Quel serait le but de l'utilisation immédiate des opérateurs de référence et de déréférencement dans la séquence "& * B"?

Question

J'ai vu cela dans notre code quelques fois et cela me rend immédiatement suspect. Mais puisque je ne connais pas l'intention originale, j'hésite à l'enlever.

//requires double indirection which I won't go into 
FooClass::FooFunction(void ** param) 
{ 
    //do something 
} 

SomeClass * A = new SomeClass(); 
SomeClass **B = &A; 
FooFunction(reinterpret_cast<void**>(&*B)); // what is happening here? 

La partie "& * B" est la partie en question? N'hésitez pas à intégrer l'explication du casting de réinterprétation mais je suis assez familier avec les techniques de casting.

Answer 1

Je ne vois qu'une seule raison: B a surchargé operator*() retourner un X, mais celui qui a écrit le code avait besoin d'un . (Notez que dans votre code, X est A*.) Le cas typique est celui des pointeurs intelligents et des itérateurs.

Si ce qui précède n'est pas le cas, peut-être que le code a été écrit pour être assez générique pour gérer les pointeurs/itérateurs intelligents. Ou il utilisait des pointeurs intelligents et celui qui l'a changé n'a pas pris la peine de changer &* aussi? Avez-vous passé en revue son histoire pour voir quand cela a été introduit et à quoi ressemblait le code?

Answer 2

J'ai fait des choses similaires avec les itérateurs - déréférencer l'itérateur pour obtenir une référence, puis faire l'opérateur "&" pour obtenir un pointeur.

Je ne vois pas pourquoi cela ferait quoi que ce soit ici. Si le type à droite de "& *" est un type de pointeur, il ne fait rien.

Answer 3

Considérons l'exemple suivant;

class A { 
public: 
    int f() { return 55; } 
}; 

class B { 
public: 
    B(A* a) : a(a) {} 
    A*& operator*() { return a; } 

    A* a; 
}; 

int main() { 
    A* a = new A(); 
    B b = a; 

    // &* calls operator*, then gets address of A 
    void** x = reinterpret_cast<void**>(&*b); 
    cout << reinterpret_cast<A*>(*x)->f() << endl; // prints 55 

    void** x2 = reinterpret_cast<void**>(b);  // compile error 
} 

Votre dernière modification de la question conduit à:

A* a = new A(); 
A** b = &a; 

void** x = reinterpret_cast<void**>(&*b); // now this is equal to the following 
void** x2 = reinterpret_cast<void**>(b); // so using &* make no sense