Passare un array per riferimento

Come passa una matrice allocata staticamente per lavoro di riferimento?

void foo(int (&myArray)[100]) { } int main() { int a[100]; foo(a); } 

Does (&myArray)[100] ha qualche significato o è solo una syntax per passare qualsiasi matrice per riferimento? Non capisco parentesi separata seguita da parentesi quadre qui. Grazie.

È una syntax per i riferimenti di array – è necessario utilizzare (&array) per chiarire al compilatore che si desidera un riferimento a una matrice, piuttosto che la matrice (non valida) di riferimenti int & array[100]; .

EDIT: alcuni chiarimenti.

 void foo(int * x); void foo(int x[100]); void foo(int x[]); 

Questi tre sono modi diversi per dichiarare la stessa funzione. Sono tutti trattati come se int * un parametro int * , puoi passare a qualsiasi array di dimensioni.

 void foo(int (&x)[100]); 

Questo accetta solo matrici di 100 interi. Puoi tranquillamente usare sizeof su x

 void foo(int & x[100]); // error 

Questo viene analizzato come una “matrice di riferimenti” – che non è legale.

È solo la syntax richiesta:

 void Func(int (&myArray)[100]) 

^ Passare una matrice di 100 int con riferimento al nome dei parametri è myArray ;

 void Func(int* myArray) 

^ Passa un array. La matrice decade in un puntatore. Quindi perdi le informazioni sulla dimensione.

 void Func(int (*myFunc)(double)) 

^ Passa un puntatore a funzione. La funzione restituisce un int e prende un double . Il nome del parametro è myFunc .

È una syntax. Nella funzione argomenti int (&myArray)[100] parentesi che racchiudono &myArray sono necessari. se non li usi, passerai una array of references e questo è dovuto al fatto che l’ subscript operator [] ha precedenza più alta sull’operatore & operator .

Ad esempio int &myArray[100] // array of references

Quindi, usando type construction () dici al compilatore che vuoi un riferimento a un array di 100 interi.

Per esempio int (&myArray)[100] // reference of an array of 100 ints

Le matrici sono predefinite passate da puntatori. Puoi provare a modificare un array all’interno di una chiamata di funzione per una migliore comprensione.