Adresse de l’opérateur : &

Syntaxe

address-of-expression:
  & cast-expression

Notes

L’opérateur unaire (&) retourne l’adresse de (autrement dit, un pointeur vers) son opérande. L’opérande de l’opérateur d’adresse peut être un indicateur de fonction ou une valeur lvalue qui fait référence à un objet qui n’est pas un champ de bits.

L’opérateur d’adresse ne peut être appliqué qu’à certaines expressions lvalue : soit à des variables de types fondamentaux, de structure, de classe ou d’union, soit à des références de tableau en indice. Dans ces expressions, une expression constante (qui n’inclut pas l’opérateur d’adresse) peut être ajoutée ou soustraite de l’expression d’adresse.

Lorsqu’elle est appliquée aux fonctions ou lvalues, le résultat de l’expression est un type de pointeur (une rvalue) 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 vers char. L’opérateur d’adresse, appliqué à ou volatile aux const objets, est évalué const type * ou volatile type *, où type est le type de l’objet d’origine.

Vous pouvez uniquement prendre l’adresse d’une fonction surchargée lorsqu’il est clair quelle version de la fonction est référencée. Pour plus d’informations sur la façon d’obtenir l’adresse d’une fonction surchargée particulière, consultez surcharge de fonction.

Lorsque l’opérateur d’adresse est appliqué à un nom qualifié, le résultat dépend du fait que le nom qualifié spécifie un membre statique. Si oui, le résultat est un pointeur vers le type spécifié dans la déclaration du membre. Pour un membre qui n’est pas statique, le résultat est un pointeur vers le nom de membre de la classe indiquée par un nom de classe qualifié. Pour plus d’informations sur le nom de classe qualifiée, consultez expressions primaires.

Exemple : Adresse du membre statique

Le fragment de code suivant montre comment le résultat de l’opérateur d’adresse diffère, selon qu’un membre de classe 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, l'expression &PTM::fValue permet d'obtenir le type float * à la place du type float PTM::*, car fValue est un membre statique.

Exemple : Adresse d’un type de référence

L'application de l'opérateur d'adresse à un type référence fournit le même résultat que l'application de l'opérateur à l'objet auquel la référence est liée. Par 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;
}

&d equals &rd

Exemple : Adresse de fonction en tant que paramètre

L'exemple ci-dessous utilise l'opérateur d'adresse pour passer un argument de pointeur à 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
}

25

Voir aussi

Expressions avec des opérateurs unaires
Opérateurs intégrés C++, priorité et associativité
Déclarateur de référence Lvalue : &
Indirection et adresse des opérateurs