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

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

Autrement dit, le nombre d'éléments que le tableau peut contenir?

Résumé:

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

Réponse complète:

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

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

Sur mon ordinateur, les entiers font 4 octets, donc n est 68.

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

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

et obtenez la bonne réponse (68/4 = 17), mais si le type de achangement vous aurait un méchant bug si vous oubliez de le changer sizeof(int)aussi.

Ainsi, le diviseur préféré est sizeof(a[0])ou l'équivalent sizeof(*a), la taille du premier élément du tableau.

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

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

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

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

La sizeofmanière est la bonne, si vous traitez des tableaux non reçus comme paramètres. Un tableau envoyé en tant que paramètre à une fonction est traité comme un pointeur, il sizeofretournera donc la taille du pointeur au lieu de celle du tableau.

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

Tester:

#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", (int) sizeof(array));
    printSizeOf(array);

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

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

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

Sortie (dans un système d'exploitation Linux 64 bits):

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

Sortie (dans un système d'exploitation Windows 32 bits):

sizeof of array: 28
sizeof of parameter: 4
Length of array: 7
Length of parameter: 1

Il convient de noter que cela sizeofn'aide pas lorsqu'il s'agit d'une valeur de tableau qui s'est désintégrée en un pointeur: même si elle pointe vers le début d'un tableau, pour le compilateur, c'est la même chose qu'un pointeur vers un seul élément de ce tableau . Un pointeur ne "se souvient" de rien d'autre du tableau qui a été utilisé pour l'initialiser.

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

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

La taille du "truc" est le meilleur moyen que je connaisse, avec un petit mais (pour moi, ce qui est une bête noire majeure) un changement important dans l'utilisation des parenthèses.

Comme l'indique clairement l'entrée Wikipedia, les C ne sizeofsont pas une fonction; c'est un opérateur . Ainsi, il ne nécessite pas de parenthèses autour de son argument, sauf si l'argument est un nom de type. Ceci est facile à retenir, car il fait ressembler l'argument à une expression cast, qui utilise également des parenthèses.

Donc: si vous avez les éléments suivants:

int myArray[10];

Vous pouvez trouver le nombre d'éléments avec du code comme celui-ci:

size_t n = sizeof myArray / sizeof *myArray;

Pour moi, cela se lit beaucoup plus facilement que l'alternative avec parenthèses. Je suis également favorable à 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 cela est également au moment de la compilation, il n'est donc pas nécessaire de s'inquiéter de la division affectant les performances du programme. Utilisez donc ce formulaire partout 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, car vous n'avez alors pas à vous soucier de faire une erreur et d'indiquer le mauvais type.

Par exemple, supposons que vous ayez une fonction qui génère des données sous forme de flux d'octets, par exemple sur un réseau. Appelons la fonction send()et faisons en sorte qu'elle prenne comme arguments 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 devez envoyer un entier, donc vous le codez comme ceci:

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

Maintenant, vous avez introduit une manière subtile de vous tirer une balle dans le pied, en spécifiant le type de fooà deux endroits. Si l'un change mais pas l'autre, le code se casse. Ainsi, faites-le toujours comme ceci:

send(&foo, sizeof foo);

Maintenant tu es protégé. Bien sûr, vous dupliquez le nom de la variable, mais cela a une forte probabilité de se casser d'une manière que le compilateur peut détecter, si vous la changez.

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

Consultez ce lien pour des explications

Vous pouvez utiliser l'opérateur sizeof mais cela ne fonctionnera pas pour les fonctions car il prendra la référence du pointeur, vous pouvez faire ce qui suit pour trouver la longueur d'un tableau:

len = sizeof(arr)/sizeof(arr[0])

Code trouvé à l'origine ici: programme C pour trouver le nombre d'éléments dans un tableau

Si vous connaissez le type de données du tableau, vous pouvez utiliser quelque chose comme:

int arr[] = {23, 12, 423, 43, 21, 43, 65, 76, 22};

int noofele = sizeof(arr)/sizeof(int);

Ou si vous ne connaissez pas le type de données du tableau, vous pouvez utiliser quelque chose comme:

noofele = sizeof(arr)/sizeof(arr[0]);

Remarque: Cette chose ne fonctionne que si le tableau n'est pas défini au moment de l'exécution (comme malloc) et que le tableau n'est pas passé dans une fonction. Dans les deux cas, arr(nom du tableau) est un pointeur.

La macro ARRAYELEMENTCOUNT(x)que tout le monde utilise n'évalue pas correctement . En réalité, ceci est juste une question sensible, car vous ne pouvez pas avoir d'expressions qui aboutissent à un type «tableau».

/* Compile as: CL /P "macro.c" */
# define ARRAYELEMENTCOUNT(x) (sizeof (x) / sizeof (x[0]))

ARRAYELEMENTCOUNT(p + 1);

Évalue en fait:

(sizeof (p + 1) / sizeof (p + 1[0]));

Tandis que

/* Compile as: CL /P "macro.c" */
# define ARRAYELEMENTCOUNT(x) (sizeof (x) / sizeof (x)[0])

ARRAYELEMENTCOUNT(p + 1);

Il évalue correctement:

(sizeof (p + 1) / sizeof (p + 1)[0]);

Cela n'a vraiment pas grand-chose à voir avec la taille des tableaux explicitement. Je viens de remarquer beaucoup d'erreurs de ne pas vraiment observer le fonctionnement du préprocesseur C. Vous encapsulez toujours le paramètre de macro dans lequel aucune expression ne peut être impliquée.

C'est correct; mon exemple était mauvais. Mais c'est exactement ce qui devrait arriver. Comme je l'ai mentionné précédemment, cela p + 1se terminera comme un type de pointeur et invalidera la macro entière (comme si vous tentiez d'utiliser la macro dans une fonction avec un paramètre de pointeur).

À la fin de la journée, dans ce cas particulier , la faute n'a pas vraiment d'importance (donc je perds juste le temps de tout le monde; huzzah!), Parce que vous n'avez pas d'expressions avec un type de 'tableau'. Mais vraiment, le point sur les subtils d'évaluation du préprocesseur est, je pense, important.

Pour les tableaux multidimensionnels, c'est un peu plus compliqué. Souvent, les gens définissent des constantes macro explicites, c.-à-d.

#define g_rgDialogRows   2
#define g_rgDialogCols   7

static char const* g_rgDialog[g_rgDialogRows][g_rgDialogCols] =
{
    { " ",  " ",    " ",    " 494", " 210", " Generic Sample Dialog", " " },
    { " 1", " 330", " 174", " 88",  " ",    " OK",        " " },
};

Mais ces constantes peuvent également être évaluées au moment de la compilation avec sizeof :

#define rows_of_array(name)       \
    (sizeof(name   ) / sizeof(name[0][0]) / columns_of_array(name))
#define columns_of_array(name)    \
    (sizeof(name[0]) / sizeof(name[0][0]))

static char* g_rgDialog[][7] = { /* ... */ };

assert(   rows_of_array(g_rgDialog) == 2);
assert(columns_of_array(g_rgDialog) == 7);

Notez que ce code fonctionne en C et C ++. Pour les tableaux de plus de deux dimensions, utilisez

sizeof(name[0][0][0])
sizeof(name[0][0][0][0])

etc., à l'infini.

sizeof(array) / sizeof(array[0])

Taille d'un tableau en C:

int a[10];
size_t size_of_array = sizeof(a);      // Size of array a
int n = sizeof (a) / sizeof (a[0]);    // Number of elements in array a
size_t size_of_element = sizeof(a[0]); // Size of each element in array a                                          
                                       // Size of each element = size of type

Je conseillerais de ne jamais utiliser sizeof(même s'il peut être utilisé) pour obtenir l'une des deux tailles différentes d'un tableau, soit en nombre d'éléments soit en octets, qui sont les deux derniers cas que je montre ici. Pour chacune des deux tailles, les macros illustrées ci-dessous peuvent être utilisées pour la rendre plus sûre. La raison est de rendre évidente l'intention du code à mainteneurs, et la différence sizeof(ptr)de sizeof(arr)prime abord (qui écrit de cette façon est pas évident), de sorte que les insectes sont alors évident pour tout le monde à lire le code.

TL; DR:

#define ARRAY_SIZE(arr)     (sizeof(arr) / sizeof((arr)[0]) + must_be_array(arr))

#define ARRAY_SSIZE(arr)    ((ptrdiff_t)ARRAY_SIZE(arr))

#define ARRAY_BYTES(arr)    (sizeof((arr)[0]) * ARRAY_SIZE(arr))

must_be_array(arr)(défini ci-dessous) EST nécessaire en tant que -Wsizeof-pointer-divbuggy (en avril / 2020):

#define is_same_type(a, b)      __builtin_types_compatible_p(typeof(a), typeof(b))
#define is_array(a)             (!is_same_type((a), &(a)[0]))
#define Static_assert_array(a)  _Static_assert(is_array(a), "Not a `[]` !")
#define must_be_array(a)        (                                       \
        0 * (int)sizeof(                                                \
                struct {                                                \
                        Static_assert_array(a);                         \
                        char ISO_C_forbids_a_struct_with_no_members__;  \
                }                                                       \
        )                                                               \
)

Il y a eu des bugs importants concernant ce sujet: https://lkml.org/lkml/2015/9/3/428

Je ne suis pas d'accord avec la solution proposée par Linus, qui consiste à ne jamais utiliser la notation matricielle pour les paramètres des fonctions.

J'aime la notation de tableau comme documentation qu'un pointeur est utilisé comme tableau. Mais cela signifie qu'une solution infaillible doit être appliquée pour qu'il soit impossible d'écrire du code bogué.

À partir d'un tableau, nous avons trois tailles que nous pourrions vouloir savoir:

• La taille des éléments du tableau
• Le nombre d'éléments dans le tableau
• La taille en octets que le tableau utilise en mémoire

La taille des éléments du tableau

Le premier est très simple, et cela n'a pas d'importance si nous avons affaire à un tableau ou à un pointeur, car c'est fait de la même manière.

Exemple d'utilisation:

void foo(ptrdiff_t nmemb, int arr[static nmemb])
{
        qsort(arr, nmemb, sizeof(arr[0]), cmp);
}

qsort() a besoin de cette valeur comme troisième argument.

Pour les deux autres tailles, qui sont le sujet de la question, nous voulons nous assurer que nous avons affaire à un tableau, et casser la compilation sinon, car si nous avons affaire à un pointeur, nous obtiendrons des valeurs erronées . Lorsque la compilation est interrompue, nous pourrons facilement voir que nous n'avons pas affaire à un tableau, mais à un pointeur à la place, et nous devrons simplement écrire le code avec une variable ou une macro qui stocke la taille du tableau derrière le pointeur.

Le nombre d'éléments dans le tableau

Celui-ci est le plus courant, et de nombreuses réponses vous ont fourni la macro typique ARRAY_SIZE:

#define ARRAY_SIZE(arr)     (sizeof(arr) / sizeof((arr)[0]))

Étant donné que le résultat de ARRAY_SIZE est couramment utilisé avec des variables de type signées ptrdiff_t, il est bon de définir une variante signée de cette macro:

#define ARRAY_SSIZE(arr)    ((ptrdiff_t)ARRAY_SIZE(arr))

Les tableaux avec plus de PTRDIFF_MAXmembres vont donner des valeurs invalides pour cette version signée de la macro, mais à la lecture de C17 :: 6.5.6.9, des tableaux comme celui-ci jouent déjà avec le feu. Uniquement ARRAY_SIZEet size_tdoit être utilisé dans ces cas.

Les versions récentes de compilateurs, tels que GCC 8, vous avertiront lorsque vous appliquerez cette macro à un pointeur, elle est donc sûre (il existe d'autres méthodes pour la sécuriser avec des compilateurs plus anciens).

Il fonctionne en divisant la taille en octets de l'ensemble du tableau par la taille de chaque élément.

Exemples d'utilisation:

void foo(ptrdiff_t nmemb)
{
        char buf[nmemb];

        fgets(buf, ARRAY_SIZE(buf), stdin);
}

void bar(ptrdiff_t nmemb)
{
        int arr[nmemb];

        for (ptrdiff_t i = 0; i < ARRAY_SSIZE(arr); i++)
                arr[i] = i;
}

Si ces fonctions n'utilisaient pas de tableaux, mais les obtenaient à la place comme paramètres, l'ancien code ne se compilerait pas, il serait donc impossible d'avoir un bogue (étant donné qu'une version récente du compilateur est utilisée, ou qu'une autre astuce est utilisée) , et nous devons remplacer l'appel de macro par la valeur:

void foo(ptrdiff_t nmemb, char buf[nmemb])
{

        fgets(buf, nmemb, stdin);
}

void bar(ptrdiff_t nmemb, int arr[nmemb])
{

        for (ptrdiff_t i = 0; i < nmemb; i++)
                arr[i] = i;
}

La taille en octets que le tableau utilise en mémoire

ARRAY_SIZE est couramment utilisé comme solution au cas précédent, mais ce cas est rarement écrit en toute sécurité, peut-être parce qu'il est moins courant.

La manière courante d'obtenir cette valeur est d'utiliser sizeof(arr). Le problème: le même qu'avec le précédent; si vous avez un pointeur au lieu d'un tableau, votre programme deviendra fou.

La solution au problème consiste à utiliser la même macro que précédemment, que nous savons être sûre (elle rompt la compilation si elle est appliquée à un pointeur):

#define ARRAY_BYTES(arr)        (sizeof((arr)[0]) * ARRAY_SIZE(arr))

Son fonctionnement est très simple: il annule la division qui le ARRAY_SIZEfait, donc après des annulations mathématiques, vous vous retrouvez avec une seule sizeof(arr), mais avec la sécurité supplémentaire de la ARRAY_SIZEconstruction.

Exemple d'utilisation:

void foo(ptrdiff_t nmemb)
{
        int arr[nmemb];

        memset(arr, 0, ARRAY_BYTES(arr));
}

memset() a besoin de cette valeur comme troisième argument.

Comme précédemment, si le tableau est reçu en paramètre (un pointeur), il ne se compilera pas, et nous devrons remplacer l'appel de macro par la valeur:

void foo(ptrdiff_t nmemb, int arr[nmemb])
{

        memset(arr, 0, sizeof(arr[0]) * nmemb);
}

Mise à jour (23 / avril / 2020): -Wsizeof-pointer-divest buggé :

Aujourd'hui, j'ai découvert que le nouvel avertissement dans GCC ne fonctionne que si la macro est définie dans un en-tête qui n'est pas un en-tête système. Si vous définissez la macro dans un en-tête installé sur votre système (généralement /usr/local/include/ou /usr/include/) ( #include <foo.h>), le compilateur n'émettra PAS d'avertissement (j'ai essayé GCC 9.3.0).

Nous avons donc #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))et voulons le rendre sûr. Nous aurons besoin de C11 _Static_assert()et de quelques extensions GCC: déclarations et déclarations dans les expressions , __builtin_types_compatible_p :

#define is_same_type(a, b)      __builtin_types_compatible_p(typeof(a), typeof(b))
#define is_array(a)             (!is_same_type((a), &(a)[0]))
#define Static_assert_array(a)  _Static_assert(is_array(a), "Not a `[]` !")

#define ARRAY_SIZE(arr)         (                                       \
{                                                                       \
        Static_assert_array(arr);                                       \
        sizeof(arr) / sizeof((arr)[0]);                                \
}                                                                       \
)

