Comment puis-je obtenir de manière fiable l'adresse d'un objet lorsque l'opérateur & est surchargé?

Considérez le programme suivant:

struct ghost
{
    // ghosts like to pretend that they don't exist
    ghost* operator&() const volatile { return 0; }
};

int main()
{
    ghost clyde;
    ghost* clydes_address = &clyde; // darn; that's not clyde's address :'( 
}

Comment obtenir l clyde'adresse de?

Je recherche une solution qui fonctionnera aussi bien pour tous les types d'objets. Une solution C ++ 03 serait bien, mais je suis également intéressé par les solutions C ++ 11. Si possible, évitons tout comportement spécifique à l'implémentation.

Je connais le std::addressofmodèle de fonction de C ++ 11 , mais je ne suis pas intéressé à l'utiliser ici: j'aimerais comprendre comment un implémenteur de bibliothèque standard pourrait implémenter ce modèle de fonction.

Mise à jour: en C ++ 11, on peut utiliser à la std::addressofplace de boost::addressof.

Copions d'abord le code de Boost, moins le travail du compilateur autour des bits:

template<class T>
struct addr_impl_ref
{
  T & v_;

  inline addr_impl_ref( T & v ): v_( v ) {}
  inline operator T& () const { return v_; }

private:
  addr_impl_ref & operator=(const addr_impl_ref &);
};

template<class T>
struct addressof_impl
{
  static inline T * f( T & v, long ) {
    return reinterpret_cast<T*>(
        &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
  }

  static inline T * f( T * v, int ) { return v; }
};

template<class T>
T * addressof( T & v ) {
  return addressof_impl<T>::f( addr_impl_ref<T>( v ), 0 );
}

Que se passe-t-il si nous transmettons une référence à la fonction ?

Remarque: addressofne peut pas être utilisé avec un pointeur sur la fonction

En C ++, si void func();est déclaré, alors funcest une référence à une fonction ne prenant aucun argument et ne renvoyant aucun résultat. Cette référence à une fonction peut être convertie de manière triviale en un pointeur vers une fonction - à partir de @Konstantin: Selon 13.3.3.2 les deux T &et T *sont indiscernables pour les fonctions. La première est une conversion d'identité et la deuxième est une conversion de fonction en pointeur, toutes deux ayant le rang "Exact Match" (13.3.3.1.1 tableau 9).

La référence au passage de fonctionaddr_impl_ref , il y a une ambiguïté dans la résolution de surcharge pour le choix de f, qui est résolue grâce à l'argument factice 0, qui est une intpremière et pourrait être promue en long(Conversion intégrale).

Ainsi, nous renvoyons simplement le pointeur.

Que se passe-t-il si nous passons un type avec un opérateur de conversion?

Si l'opérateur de conversion donne un T*alors nous avons une ambiguïté: pour f(T&,long)une promotion intégrale est requise pour le deuxième argument tandis que pour f(T*,int)l'opérateur de conversion est appelé sur le premier (grâce à @litb)

C'est à ce moment-là que addr_impl_refcommence. La norme C ++ stipule qu'une séquence de conversion peut contenir au plus une conversion définie par l'utilisateur. En encapsulant le type addr_impl_refet en forçant déjà l'utilisation d'une séquence de conversion, nous "désactivons" tout opérateur de conversion fourni avec le type.

Ainsi, la f(T&,long)surcharge est sélectionnée (et la promotion intégrale effectuée).

Que se passe-t-il pour tout autre type?

Ainsi la f(T&,long)surcharge est sélectionnée, car là le type ne correspond pas au T*paramètre.

Remarque: d'après les remarques dans le fichier concernant la compatibilité Borland, les tableaux ne se désintègrent pas en pointeurs, mais sont passés par référence.

Que se passe-t-il dans cette surcharge?

Nous voulons éviter d'appliquer operator&au type, car il peut avoir été surchargé.

Les garanties standard qui reinterpret_castpeuvent être utilisées pour ce travail (voir la réponse de @Matteo Italia: 5.2.10 / 10).

Boost ajoute quelques subtilités avec les qualificatifs constet volatilepour éviter les avertissements du compilateur (et utilisez correctement a const_castpour les supprimer).

• Diffuser T&surchar const volatile&
• Dénuder le constetvolatile
• Appliquer l' &opérateur pour prendre l'adresse
• Rejeter sur un T*

Le const/ la volatilejonglerie est un peu de la magie noire, mais elle simplifie le travail (plutôt que de fournir 4 surcharges). Notez que puisque Tn'est pas qualifié, si nous passons a ghost const&, alors T*est ghost const*, donc les qualificatifs n'ont pas vraiment été perdus.

EDIT: la surcharge du pointeur est utilisée pour le pointeur vers les fonctions, j'ai quelque peu modifié l'explication ci-dessus. Je ne comprends toujours pas pourquoi c'est nécessaire .

La sortie d'ideone suivante résume cela, un peu.

Utilisez std::addressof.

Vous pouvez y penser comme faisant ce qui suit dans les coulisses:

1. Réinterpréter l'objet comme une référence à un caractère
2. Prenez l'adresse de ça (n'appelle pas la surcharge)
3. Rejetez le pointeur sur un pointeur de votre type.

