Signification de *& et **& en C++.

Question

J'ai trouvé plusieurs fois ces symboles dans une déclaration de fonction, mais je ne sais pas ce qu'ils signifient.

Ejemplo:

void raccogli_dati(double **& V, double **p, int N) { 
  int ultimo = 3; 
  V = new double * [N/2]; 
  for(int i=0; i < N/2; i++) { 
    V[i] = new double[N/2], std :: clog << "digita " << N/2 - i
                 << " valori per la parte superiore della matrice V: "; 
    for(int j=i; j < N/2; j++) 
      std :: cin >> V[i][j], p[ultimo++][0] = (V[i][j] /= sqrt(p[i][0]*p[j][0]));
  } 
  for(int i=1; i < N/2; i++) 
    for(int j=0; j < i; j++) 
       V[i][j] = V[j][i];
}

Answer 1

C'est prendre le paramètre par référence. Ainsi, dans le premier cas, vous prenez un paramètre de type pointeur par référence et toute modification apportée à la valeur du pointeur est répercutée en dehors de la fonction. Le deuxième cas est similaire au premier, la seule différence étant qu'il s'agit d'un double pointeur. Voir cet exemple :

void pass_by_value(int* p)
{
    //Allocate memory for int and store the address in p
    p = new int;
}

void pass_by_reference(int*& p)
{
    p = new int;
}

int main()
{
    int* p1 = NULL;
    int* p2 = NULL;

    pass_by_value(p1); //p1 will still be NULL after this call
    pass_by_reference(p2); //p2 's value is changed to point to the newly allocate memory

    return 0;
}

Answer 2

Le premier est une référence à un pointeur, le second est une référence à un pointeur à un pointeur. Voir aussi la FAQ sur la différence entre les pointeurs et les références .

void foo(int*& x, int**& y) {
    // modifying x or y here will modify a or b in main
}

int main() {
    int val = 42;
    int *a  = &val;
    int **b = &a;

    foo(a, b);
    return 0;
}

Answer 3

C'est passer un pointeur par référence plutôt que par valeur. Cela permet par exemple de modifier le pointeur (et non l'objet pointé) dans la fonction de manière à ce que le code appelant voie le changement.

Comparez :

void nochange( int* pointer ) //passed by value
{
   pointer++; // change will be discarded once function returns
}

void change( int*& pointer ) //passed by reference
{
   pointer++; // change will persist when function returns
}

Answer 4

Un site int* est un pointeur vers un int donc int*& doit être une référence à un pointeur sur une int . De même, int** est un pointeur sur un pointeur sur une int donc int**& doit être une référence à un pointeur à un pointeur à une int .

Answer 5

Pour comprendre ces phrases, examinons quelques éléments :

typedef double Foo;
void fooFunc(Foo &_bar){ ... }

Donc c'est passer un double par référence.

typedef double* Foo;
void fooFunc(Foo &_bar){ ... }

maintenant il passe un pointeur à un double par référence.

typedef double** Foo;
void fooFunc(Foo &_bar){ ... }

Enfin, il s'agit de passer un pointeur sur un pointeur sur un double par référence. Si vous pensez en termes de typedefs comme celui-ci, vous comprendrez l'ordre correct des & et * ainsi que leur signification.