Maintenant, ARRAY_SIZE()c'est complètement sûr, et donc tous ses dérivés seront sûrs.

Mise à jour: libbsd fournit __arraycount():

Libbsd fournit la macro __arraycount()dans <sys/cdefs.h>, ce qui est dangereux parce qu'il manque une paire de parenthèses, mais nous pouvons ajouter ces parenthèses nous - mêmes, et donc nous ne même pas besoin d'écrire la division dans notre tête (pourquoi nous dupliquer du code qui existe déjà? ). Cette macro est définie dans un en-tête système, donc si nous l'utilisons, nous sommes obligés d'utiliser les macros ci-dessus.

#include <sys/cdefs.h>


#define is_same_type(a, b)      __builtin_types_compatible_p(typeof(a), typeof(b))
#define is_array(a)             (!is_same_type((a), &(a)[0]))
#define Static_assert_array(a)  _Static_assert(is_array(a), "Not a `[]` !")

#define ARRAY_SIZE(arr)         (                                       \
{                                                                       \
        Static_assert_array(arr);                                       \
        __arraycount((arr));                                            \
}                                                                       \
)

#define ARRAY_SSIZE(arr)        ((ptrdiff_t)ARRAY_SIZE(arr))
#define ARRAY_BYTES(arr)        (sizeof((arr)[0]) * ARRAY_SIZE(arr))

