comment l'esperluette(&) signe en c++? [dupliquer]
possibilité de dupliquer:
quelles sont les différences entre la variable pointeur et la variable de référence en C++?
cela me confond:
class CDummy
{
public:
int isitme (CDummy& param);
};
int CDummy::isitme (CDummy& param)
{
if (¶m == this)
{
return true; //ampersand sign on left side??
}
else
{
return false;
}
}
int main ()
{
CDummy a;
CDummy* b = &a;
if ( b->isitme(a) )
{
cout << "yes, &a is b";
}
return 0;
}
dans C & signifie habituellement l'adresse d'une var. Ce qui signifie-t-il ici? Est-ce une façon élégante de notation pointeur?
la raison pour laquelle je suppose que c'est un pointeur notation parce que c'est un pointeur après tout et nous vérifions l'égalité de deux pointeurs.
j'étudie de cplusplus.com et ils ont cet exemple.
3 réponses
pour commencer, notez que
this
est un pointeur spécial ( == adresse mémoire) de la classe its in. Tout d'abord, un objet est instancié:
CDummy a;
ensuite, un pointeur est instancié:
CDummy *b;
ensuite, l'adresse mémoire de a est affectée au pointeur b :
b = &a;
ensuite, la méthode CDummy::isitme(CDummy ¶m) s'appelle:
b->isitme(a);
un essai est évalué à l'intérieur de cette méthode:
if (¶m == this) // do something
Voici la partie délicate. param est un objet de type CDummy, mais ¶m est l'adresse mémoire de param. Ainsi, l'adresse mémoire de param est testée par rapport à une autre adresse mémoire appelée " this ". Si vous copiez l'adresse mémoire de l'objet de cette méthode est appelée depuis dans l'argument de cette méthode, il en résulte true .
Ce type d'évaluation est habituellement fait lors de la surcharge du constructeur de copie
MyClass& MyClass::operator=(const MyClass &other) {
// if a programmer tries to copy the same object into itself, protect
// from this behavior via this route
if (&other == this) return *this;
else {
// otherwise truly copy other into this
}
}
également noter l'usage de *this , où this est déréférencé . C'est-à-dire, au lieu de retourner l'adresse mémoire, retourner l'objet situé à cette adresse mémoire.
le & a plus d'un sens:
1) prendre l'adresse d'une variable
int x;
void* p = &x;
//p will now point to x, as &x is the address of x
2) passer un argument par référence à une fonction
void foo(CDummy& x);
//you pass x by reference
//if you modify x inside the function, the change will be applied to the original variable
//a copy is not created for x, the original one is used
//this is preffered for passing large objects
//to prevent changes, pass by const reference:
void fooconst(const CDummy& x);
3) déclarer une variable de référence
int k = 0;
int& r = k;
//r is a reference to k
r = 3;
assert( k == 3 );
4) bitwise et opérateur
int a = 3 & 1; // a = 1
n) Autres???
le CDummy& param qui est déclaré comme paramètre de la fonction CDummy::isitme est en fait un référence qui est" comme " un pointeur, mais différent. La chose importante à noter à propos des références est qu'à l'intérieur des fonctions où elles sont passées comme paramètres, vous avez vraiment une référence à l'instance du type, pas "juste" un pointeur vers elle. Donc, en ligne avec le commentaire, le ' & ' fonctionne comme en C, il obtient l'adresse de l'argument passé, et en le comparant à this qui est, bien sûr, un pointeur vers l'instance de la classe la méthode est appelée.