Pourquoi la taille d'un paramètre de tableau n'est-elle pas la même que dans main?

Pourquoi la taille d'un tableau envoyé en tant que paramètre n'est-elle pas la même que dans main?

#include <stdio.h>

void PrintSize(int p_someArray[10]);

int main () {
    int myArray[10];
    printf("%d\n", sizeof(myArray)); /* As expected, 40 */
    PrintSize(myArray);/* Prints 4, not 40 */
}

void PrintSize(int p_someArray[10]){
    printf("%d\n", sizeof(p_someArray));
}

Un type tableau est implicitement converti en type pointeur lorsque vous le transmettez à une fonction.

Alors,

void PrintSize(int p_someArray[10]) {
    printf("%zu\n", sizeof(p_someArray));
}

et

void PrintSize(int *p_someArray) {
    printf("%zu\n", sizeof(p_someArray));
}

sont équivalents. Donc, ce que vous obtenez est la valeur desizeof(int*)

C'est un pointeur, c'est pourquoi c'est une implémentation courante de passer la taille du tableau comme deuxième paramètre à la fonction

Comme d'autres l'ont indiqué, les tableaux se désintègrent en pointeurs vers leur premier élément lorsqu'ils sont utilisés comme paramètres de fonction. Il convient également de noter que sizeof n'évalue pas l'expression et ne nécessite pas de parenthèses lorsqu'il est utilisé avec une expression, de sorte que votre paramètre n'est pas du tout utilisé, vous pouvez donc aussi bien écrire le sizeof avec le type plutôt que la valeur.

#include <stdio.h>

void PrintSize1 ( int someArray[][10] );
void PrintSize2 ( int someArray[10] );

int main ()
{
    int myArray[10];
    printf ( "%d\n", sizeof myArray ); /* as expected 40 */
    printf ( "%d\n", sizeof ( int[10] ) ); /* requires parens */
    PrintSize1 ( 0 ); /* prints 40, does not evaluate 0[0] */
    PrintSize2 ( 0 ); /* prints 40, someArray unused */
}

void PrintSize1 ( int someArray[][10] )
{
    printf ( "%d\n", sizeof someArray[0] );
}

void PrintSize2 ( int someArray[10] )
{
    printf ( "%d\n", sizeof ( int[10] ) );
}

Donc, vous devrez passer la longueur du tableau comme deuxième paramètre. Lorsque vous écrivez du code, dans lequel vous déclarez tous les deux un tableau de taille constante, puis passez ce tableau à une fonction, il est pénible de voir la constante de longueur de tableau apparaître à plusieurs endroits dans votre code ...

K&R à la rescousse:

#define N_ELEMENTS(array) (sizeof(array)/sizeof((array)[0])) 

Alors maintenant, vous pouvez faire par exemple:

int a[10];
...
myfunction(a, N_ELEMENTS(a));

Parce que les tableaux se désintègrent en pointeurs lorsqu'ils sont passés en paramètres. C'est ainsi que fonctionne C, bien que vous puissiez passer des «tableaux» en C ++ par référence et résoudre ce problème. Notez que vous pouvez passer des tableaux de différentes tailles à cette fonction:

 // 10 is superfluous here! You can pass an array of different size!
void PrintSize(int p_someArray[10]);

Le comportement que vous avez trouvé est en fait une grosse verrue en langage C. Chaque fois que vous déclarez une fonction qui prend un paramètre de tableau, le compilateur vous ignore et change le paramètre en pointeur. Donc, ces déclarations se comportent toutes comme la première:

