hoe werkt het ampersand(&) teken in c++?

Mogelijk duplicaat:
Wat zijn de verschillen tussen pointervariabele en referentievariabele in C++?

Dit brengt me in verwarring:

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;
}

In C & betekent meestal het adres van een var. Wat betekent het hier? Is dit een mooie manier van aanwijzernotatie?

De reden dat ik aanneem dat het een pointer-notatie is, omdat dit toch een pointer is en we controleren op gelijkheid van twee pointers.

Ik studeer van cplusplus.com en zij hebben dit voorbeeld.

Antwoord 1, autoriteit 100%

Om te beginnen, houd er rekening mee dat

this

is een speciale pointer (== geheugenadres) naar de klasse waarin het zich bevindt.
Eerst wordt een object geïnstantieerd:

CDummy a;

Vervolgens wordt een aanwijzer geïnstantieerd:

CDummy *b;

Vervolgens wordt het geheugenadres van atoegewezen aan de aanwijzer b:

b = &a;

Volgende, de methode CDummy::isitme(CDummy &param)wordt genoemd:

b->isitme(a);

Er wordt een test geëvalueerd in deze methode:

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

Hier is het lastige deel. Paraminstelling is een object van het type type, maar &paramis het geheugenadres van de param. Dus het geheugenadres van de parameter wordt getest tegen een ander geheugenadres dat wordt genoemd “this“. Als u het geheugenadres van het object kopieert, wordt deze methode genoemd van het argument van deze methode, dit zal resulteren in true.

Dit soort evaluatie wordt meestal gedaan bij het overbelasten van de Copy Constructor

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

Houd ook op het gebruik van *this, waar thisis afgesproken . Dat wil zeggen, in plaats van het geheugenadres terug te sturen, retourneert u het object dat zich op dat geheugenadres bevindt.

Antwoord 2, Autoriteit 171%

De &heeft meer de enige betekenissen:

1) Neem het adres van een variabele

int x;
void* p = &x;
//p will now point to x, as &x is the address of x

2) Geef een argument door met verwijzing naar een functie

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) declareer een referentievariabele

int k = 0;
int& r = k;
//r is a reference to k
r = 3;
assert( k == 3 );

4) bitsgewijze en operator

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

n) anderen???

Antwoord 3, autoriteit 3%

Nou, de CDummy& paramdie is gedeclareerd als een parameter van de functie CDummy::isitmeis eigenlijk een referentiewat “als” een aanwijzer is, maar anders. Het belangrijkste om op te merken over verwijzingen is dat binnen functies waar ze als parameters worden doorgegeven, je echt een verwijzing hebt naar de instantie van het type, niet “slechts” een verwijzing ernaar. Dus, op de lijn met de opmerking, de ‘&’ werkt net als in C, het krijgt het adres van het ingevoerde argument en vergelijkt het met this, wat natuurlijk een verwijzing is naar de instantie van de klasse waarop de methode wordt aangeroepen .