Comment puis-je déterminer la taille de mon tableau en C?

Question

Comment puis-je déterminer la taille de mon tableau en C?

C'est le nombre d'éléments du tableau peut contenir?

Answer 1

résumé:

int a[17];
n = sizeof(a)/sizeof(a[0]);

Pour déterminer la taille de votre tableau en octets, vous pouvez utiliser l' sizeof opérateur:

int a[17];
int n = sizeof(a);

Sur mon ordinateur, ints sont 4 octets de long, de sorte que n est de 68.

Pour déterminer le nombre d'éléments dans le tableau, nous pouvons diviser la taille totale de la matrice par la taille de l'élément de tableau. Vous pouvez le faire avec le type, comme ceci:

int a[17];
int n = sizeof(a) / sizeof(int);

et d'obtenir la bonne réponse (68 / 4 = 17), mais si le type de a changé, vous aurait un méchant bug si vous avez oublié de changer l' sizeof(int) .

Donc, préféré le diviseur est - sizeof(a[0]), la taille de la élément de zeroeth de la matrice.

int a[17];
int n = sizeof(a) / sizeof(a[0]);

Un autre avantage est que vous pouvez maintenant facilement paramétrer le nom du tableau dans une macro et obtenez:

#define NELEMS(x)  (sizeof(x) / sizeof(x[0]))

int a[17];
int n = NELEMS(a);

Answer 2

L' sizeof bonne façon de le forum vous traitez avec des matrices non reçus en tant que paramètres. Un tableau transmis comme paramètre à une fonction est considéré comme un pointeur, donc, sizeof sera de retour le pointeur de taille, au lieu de la matrice.

Ainsi, à l'intérieur des fonctions de cette méthode ne fonctionne pas. Au lieu de cela, toujours passer un paramètre supplémentaire size_t size indiquant le nombre d'éléments dans le tableau.

Test:

#include <stdio.h>
#include <stdlib.h>

void printSizeOf(int intArray[]);
void printLength(int intArray[]);

int main(int argc, char* argv[])
{
    int array[] = { 0, 1, 2, 3, 4, 5, 6 };

    printf("sizeof of array: %d\n", sizeof(array));
    printSizeOf(array);

    printf("Length of array: %d\n", sizeof(array) / sizeof(array[0]));
    printLength(array);
}

void printSizeOf(int intArray[])
{
    printf("sizeof of parameter: %d\n", sizeof(intArray));
}

void printLength(int intArray[])
{
    printf("Length of parameter: %d\n", sizeof(intArray) / sizeof(intArray[0]));
}

De sortie (en 64 bits système d'exploitation Linux):

sizeof of array: 28
sizeof of parameter: 8
Length of array: 7
Length of parameter: 2

Answer 3

Il est intéressant de noter que, sizeof n'est pas vous aider si vous faites affaire avec un pointeur sur un tableau:

int a[10];
int* p = a;

assert(sizeof(a) / sizeof(a[0]) == 10);
assert(sizeof(p) == sizeof(void*));

---

@Skizz: Le standard gagne sur Wikipédia, n'importe quel jour de la semaine :)

@DrPizza: Wikipédia n'est pas en contradiction qu' sizeof(char) est de 1. En fait, l'article définit qu' sizeof(char) est 1 en disant qu' sizeof est par rapport à la taille de char. (Noter la différence entre la "taille de char" et "sizeof(char)" :)

Ainsi, alors que sizeof(char) == 1, qui n'implique pas nécessairement qu'un char occupe exactement un octet en mémoire. (Mais la norme apparemment le dit explicitement, nous sommes donc bon)

Answer 4

Le sizeof "truc" est le meilleur moyen que je connaisse, avec une petite mais (pour moi, cela étant l'un des principaux bête noire) changement important dans l'utilisation de parenthèses.

Comme l'entrée de Wikipedia, C sizeof n'est pas une fonction, c'est un opérateur. Ainsi, il ne nécessite pas de parenthèses autour de son argument, à moins que l'argument est un nom de type. C'est facile à retenir, car il rend l'argument de ressembler à une fonte d'expression, qui utilise également la parenthèse.

Donc: Si vous avez le suivant:

int myArray[10];

Vous pouvez trouver le nombre d'éléments avec un code comme ceci:

size_t n = sizeof myArray / sizeof *myArray;

Qui, pour moi, qui lit beaucoup plus facile que l'autre avec la parenthèse. J'ai également en faveur de l'utilisation de l'astérisque dans la partie droite de la division, car il est plus concis que l'indexation.

Bien sûr, tout ceci est une compilation de trop, donc il n'y a pas besoin de s'inquiéter à propos de la division qui affectent la performance du programme. Il faut donc utiliser ce formulaire où vous le pouvez.

Il est toujours préférable d'utiliser sizeof sur un objet réel lorsque vous en avez un, plutôt que sur un type, depuis, vous n'avez pas besoin de vous soucier de faire une erreur et en précisant le type incorrect.

Par exemple, disons que vous avez une fonction qui affiche des données en un flux d'octets, par exemple à travers un réseau. Nous allons appeler la fonction send(), et d'en faire prendre comme argument un pointeur vers l'objet à envoyer, et le nombre d'octets dans l'objet. Ainsi, le prototype devient:

void send(const void *object, size_t size);

Et puis vous avez besoin d'envoyer un nombre entier, de sorte que vous code comme ceci:

int foo = 4711;
send(&foo, sizeof (int));

Maintenant, vous avez introduit une subtile façon de se tirer une balle dans le pied, en précisant le type d' foo dans les deux endroits. Si on change, mais l'autre ne fonctionne pas, le code des pauses. Ainsi, toujours faire comme ceci:

send(&foo, sizeof foo);

Maintenant, vous êtes protégé. Bien sûr, vous dupliquez le nom de la variable, mais qui a une forte probabilité de rupture d'une façon que le compilateur peut détecter, si vous le changez.

Answer 5

int size = (&arr)[1] - arr;

Consultez ce lien pour l'explication