overload - operator[] c++

Sobrecarga por tipo de retorno

Question

Leí algunas preguntas aquí en SO sobre este tema que me parece confuso. Acabo de empezar a aprender C ++ y todavía no he estudiado las plantillas o la sobrecarga de operadores y cosas por el estilo.

Ahora hay una manera simple de sobrecargar

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

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

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

?

Answer 1

Es posible, pero no estoy seguro de que sea una técnica que recomendaría para principiantes. Como en otros casos, cuando quiere que la elección de las funciones dependa de cómo se usa el valor de retorno, usa un proxy; primero defina funciones como getChar y getInt , luego un get() genérico 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 todos los tipos que necesite.

Answer 2

No hay forma de sobrecargar por tipo de devolución en C ++. Sin usar plantillas, usar get_int y get_char será lo mejor que puede hacer.

Answer 3

No puede sobrecargar los métodos según los 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.

Answer 4

No, no hay. No puede sobrecargar los métodos según el tipo de devolución.

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
• cv-calificadores
• 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 parameter-type-list (8.3.5) y, si la función es un miembro de la clase, los cv-qualifiers (si los hay) sobre la función misma y la clase en el que se declara la función miembro. [...]

Opciones:

1) cambiar el nombre del método:

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

2) fuera de parámetro:

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

3) plantillas ... excesivas en este caso.

Answer 5

No, no puedes sobrecargar por tipo de devolución; solo por tipos de parámetros y calificadores const / volátiles.

Una alternativa sería "devolver" 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.

Answer 6

Puedes pensar de esta manera:

Tienes:

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

Y, no es obligatorio para recoger 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 devolución.

Answer 7

Si bien la mayoría de los otros comentarios sobre este problema son técnicamente correctos, puede sobrecargar eficazmente 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

Answer 8

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