Перевантаження за типом повернення

Я прочитав тут кілька запитань на тему SO щодо цієї теми, яка мені здається поки що незрозумілою. Я тільки почав вивчати C ++, і ще не вивчав шаблони чи перевантаження оператора тощо.

Зараз є простий спосіб перевантажити

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

без шаблонів чи дивної поведінки? чи я повинен просто

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

?

Ні, немає. Ви не можете перевантажити методи на основі типу повернення.

Дозвіл на перевантаження враховує підпис функції . Підпис функції складається з:

• назва функції
• cv-кваліфікація
• типи параметрів

І ось цитата:

1.3.11 підпис

інформація про функцію, яка бере участь у вирішенні перевантажень (13.3): її перелік типів параметрів (8.3.5) і, якщо функція є членом класу, cv-кваліфікатори (якщо такі є) щодо самої функції та класу в якому оголошена функція-член. [...]

Варіанти:

1) змініть назву методу:

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

2) параметр out:

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

3) шаблони ... в цьому випадку надмірні.

Це можливо, але я не впевнений, що це техніка, яку я рекомендую початківцям. Як і в інших випадках, коли ви хочете, щоб вибір функцій залежав від того, як використовується значення, що повертається, ви використовуєте проксі-сервер; спочатку визначте такі функції, як getCharі getInt, а потім загальну, get()яка повертає такий проксі:

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

Поширте його на стільки типів, скільки вам потрібно.

Ні, ви не можете перевантажити за типом повернення; лише за типами параметрів, а також за класифікаторами const / volatile.

Однією з альтернатив може бути "повернення" за допомогою посилального аргументу:

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

хоча я, мабуть, використовував би шаблон, або інакше названі функції, як ваш другий приклад.

Ви можете думати так:

Ти маєш:

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

І не обов’язково збирати повернене значення функції під час виклику.

Тепер Ви закликаєте

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

Отже, немає значення, якщо дозволено перевантаження на основі типу повернення.

Відроджуючи старий потік, але я бачу, що ніхто не згадував про перевантаження реф-кваліфікаторами. Ref-кваліфікатори - це мовна функція, додана в C ++ 11, і я нещодавно натрапив на неї - вона не настільки поширена, як, наприклад, cv-кваліфікатори. Основна ідея полягає у розрізненні двох випадків: коли функція-член викликається на об'єкт rvalue і коли викликається на об'єкт lvalue. В основному ви можете написати щось подібне (я трохи модифікую код 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
}

Цей код видасть такий результат:

returning int..
returning char..

Звичайно, як у випадку з cv-кваліфікаторами, обидві функції могли повернути однаковий тип, і перевантаження все одно було б успішним.

Як зазначалося раніше, шаблони в цьому випадку є надмірними, але це все ще варіант, про який варто згадати.

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

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

Хоча більшість інших коментарів щодо цієї проблеми є технічно правильними, ви можете ефективно перевантажити повернене значення, якщо поєднати його з перевантажуючим вхідним параметром. Наприклад:

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

ДЕМО:

#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) );
}

Результатом цього є:

I 
C

У C ++ немає можливості перевантажити типом повернення. Без використання шаблонів, використання get_intі get_charбуде найкращим з усіх можливих результатів.

Ви не можете перевантажити методи на основі типів повернення. Найкраще - створити дві функції з дещо іншим синтаксисом, наприклад, у другому фрагменті коду.

ви не можете перевантажити функцію на основі типу повернення функції. Ви можете накладати на основу тип і кількість аргументів, які приймає ця функція.

Я використав відповідь Джеймса Канзе, використовуючи проксі:

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

Я хотів уникати використання потворних static_casts у порожнечі *, тому зробив це:

#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;
}

Працює ідеально!