Sobrecarregando um operador unário

Vamos considerar uma class com um operador unário sobrecarregado e (Address-of). Deixe ser class A

 template  class A { public: C * operator &() { return &data; } //... private: C data; } 

Agora eu quero passar para alguma function um ponteiro do tipo A para preencher seus data . Vamos chamá-lo f

 void f(A * auto_containter) { //... } 

Mas fica claro por que o código abaixo não funcionaria (nem compilaria). É porque o operador sobrecarregado é chamado.

 A a; f(&a); 

A questão é a seguinte:

Existe alguma syntax para passar o endereço de a para f ? Se não, então para mim é muito estranho porque é permitido sobrecarregar o operator & unário, porque torna o código mais bugs e difícil de entender. Ou existem outras razões?

Use boost::addressof function boost::addressof . Em qualquer caso, sobrecarregar unário e é altamente duvidoso. Por que em vez de ter uma function nomeada que retorna o endereço dos seus dados?

Existe alguma syntax para passar o endereço de a para f ?

Sim, tem uma syntax feia:

 f( reinterpret_cast( &reinterpret_cast(a) ) ); 

boost::addressof é um bom e genérico wrapper em torno dele.

Existe alguma syntax para passar o endereço de a para f?

Outros já apontaram boost::addressof . O mecanismo em que se baseia é um uso padrão garantido do operador de endereço interno para um tipo reinterpret_cast to reference. A function Boost apenas envolve a combinação bastante verbosa e desajeitada de castings.

Se não, então para mim é muito estranho porque é permitido sobrecarregar o operador unário e, porque se tornar o código mais bugs e difícil de entender. Ou existem outras razões?

Em alguns casos, pode ser mais conveniente. Por exemplo, uma class de ponteiro inteligente pode oferecer um operador de endereço customizado para suportar a escrita de &p como argumento real para um argumento formal T** . No entanto, acho que hoje em dia é geralmente reconhecido que não é uma boa ideia.

Cheers & hth.

Por que você iria querer sobrecarregar o operator& unário operator& ?

Além disso, há boost::addressof .

Seu cenário nunca surge, porque quem está escrevendo essa function terá uma referência, não um ponteiro. Além disso, você esqueceu de instanciar A com um tipo de exemplo para C.

É por isso que boost::addressof foi inventado.