funcion - auto c++ ejemplo

Función de conversión con decltype(auto) en C++ 14

Question

class A {
    public:
        int num;
        A ( int param ) : num( param ) {}
        operator decltype( auto )( ){ return num; }
};

class B {
    public:
        int num;
        A objA;
        B ( int param ) : num( param ), objA( param ) {}
      //operator A( )       { return objA; }         // Works               // #1   
      //operator int( )     { return objA; }         // Works               // #2
      //operator char( )    { return objA; }         // Actually Not Needed // #3
      //operator double( )  { return objA; }         // Actually Not Needed // #4
        operator decltype( auto )( ){ return objA; } // Does NOT Work       // #5
};

int main(){

    A objA( 1 );
    int    x1 =   int( objA );
    char   y1 = (char) objA;
    double z1 =        objA;

    B objB( 2 );
    A objA2     = objB;
    int      x2 = objB;
    char     y2 = objB;
    double   z2 = objB;

    return 0;
}

Este código no compila ni con clang ni con gcc, así que asumo que no es correcto. Sin embargo, si comento la línea 5 y las líneas de descompresión 1 y 2 el programa funciona correctamente en ambos compiladores (las líneas 3 y 4 no son realmente necesarias).

Hasta donde yo sé, las secuencias de conversión necesarias se definen en ambos escenarios. ¿Alguien sabe por qué este programa no es correcto? ¿Qué me estoy perdiendo?

Answer 1

Tenga en cuenta que la secuencia de conversión implícita podría contener solo una conversión definida por el usuario. Entonces el código no funcionará para int x2 = objB; ; B convierte a A y A conversiones a int son ambas conversiones definidas por el usuario.

Si proporciona el operator int() en B , funciona bien porque B se puede convertir a int directamente. (Y también funciona con char y double , a lo que int podría convertirse mediante conversión estándar).

Answer 2

decltype(auto) obtendrá el tipo exacto (incluidas referencias y punteros) del tipo que está devolviendo . Para la class A su operador de conversión devolverá una int , y para la class B obtendrá la devolución de una class A Creo que su creencia es que el operator decltype(auto) (){/*...*/} intentará devolver la clase para la cual se necesita la conversión, cuando de hecho necesitaría una plantilla para hacerlo:

class A {
    public:
        int num;
        A ( int param ) : num( param ) {}

        template<class T>
        operator T(){ return static_cast<T>(num); }
};

class B {
    public:
        int num;
        A objA;
        B ( int param ) : num( param ), objA( param ) {}

      template<class T>
      operator T ( ){ return static_cast<T>(objA); }
};

Demo en vivo