void func(int *a)
void func(int a[])
void func(int a
typedef int array_plz[5];
void func(array_plz a)

a sera un pointeur vers int dans les quatre cas. Si vous passez un tableau à func, il se désintégrera immédiatement en un pointeur vers son premier élément. (Sur un système 64 bits, un pointeur 64 bits est deux fois plus grand qu'un entier 32 bits, donc votre ratio sizeof renvoie 2.)

Le seul objectif de cette règle est de maintenir la compatibilité ascendante avec les compilateurs historiques qui ne prenaient pas en charge le passage de valeurs d'agrégation en tant qu'arguments de fonction.

Cela ne signifie pas qu'il est impossible de passer un tableau à une fonction. Vous pouvez contourner cette verrue en incorporant le tableau dans une structure (c'est essentiellement le but de std :: array de C ++ 11):

struct array_rly {
int a[5];
};
void func(struct array_rly a)
{
printf("%zd\n", sizeof(a.a)/sizeof(a.a[0]));  /* prints 5 */
}

ou en passant un pointeur vers le tableau:

void func(const int (*a)[5])
{
printf("%zd\n", sizeof(*a)/sizeof((*a)[0]));  /* prints 5 */
}

Dans le cas où la taille du tableau n'est pas une constante de compilation, vous pouvez utiliser la technique du pointeur vers un tableau avec des tableaux de longueur variable C99:

void func(int n, const int (*a)[n])
{
printf("%zd\n", sizeof(*a)/sizeof((*a)[0]));  /* prints n */
}

En C ++, vous pouvez passer un tableau par référence dans ce but précis:

void foo(int (&array)[10])
{
    std::cout << sizeof(array) << "\n";
}

En langage C, il n'y a pas de méthode pour déterminer la taille d'un tableau inconnu, donc la quantité doit être transmise ainsi qu'un pointeur vers le premier élément.

Vous ne pouvez pas passer de tableaux à des fonctions.

Si vous voulez vraiment imprimer la taille, vous pouvez passer un pointeur vers un tableau, mais ce ne sera pas du tout générique car vous devez également définir la taille du tableau pour la fonction.

#include <stdio.h>

void PrintSize(int (*p_anArray)[10]);

int main(void) {
    int myArray[10];
    printf("%d\n", sizeof(myArray)); /* as expected 40 */
    PrintSize(&myArray);/* prints 40 */
}

void PrintSize(int (*p_anArray)[10]){
    printf("%d\n", (int) sizeof(*p_anArray));
}

Le comportement est voulu par la conception.

La même syntaxe dans la déclaration des paramètres de fonction signifie une chose complètement différente de la définition de variable locale.

La raison est décrite dans d'autres réponses.

En langage C, lorsque vous passez le tableau en argument à la fonction, il est automatiquement converti en pointeur, le tableau passant d'une fonction à une autre fonction est appelé appel par référence. C'est la raison pour laquelle la fonction appelée ne reçoit que le pointeur qui pointe vers le premier élément de la fonction C'est la raison

fun (int a []) est similaire à fun (int * a);

Ainsi, lorsque vous imprimez la taille du tableau, il imprimera la taille du premier élément.

Dans la langue de programmation 'C' 'sizeof ()' est l'opérateur et il renvoie la taille de l'objet en octets.L'argument de l'opérateur 'sizeof ()' doit être un type à valeur gauche (entier, nombre flottant, struct, tableau Donc, si vous voulez connaître la taille d'un tableau en octets, vous pouvez le faire très simplement.Utilisez simplement l'opérateur 'sizeof ()' et pour son argument utilisez le nom du tableau.Par exemple:

#include <stdio.h>

main(){

 int n[10];
 printf("Size of n is: %d \n", sizeof(n)); 

}

La sortie sur un système 32 bits sera: La taille de n est: 40.Parce que l'ineteger sur le système 32 est de 4 octets.Sur 64x, il est de 8 octets.Dans ce cas, nous avons 10 entiers déclarés dans un tableau.Le résultat est donc '10 * sizeof ( int) '.

Quelques conseils:

Si nous avons un tableau déclaré comme celui-ci 'int n [] = {1, 2, 3, ... 155 ..};'. Nous voulons donc savoir combien d'éléments sont stockés dans ce tableau. Utilisez cet alghorithme:

sizeof (nom_du_array) / sizeof (type_tableau)

Code: #include

principale(){

int n[] = { 1, 2, 3, 44, 6, 7 };
printf("Number of elements: %d \n", sizeof(n) / sizeof(int));
return 0;

}

Les tableaux ne sont que faiblement dimensionnés. Pour la plupart, un tableau est un pointeur vers la mémoire. La taille dans votre déclaration indique uniquement au compilateur la quantité de mémoire à allouer pour le tableau - elle n'est pas associée au type, donc sizeof () n'a rien à faire.