Opérateur address-of : et

Article
03/04/2013

& cast-expression

Notes

L'opérateur address-of unaire (&) prend l'adresse de son opérande.L'opérande de l'opérateur address-of ne peut être un indicateur de fonction ou une l-value qui pointe vers un objet qui n'est pas un champ de bits et n'est pas déclaré avec le spécificateur de classe de stockage de registre .

L'opérateur address-of ne peut pas être appliqué à des variables avec le principe fondamental, la structure, la classe, ou les types union déclarés au niveau de la portée du fichier, ou aux références indicées de tableau.Dans ces expressions, une expression constante qui n'inclut pas l'opérateur address-of ne peut être ajoutée ou soustraite d'adresse-de expression.

Appliqué aux fonctions ou des valeurs lvalues, le résultat de l'expression est un type pointeur (un cast sur une valeur r) dérivé du type de l'opérande.Par exemple, si l'opérande est de type char, le résultat de l'expression est de type pointeur à char.L'opérateur d'adresse, appliqué à const ou aux objets d' volatile , correspond à const type * ou à volatile type *, où type est le type de l'objet d'origine.

Lorsque l'opérateur d'adresse est appliqué à nom qualifié, le résultat varie selon que le nom qualifié spécifie un membre statique.Si tel est le cas, le résultat est un pointeur vers le type spécifié dans la déclaration de membre.Si le membre non static, le résultat est un pointeur vers le nom du membre de la classe indiquée par le qualifier-classe-nom.(Voir l' Expressions primaire pour davantage sur le qualifier-classe-nom.) Le fragment de code suivant montre comment le résultat est différent, selon que le membre est statique :

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

Dans cet exemple, cède de &PTM::fValue d'expression tapez float * au lieu du type float PTM::* car fValue est un membre statique.

L'adresse d'une fonction surchargée peut être prise uniquement lorsqu'il est clair que la version de la fonction est référencé.Consultez Traite des fonctions surchargées pour plus d'informations sur la manière d'obtenir l'adresse d'une fonction surchargée spécifiques.

L'application de l'opérateur d'adresse à un type référence qui donne le même résultat qu'application de l'opérateur à l'objet auquel la référence est liée.Par exemple :

Exemple

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

Sortie

&d equals &rd

L'exemple suivant utilise l'opérateur d'adresse pour passer un argument de pointeur vers une fonction :

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