Les implémentations existantes (y compris Boost.Addressof) font exactement cela, en prenant simplement soin constet en volatilequalification.

L'astuce derrière boost::addressofet l'implémentation fournie par @Luc Danton repose sur la magie du reinterpret_cast; la norme indique explicitement au §5.2.10 ¶10 que

Une expression lvalue de type T1peut être convertie en type «référence à T2» si une expression de type «pointeur vers T1» peut être explicitement convertie en type «pointeur vers T2» à l'aide de a reinterpret_cast. Autrement dit, une distribution de référence reinterpret_cast<T&>(x)a le même effet que la conversion *reinterpret_cast<T*>(&x)avec les opérateurs &et intégrés *. Le résultat est une lvalue qui fait référence au même objet que la lvalue source, mais avec un type différent.

Maintenant, cela nous permet de convertir une référence d'objet arbitraire en a char &(avec une qualification cv si la référence est qualifiée cv), car tout pointeur peut être converti en a (éventuellement qualifié cv) char *. Maintenant que nous avons un char &, la surcharge de l'opérateur sur l'objet n'est plus pertinente, et nous pouvons obtenir l'adresse avec l' &opérateur intégré .

L'implémentation boost ajoute quelques étapes pour travailler avec des objets qualifiés cv: la première reinterpret_castest faite pour const volatile char &, sinon un char &cast brut ne fonctionnerait pas pour constet / ou volatileréférences ( reinterpret_castne peut pas supprimer const). Ensuite, constet volatileest supprimé avec const_cast, l'adresse est prise avec &, et un final reinterpet_castau type "correct" est effectué.

Le const_castest nécessaire pour supprimer le const/ volatilequi aurait pu être ajouté à des références non const / volatiles, mais il ne "nuit" pas à ce qui était une référence const/ volatileen premier lieu, car le final reinterpret_castajoutera à nouveau la qualification cv si c'était là en premier lieu ( reinterpret_castne peut pas supprimer le constmais peut l'ajouter).

En ce qui concerne le reste du code addressof.hpp, il semble que la majeure partie soit pour des solutions de contournement. Le static inline T * f( T * v, int )semble être nécessaire uniquement pour le compilateur Borland, mais sa présence en introduit le besoin addr_impl_ref, sinon les types de pointeurs seraient interceptés par cette seconde surcharge.

Edit : les différentes surcharges ont une fonction différente, voir @Matthieu M. excellente réponse .

Eh bien, je n'en suis plus sûr non plus; Je devrais approfondir ce code, mais maintenant je prépare le dîner :), je vais y jeter un œil plus tard.

J'ai vu une implémentation de addressoffaire ceci:

char* start = &reinterpret_cast<char&>(clyde);
ghost* pointer_to_clyde = reinterpret_cast<ghost*>(start);

Ne me demandez pas à quel point c'est conforme!

Jetez un œil à boost :: addressof et à son implémentation.