Array/pointeur/référence confusion

Question

Possible en double:
Confusion over C++ pointer and reference topic

Supposons que je passe

int arr[10]; 

en tant que paramètre à une fonction.

Tous ces prototypes de fonctions sont-ils valides? En quoi diffèrent-ils en termes d'arguments et pourquoi?

C'est ce que je sais à ce jour (pas sûr si elle est correcte ou non)

1. void foo(int &arr);  //a reference to an array, which preserve the size attribute? 
2. void foo(int &arr[]); //the same (is it)? 
3. void foo(int (&arr)[]); //I don't know 
4. void foo(int &arr[10]); //is it the same as 2? 
5. void foo(int (&arr)[10]);//no idea 

6. void foo(int *arr);  //a decayed pointer of the array, pointing to the first element of the array, losing the size attribute? 

7. void foo(int *arr[]); //the same (is it?) 
8. void foo(int (*arr)[]); //a pointer to an array, preserve the size 
9. void foo(int *arr[10]); //the same as 7 (is it?) 
10. void foo(int (*arr)[10]);//is the same as 8 (is it?) 

11. void foo(int arr[]); //is the same as 6 (is it?) 
12. void foo(int arr[10]); // is the same as 6 (is it?) 

(Je sais que cela aura besoin d'une longue explication, désolé, je suis totalement confus ...)

Answer 1

La première information importante est que les paramètres dont le type est un tableau (borné ou non) de T sont transformés en pointeurs en T. C'est à dire. les deux int arr[] et int arr[10] sont transformés en int * arr. Notez que la transformation est uniquement effectuée sur des tableaux de niveau supérieur, c'est-à-dire qu'elle ne se produit pas dans int (*arr)[10], qui est un pointeur vers un tableau d'int.

En outre, les éléments situés à droite de l'identificateur se lient plus étroitement que les éléments situés à gauche, c'est-à-dire que int *arr[10] est un tableau, alors que int (*arr)[10] est un pointeur. Enfin, les tableaux et les pointeurs vers des références ne sont pas valides, tout comme les pointeurs et les références à des tableaux non bornés.

1. void foo(int &arr);  // can't pass, reference to int 
2. void foo(int &arr[]);  // invalid, pointer to reference to int 
3. void foo(int (&arr)[]); // invalid, reference to unbounded array of int 
4. void foo(int &arr[10]); // invalid, pointer to reference to int 
5. void foo(int (&arr)[10]); // can pass, reference to an array of int 

6. void foo(int *arr);  // can pass, pointer to int 
7. void foo(int *arr[]);  // can't pass, pointer to pointer to int 
8. void foo(int (*arr)[]); // invalid, pointer to an unbounded array of int. 
9. void foo(int *arr[10]); // can't pass, pointer to pointer to int 
10. void foo(int (*arr)[10]); // can't pass, pointer to array of int 

11. void foo(int arr[]);  // can pass, pointer to int 
12. void foo(int arr[10]); // can pass, same as above 

En utilisant arr comme argument pour foo le fera à la pourriture à un pointeur vers son premier élément - la valeur passée à foo sera de type int *. Notez que vous pouvez passer &arr au numéro 10, auquel cas une valeur de type int (*)[10] sera transmise et aucune désintégration ne se produira.

Answer 2

La partie difficile est de considérer que le tableau ne passe pas par la valeur, mais se désintègre en pointeurs.

Une partie de votre déclaration sont des erreurs de syntaxe, d'autres ne sont pas (mais ne sont pas non plus ce que vous pensez probablement)

Dans votre cas, Teh seule qui ont du sens sont 6, 11 et 12.

2, 3, 4 et 8 ont des messages d'erreur explicites. (Si vous ne comprenez pas est le plus probablement parce que vous avez lu la déclaration avec une mauvaise priorité de l'opérateur)

t1.cpp:2:19: error: declaration of 'arr' as array of references 
t1.cpp:3:22: error: parameter 'arr' includes reference to array of unknown bound 'int []' 
t1.cpp:4:21: error: declaration of 'arr' as array of references 
t1.cpp:8:22: error: parameter 'arr' includes pointer to array of unknown bound 'int []' 

Les autres sont en quelque sorte redondant (référence à un tableau ou -pointer-, ils se comporteront les mêmes à l'intérieur de la fonction) ou tout simplement faux parce que déclarer quelque chose de différent comme vous l'entendez (comme 7,9,10: ils représentent une "double indirection", alors qu'un tableau simple en a un seul, et 1. cela ne représente aucune indirection: il ne fait qu'alias un seul int)