web-dev-qa-db-fra.com

comment fonctionne le signe esperluette (&) en c ++?

Duplicata possible:
Quelles sont les différences entre la variable pointeur et la variable de référence en C++?

Cela m'embrouille:

class CDummy 
{
public:
   int isitme (CDummy& param);
};

int CDummy::isitme (CDummy& param)
{
  if (&param == 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;
}

En C & signifie généralement l'adresse d'un var. Qu'est-ce que cela signifie ici? Est-ce une façon sophistiquée de noter les pointeurs?

La raison pour laquelle je suppose que c'est une notation de pointeur parce que c'est un pointeur après tout et que nous vérifions l'égalité de deux pointeurs.

J'étudie sur cplusplus.com et ils ont cet exemple.

c++pointersreferenceampersand
40
infinitloop

Pour commencer, notez que

this

est un pointeur spécial (== adresse mémoire) vers la classe dans laquelle il se trouve. Premièrement, 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 &param) est appelée:

b->isitme(a);

Un test est évalué à l'intérieur de cette méthode:

if (&param == this) // do something

Voici la partie délicate. param est un objet de type CDummy, mais &param est l'adresse mémoire de param. L'adresse mémoire de param est donc testée par rapport à une autre adresse mémoire appelée "this". Si vous copiez l'adresse mémoire de l'objet à partir duquel cette méthode est appelée dans l'argument de cette méthode, cela entraînera true.

Ce type d'évaluation est généralement effectué 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
    }
}

Notez également l'utilisation de *this, Où this est déréférencé. Autrement dit, au lieu de renvoyer l'adresse mémoire, renvoyez l'objet situé à cette adresse mémoire.

48
rwols

Le & a plusieurs significations:

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) au niveau du bit et de l'opérateur

int a = 3 & 1; // a = 1

n) autres ???

61
Luchian Grigore

Eh bien, 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 en tant que paramètres, vous avez vraiment une référence à l'instance du type, pas "juste" un pointeur vers elle. Donc, sur la ligne avec le commentaire, le "&" fonctionne comme en C, il obtient l'adresse de l'argument passé et le compare à this qui est, bien sûr, un pointeur vers l'instance de la classe à laquelle la méthode est appelée.

2
Hoons