Certains systèmes fournissent nitems()à la <sys/param.h>place et certains systèmes fournissent les deux. Vous devez vérifier votre système et utiliser celui que vous avez, et peut-être utiliser des conditions de préprocesseur pour la portabilité et prendre en charge les deux.

Mise à jour: autorisez la macro à être utilisée à la portée du fichier:

Malheureusement, l' ({})extension gcc ne peut pas être utilisée à la portée du fichier. Pour pouvoir utiliser la macro à la portée du fichier, l'assertion statique doit être à l'intérieur sizeof(struct {}). Ensuite, multipliez-le par 0pour ne pas affecter le résultat. Un cast to (int)pourrait être bon pour simuler une fonction qui retourne (int)0(dans ce cas, ce n'est pas nécessaire, mais il est réutilisable pour d'autres choses).

#include <sys/cdefs.h>


#define is_same_type(a, b)      __builtin_types_compatible_p(typeof(a), typeof(b))
#define is_array(a)             (!is_same_type((a), &(a)[0]))
#define Static_assert_array(a)  _Static_assert(is_array(a), "Not a `[]` !")
#define must_be_array(a)        (                                       \
        0 * (int)sizeof(                                                \
                struct {                                                \
                        Static_assert_array(a);                         \
                        char ISO_C_forbids_a_struct_with_no_members__;  \
                }                                                       \
        )                                                               \
)

