Signification de * & et * * & en C++
j'ai trouvé ces symboles dans une déclaration de fonction plusieurs fois, 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];
}
6 réponses
qui prend le paramètre par référence. Donc dans le premier cas, vous prenez un paramètre pointeur par référence de sorte que quelle que soit la modification que vous faites à la valeur du pointeur se reflète en dehors de la fonction. Le deuxième est le simlilar au premier avec la seule différence étant qu'il est 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;
}
est d'abord une référence à un pointeur, ensuite une référence à un pointeur. Voir aussi FAQ sur comment 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;
}
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
}
int* est un pointeur vers un int . Puis 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 , alors int**& doit être une référence à un pointeur vers un int .
pour comprendre ces phrases, regardons ces deux choses:
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 passe un pointeur à un double pointeur par référence. Si vous pensez en termes de typographies comme celle-ci, vous comprendrez l'ordre approprié du & et * plus ce qu'il signifie.
*& signifie la réception du pointeur par référence. Cela signifie qu'il s'agit d'un alias pour le paramètre passing. 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