simbolos - ¿Cómo funciona el signo & signo &(&) en c++?

para que sirve el ampersand en c++

Question

Posible duplicado:
¿Cuáles son las diferencias entre la variable de puntero y la variable de referencia en C ++?

Esto me confunde:

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 y generalmente significa la dirección de una var. ¿Qué significa aquí? ¿Es esta una forma elegante de notación de puntero?

La razón por la que lo asumo es una notación de puntero porque este es un puntero después de todo y estamos buscando la igualdad de dos punteros.

Estoy estudiando desde cplusplus.com y tienen este ejemplo.

Answer 1

Bueno, el CDummy& param que se declara como un parámetro de la función CDummy::isitme es en realidad una reference que es "como" un puntero, pero diferente. Lo importante a tener en cuenta acerca de las referencias es que dentro de las funciones donde se pasan como parámetros, realmente se tiene una referencia a la instancia del tipo, no "solo" un puntero al mismo. Entonces, en la línea con el comentario, el ''&'' está funcionando como en C, está obteniendo la dirección del argumento pasado, y comparándolo con this que es, por supuesto, un puntero a la instancia de la clase el método está siendo llamado.

Answer 2

El & tiene más un significado:

1) tomar la dirección de una variable

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

2) pasar un argumento por referencia a una función

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) declarar una variable de referencia

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

4) bitwise y operador

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

n) otros ???

Answer 3

Para comenzar, tenga en cuenta que

this

es un puntero especial (== dirección de memoria) a la clase its in. Primero, se crea una instancia de un objeto:

CDummy a;

A continuación, se crea una instancia de un puntero:

CDummy *b;

A continuación, la dirección de memoria de a se asigna al puntero b :

b = &a;

A continuación, se CDummy::isitme(CDummy &param) al método CDummy::isitme(CDummy &param) :

b->isitme(a);

Una prueba se evalúa dentro de este método:

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

Aquí está la parte difícil. param es un objeto de tipo CDummy, pero &param es la dirección de memoria de param. Entonces la dirección de memoria de param se prueba contra otra dirección de memoria llamada " this ". Si copia la dirección de memoria del objeto al que se llama este método en el argumento de este método, esto dará como resultado true .

Este tipo de evaluación generalmente se realiza al sobrecargar el constructor de copia

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

También tenga en cuenta el uso de *this , donde se está desreferenciando . Es decir, en lugar de devolver la dirección de la memoria, devuelva el objeto ubicado en esa dirección de memoria.