#define ARRAY_SIZE(arr)         (__arraycount((arr)) + must_be_array(arr))
#define ARRAY_SSIZE(arr)        ((ptrdiff_t)ARRAY_SIZE(arr))
#define ARRAY_BYTES(arr)        (sizeof((arr)[0]) * ARRAY_SIZE(arr))

"vous avez introduit une manière subtile de vous tirer une balle dans le pied"

Les tableaux «natifs» ne stockent pas leur taille. Il est donc recommandé d'enregistrer la longueur du tableau dans une variable / const distincte et de la transmettre chaque fois que vous passez le tableau, c'est-à-dire:

#define MY_ARRAY_LENGTH   15
int myArray[MY_ARRAY_LENGTH];

Vous DEVEZ toujours éviter les tableaux natifs (sauf si vous ne pouvez pas, auquel cas, faites attention à votre pied). Si vous écrivez en C ++, utilisez le conteneur 'vector' de la STL . "Par rapport aux tableaux, ils fournissent presque les mêmes performances", et ils sont bien plus utiles!

// vector is a template, the <int> means it is a vector of ints
vector<int> numbers;  

// push_back() puts a new value at the end (or back) of the vector
for (int i = 0; i < 10; i++)
    numbers.push_back(i);

// Determine the size of the array
cout << numbers.size();

