web-dev-qa-db-fra.com

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

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

Exemple:

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];
}
c++pointerssyntaxreferencesymbols
51
sdffadsf

Cela prend le paramètre par référence. Donc, dans le premier cas, vous prenez un paramètre de pointeur par référence, de sorte que toute modification que vous apportez à la valeur du pointeur se reflète en dehors de la fonction. Le deuxième est le similaire au premier, à la seule différence 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;
}
83
Naveen

Le premier est une référence à un pointeur, le second est une référence à un pointeur sur un pointeur. Voir aussi FAQ on en quoi les pointeurs et les références diffèrent .

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;
}
14
Cat Plus Plus

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

Comparer:

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
}
11
sharptooth

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

5
Oswald

*& signifie la réception du pointeur par référence. Cela signifie qu'il s'agit d'un alias pour le paramètre de passage. Donc, cela affecte le paramètre de passage.

#include <iostream>
using namespace std;

void foo(int *ptr)
{
    ptr = new int(50);    // Modifying the pointer to point to a different location
    cout << "In foo:\t" << *ptr << "\n"; 
    delete ptr ;
}

void bar(int *& ptr)
{
    ptr = new int(80);    // Modifying the pointer to point to a different location
    cout << "In bar:\t" << *ptr << "\n"; 
    // Deleting the pointer will result the actual passed parameter dangling
}
int main()
{
    int temp = 100 ;
    int *p = &temp ;

    cout << "Before foo:\t" << *p << "\n";
    foo(p) ;
    cout << "After foo:\t" << *p << "\n";

    cout << "Before bar:\t" << *p << "\n";
    bar(p) ;
    cout << "After bar:\t" << *p << "\n";

    delete p;

    return 0;
}

Sortie:

Before foo: 100
In foo: 50
After foo:  100
Before bar: 100
In bar: 80
After bar:  80
3
Mahesh

Pour comprendre ces phrases, regardons les deux choses:

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

C'est donc passer un double par référence.

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

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

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

Enfin, c'est passer un pointeur vers un pointeur vers un double par référence. Si vous pensez en termes de typedefs comme celui-ci, vous comprendrez le bon ordre des & et * plus ce que cela signifie.

3
wheaties

En règle générale, vous pouvez lire la déclaration de la variable de droite à gauche. Par conséquent, dans le cas de int *ptr;, Cela signifie que vous avez un pointeur* Vers un variable entièreint. De plus, lorsqu'il est déclaré int **ptr2;, Il s'agit d'un variable pointeur* En variable pointeur* Pointant vers un - variable entièreint, qui est identique à "(int *)* ptr2;"

Maintenant, en suivant la syntaxe en déclarant int*& rPtr;, Nous disons que c'est un Référence& À un Pointeur* Qui pointe à une variable de type int. Enfin, vous pouvez appliquer à nouveau cette approche également pour int**& rPtr2; En concluant qu'elle signifie un Référence& À un Pointeur* à un pointeur* à un entierint.

0
Juan Chavarro