Dirección-de Operator: y

Artículo
02/19/2013

& cast-expression

Comentarios

Dirección del operador unario (y) toma la dirección del operando.El operando del operador de dirección puede ser un designador de función o un valor l que señala un objeto que no es un campo de bits y no se declara con el especificador de clase de almacenamiento de Registrarse .

El operador de dirección se puede aplicar a las variables con fundamentalmente, la estructura, la clase, o tipos de unión que se declaran en el nivel de archivo-ámbito, o a las referencias subscripted de la matriz.En estas expresiones, una expresión constante que no incluye el operador de dirección se puede agregar o quitar de dirección de expression.

Cuando se aplica a las funciones o los l, el resultado de la expresión es un tipo de puntero (un r-value) derivado del tipo del operando.Por ejemplo, si el operando es de chartipo, el resultado de la expresión es de tipo puntero a char.El operador de dirección, aplicado a const y objetos de volatile , se evalúa como const type * o a volatile type *, donde es el tipo type del objeto original.

Cuando se aplica el operador a nombre completo, el resultado depende de si el nombre calificado especifica un miembro estático.Si se devuelve el resultado es un puntero al tipo especificado en la declaración de miembro.Si el miembro no es estático, el resultado es un puntero al nombre de miembro de la clase indicada por calificar-clase-nombre.(Vea Expresiones principales para más información sobre calificar-clase-nombre.) El fragmento de código siguiente muestra cómo difiere el resultado, dependiendo de si el miembro es estático:

// expre_Address_Of_Operator.cpp
// C2440 expected
class PTM {
public:
           int   iValue;
    static float fValue;
};

int main() {
   int   PTM::*piValue = &PTM::iValue;  // OK: non-static
   float PTM::*pfValue = &PTM::fValue;  // C2440 error: static
   float *spfValue     = &PTM::fValue;  // OK
}

En este ejemplo, la expresión &PTM::fValue hace que el tipo float * en lugar de float PTM::* tipo porque fValue es un miembro estático.

La dirección de una función sobrecargada puede ser tomada cuando está claro que la versión de la función se hace referencia.Vea dirección de funciones sobrecargadas para obtener información sobre cómo obtener la dirección de una función sobrecargada detalle.

Aplicar el operador de dirección a un tipo de referencia da el mismo resultado que aplicar el operador al objeto al que se enlaza la referencia.Por ejemplo:

Ejemplo

// expre_Address_Of_Operator2.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;
int main() {
   double d;        // Define an object of type double.
   double& rd = d;  // Define a reference to the object.

   // Obtain and compare their addresses
   if( &d == &rd )
      cout << "&d equals &rd" << endl;
}

Output

&d equals &rd

El ejemplo siguiente utiliza el operador para pasar un argumento puntero a una función:

// expre_Address_Of_Operator3.cpp
// compile with: /EHsc
// Demonstrate address-of operator &

#include <iostream>
using namespace std;

// Function argument is pointer to type int
int square( int *n ) {
   return (*n) * (*n);
}

int main() {
   int mynum = 5;
   cout << square( &mynum ) << endl;   // pass address of int
}