Voir: http://www.cplusplus.com/reference/stl/vector/

#define SIZE_OF_ARRAY(_array) (sizeof(_array) / sizeof(_array[0]))

Si vous voulez vraiment faire cela pour faire circuler votre tableau, je suggère d'implémenter une structure pour stocker un pointeur sur le type dont vous voulez un tableau et un entier représentant la taille du tableau. Ensuite, vous pouvez transmettre cela à vos fonctions. Attribuez simplement la valeur de la variable du tableau (pointeur au premier élément) à ce pointeur. Ensuite, vous pouvez aller Array.arr[i]chercher le i-ème élément et utiliser Array.sizepour obtenir le nombre d'éléments dans le tableau.

J'ai inclus du code pour vous. Ce n'est pas très utile mais vous pouvez l'étendre avec plus de fonctionnalités. Pour être honnête, si ce sont les choses que vous voulez, vous devez cesser d'utiliser C et utiliser un autre langage avec ces fonctionnalités intégrées.

/* Absolutely no one should use this...
   By the time you're done implementing it you'll wish you just passed around
   an array and size to your functions */
/* This is a static implementation. You can get a dynamic implementation and 
   cut out the array in main by using the stdlib memory allocation methods,
   but it will work much slower since it will store your array on the heap */

#include <stdio.h>
#include <string.h>
/*
#include "MyTypeArray.h"
*/
/* MyTypeArray.h 
#ifndef MYTYPE_ARRAY
#define MYTYPE_ARRAY
*/
typedef struct MyType
{
   int age;
   char name[20];
} MyType;
typedef struct MyTypeArray
{
   int size;
   MyType *arr;
} MyTypeArray;

MyType new_MyType(int age, char *name);
MyTypeArray newMyTypeArray(int size, MyType *first);
/*
#endif
End MyTypeArray.h */

