Sobrecarga por tipo de retorno

Leí algunas preguntas aquí sobre SO sobre este tema que me parece confuso. Recién comencé a aprender C ++ y aún no he estudiado las plantillas o la sobrecarga de operadores y demás.

Ahora, ¿hay una forma sencilla de sobrecargar

class My {
public:
    int get(int);
    char get(int);
}

sin plantillas o comportamiento extraño? o debería simplemente

class My {
public:
    int get_int(int);
    char get_char(int);
}

?

No, no lo hay. No puede sobrecargar métodos basados ​​en el tipo de retorno.

La resolución de sobrecarga tiene en cuenta la firma de la función . Una firma de función se compone de:

• nombre de la función
• calificadores-cv
• tipos de parámetros

Y aquí está la cita:

1.3.11 firma

la información sobre una función que participa en la resolución de sobrecarga (13.3): su lista de tipos de parámetros (8.3.5) y, si la función es un miembro de la clase, los calificadores cv (si los hay) en la función en sí y la clase en el que se declara la función miembro. [...]

Opciones:

1) cambie el nombre del método:

class My {
public:
    int getInt(int);
    char getChar(int);
};

2) parámetro de salida:

class My {
public:
    void get(int, int&);
    void get(int, char&);
}

3) plantillas ... exagerado en este caso.

Es posible, pero no estoy seguro de que sea una técnica que recomendaría a los principiantes. Como en otros casos, cuando desea que la elección de funciones dependa de cómo se usa el valor de retorno, usa un proxy; primero defina funciones como getChary getInt, luego un genérico get()que devuelve un Proxy como este:

class Proxy
{
    My const* myOwner;
public:
    Proxy( My const* owner ) : myOwner( owner ) {}
    operator int() const
    {
        return myOwner->getInt();
    }
    operator char() const
    {
        return myOwner->getChar();
    }
};

Extiéndalo a tantos tipos como necesite.

No, no puede sobrecargar por tipo de retorno; solo por tipos de parámetros y calificadores const / volatile.

Una alternativa sería "regresar" usando un argumento de referencia:

void get(int, int&);
void get(int, char&);

aunque probablemente usaría una plantilla o funciones con nombres diferentes como su segundo ejemplo.

Puedes pensar de esta manera:

Tienes:

  int get(int);
  char get(int);

Y no es obligatorio recopilar el valor de retorno de la función al invocar.

Ahora, invocas

  get(10);  -> there is an ambiguity here which function to invoke. 

Por lo tanto, no tiene sentido si se permite la sobrecarga según el tipo de retorno.

Resucitando un hilo antiguo, pero puedo ver que nadie mencionó la sobrecarga de los calificadores de referencia. Los calificadores de referencia son una característica del lenguaje agregada en C ++ 11 y recientemente me encontré con ella; no está tan extendida como, por ejemplo, los calificadores de cv. La idea principal es distinguir entre los dos casos: cuando la función miembro se llama en un objeto rvalue y cuando se llama en un objeto lvalue. Básicamente, puedes escribir algo como esto (estoy modificando ligeramente el código de OP):

#include <stdio.h>

class My {
public:
    int get(int) & { // notice &
        printf("returning int..\n");
        return 42;
    }
    char get(int) && { // notice &&
        printf("returning char..\n");
        return 'x';
    };
};

int main() {
    My oh_my;
    oh_my.get(13); // 'oh_my' is an lvalue
    My().get(13); // 'My()' is a temporary, i.e. an rvalue
}

Este código producirá el siguiente resultado:

returning int..
returning char..

Por supuesto, como es el caso de los calificadores cv, ambas funciones podrían haber devuelto el mismo tipo y la sobrecarga aún sería exitosa.

Como se dijo antes, las plantillas son exageradas en este caso, pero sigue siendo una opción que vale la pena mencionar.

class My {
public:
    template<typename T> T get(int);
};

template<> int My::get<int>(int);
template<> char My::get<char>(int);

Si bien la mayoría de los otros comentarios sobre este problema son técnicamente correctos, puede sobrecargar efectivamente el valor de retorno si lo combina con el parámetro de entrada de sobrecarga. Por ejemplo:

class My {
public:
    int  get(int);
    char get(unsigned int);
};

MANIFESTACIÓN:

#include <stdio.h>

class My {
public:
    int  get(         int x) { return 'I';  };
    char get(unsinged int x) { return 'C';  };
};

int main() {

    int i;
    My test;

    printf( "%c\n", test.get(               i) );
    printf( "%c\n", test.get((unsigned int) i) );
}

El resultado de esto es:

I 
C

No hay forma de sobrecargar por tipo de retorno en C ++. Sin usar plantillas, usar get_inty get_charserá lo mejor que pueda hacer.

No puede sobrecargar métodos basados ​​en tipos de devolución. Su mejor opción es crear dos funciones con una sintaxis ligeramente diferente, como en su segundo fragmento de código.

no se puede sobrecargar una función en función del tipo de retorno de la función. puede sobrepasar según el tipo y la cantidad de argumentos que toma esta función.

Usé la respuesta de James Kanze usando un proxy:

https://stackoverflow.com/a/9569120/262458

Quería evitar usar muchos static_casts feos en un void *, así que hice esto:

#include <SDL_joystick.h>
#include <SDL_gamecontroller.h>

struct JoyDev {
    private:
        union {
            SDL_GameController* dev_gc = nullptr;
            SDL_Joystick*       dev_js;
        };
    public:
        operator SDL_GameController*&() { return dev_gc; }
        operator SDL_Joystick*&()       { return dev_js; }

        SDL_GameController*& operator=(SDL_GameController* p) { dev_gc = p; return dev_gc; }
        SDL_Joystick*&       operator=(SDL_Joystick* p)       { dev_js = p; return dev_js; }
};

struct JoyState {
    public:
        JoyDev dev;
};

int main(int argc, char** argv)
{
    JoyState js;

    js.dev = SDL_JoystickOpen(0);

    js.dev = SDL_GameControllerOpen(0);

    SDL_GameControllerRumble(js.dev, 0xFFFF, 0xFFFF, 300);

    return 0;
}

¡Funciona perfectamente!