按返回类型重载

Question

我在这里阅读了一些关于这个主题的问题，这似乎让我感到困惑。刚开始学C++，还没有学过模板或者运算符重载等。

现在有没有简单的重载方法

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

没有模板或奇怪的行为？或者我应该只是

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

?

Answer 1

不，没有。您不能根据返回类型重载方法。

重载解析考虑到函数签名。函数签名由以下部分组成：

• 函数名
• cv 限定符
• 参数类型

这是引用：

1.3.11 签名

有关参与重载的函数的信息 分辨率（13.3）：它的参数类型列表（8.3.5），如果 函数是类成员，函数上的 cv 限定符（如果有） 本身和声明成员函数的类。 [...]

选项：

1) 更改方法名称：

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

2) 输出参数：

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

3) 模板...在这种情况下有点矫枉过正。

Answer 2

这是可能的，但我不确定这是我推荐的技术 初学者。与其他情况一样，当您希望选择功能时 取决于如何使用返回值，您使用代理；首先定义 像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();
    }
};

根据需要将其扩展到尽可能多的类型。

Answer 3

不，你不能通过返回类型重载；只能通过参数类型和 const/volatile 限定符。

另一种选择是使用引用参数“返回”：

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

虽然我可能会使用模板，或者像您的第二个示例一样使用不同名称的函数。

Answer 4

如前所述，在这种情况下，模板是多余的，但它仍然是一个值得一提的选项。

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

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

Answer 5

你可以这样想：

你有：

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

并且，在调用时收集函数的返回值不是强制性的。

现在，你调用

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

所以，根据返回类型是否允许重载是没有意义的。

Answer 6

复活一个旧线程，但我可以看到没有人提到 ref-qualifiers 的重载。 Ref-qualifiers 是 C++11 中添加的一种语言特性，我最近才偶然发现它——它并不像 e.g. cv 限定符。主要思想是区分两种情况：何时在右值对象上调用成员函数，以及何时在左值对象上调用。你基本上可以写这样的东西（我稍微修改了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 限定符一样，两个函数都可以返回相同的类型，并且重载仍然会成功。

Answer 7

虽然这个问题上的大多数其他 cmets 在技术上都是正确的，但您可以有效地重载返回值如果将它与重载输入参数结合使用。例如：

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

Answer 8

在 C++ 中无法通过返回类型进行重载。在不使用模板的情况下，使用get_int 和get_char 将是您能做的最好的。

Answer 9

您不能基于返回类型重载方法。您最好的选择是创建两个语法略有不同的函数，例如在您的第二个代码 sn-p 中。

Answer 10

您不能根据函数的返回类型重载函数。 您可以根据此函数采用的参数类型和数量进行覆盖。

Answer 11

我通过代理使用了 James Kanze 的答案：

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

我想避免在 void* 上使用大量难看的 static_cast，所以我这样做了：

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

完美运行！