/* MyTypeArray.c */
MyType new_MyType(int age, char *name)
{
   MyType d;
   d.age = age;
   strcpy(d.name, name);
   return d;
}

MyTypeArray new_MyTypeArray(int size, MyType *first)
{
   MyTypeArray d;
   d.size = size;
   d.arr = first;
   return d;
}
/* End MyTypeArray.c */


void print_MyType_names(MyTypeArray d)
{
   int i;
   for (i = 0; i < d.size; i++)
   {
      printf("Name: %s, Age: %d\n", d.arr[i].name, d.arr[i].age);
   }
}

int main()
{
   /* First create an array on the stack to store our elements in.
      Note we could create an empty array with a size instead and
      set the elements later. */
   MyType arr[] = {new_MyType(10, "Sam"), new_MyType(3, "Baxter")};
   /* Now create a "MyTypeArray" which will use the array we just
      created internally. Really it will just store the value of the pointer
      "arr". Here we are manually setting the size. You can use the sizeof
      trick here instead if you're sure it will work with your compiler. */
   MyTypeArray array = new_MyTypeArray(2, arr);
   /* MyTypeArray array = new_MyTypeArray(sizeof(arr)/sizeof(arr[0]), arr); */
   print_MyType_names(array);
   return 0;
}

La meilleure façon est d'enregistrer ces informations, par exemple, dans une structure:

typedef struct {
     int *array;
     int elements;
} list_s;

Implémentez toutes les fonctions nécessaires telles que créer, détruire, vérifier l'égalité et tout ce dont vous avez besoin. Il est plus facile de passer en paramètre.

La fonction sizeofrenvoie le nombre d'octets utilisé par votre tableau dans la mémoire. Si vous souhaitez calculer le nombre d'éléments dans votre tableau, vous devez diviser ce nombre par le sizeoftype de variable du tableau. Disons que int array[10];si le nombre entier de type variable de votre ordinateur est de 32 bits (ou 4 octets), pour obtenir la taille de votre tableau, vous devez procéder comme suit:

int array[10];
int sizeOfArray = sizeof(array)/sizeof(int);

Vous pouvez utiliser l' &opérateur. Voici le code source:

#include<stdio.h>
#include<stdlib.h>
int main(){

    int a[10];

    int *p; 

    printf("%p\n", (void *)a); 
    printf("%p\n", (void *)(&a+1));
    printf("---- diff----\n");
    printf("%zu\n", sizeof(a[0]));
    printf("The size of array a is %zu\n", ((char *)(&a+1)-(char *)a)/(sizeof(a[0])));


    return 0;
};

Voici l'exemple de sortie

1549216672
1549216712
---- diff----
4
The size of array a is 10

La réponse la plus simple:

#include <stdio.h>

int main(void) {

    int a[] = {2,3,4,5,4,5,6,78,9,91,435,4,5,76,7,34};//for Example only
    int size;

    size = sizeof(a)/sizeof(a[0]);//Method

    printf ("size = %d",size);
    return 0;
}

Une solution plus élégante sera

size_t size = sizeof(a) / sizeof(*a);

Outre les réponses déjà fournies, je voudrais souligner un cas particulier en utilisant

sizeof(a) / sizeof (a[0])

Si aest soit un tableau de char, unsigned charsoit signed charvous n'avez pas besoin de l'utiliser sizeofdeux fois car une sizeofexpression avec un opérande de ces types résulte toujours en 1.

Citation de C18,6.5.3.4 / 4:

« Quand sizeofon applique sur un opérande qui est de type char, unsigned char, ou signed char, (ou une version qualifiée de celui - ci) , le résultat est 1».

Ainsi, sizeof(a) / sizeof (a[0])serait équivalent à NUMBER OF ARRAY ELEMENTS / 1if aest un tableau de type char, unsigned charou signed char. La division par 1 est redondante.

Dans ce cas, vous pouvez simplement abréger et faire:

sizeof(a)

Par exemple:

char a[10];
size_t length = sizeof(a);

Si vous voulez une preuve, voici un lien vers GodBolt .

Néanmoins, la division maintient la sécurité, si le type change de manière significative (bien que ces cas soient rares).

Remarque: Celui-ci peut vous donner un comportement indéfini comme indiqué par MM dans le commentaire.

int a[10];
int size = (*(&a+1)-a) ;

Pour plus de détails, voir ici et aussi ici .