为什么编译器在这个 const 函数重载问题中没有更聪明？

Question

以下代码无法编译：

#include <iostream>
class Foo {
  std::string s;
 public:
  const std::string& GetString() const { return s; }
  std::string* GetString() { return &s; }
};

int main(int argc, char** argv){
  Foo foo;
  const std::string& s = foo.GetString(); // error
  return 0;
}

我收到以下错误：

const1.cc:11: error: 
invalid initialization of reference of type 'const std::string&' 
from expression of type 'std::string*

这确实有些道理，因为foo 不是const Foo 类型，而只是Foo，所以编译器想要使用非常量函数。但是，为什么它不能通过查看我分配给它的（类型）变量来识别我想调用 const GetString 函数？我发现这种情况令人惊讶。

Answer 1

返回类型由实际调用的重载函数决定，它从不构成重载决议本身的一部分。 （如果没有使用返回类型怎么办？）

const 不是返回值的问题，因为您可以将非const 对象绑定到const 引用，这是您的函数返回一个您不取消引用的指针的事实。

由于foo 不是const，因此调用了非const GetString() - 它更适合非const 对象。你需要：

const std::string& s = *foo.GetString();

Answer 2

我不记得为什么他们不允许在返回类型上重载（我认为这是因为返回值可以被丢弃，因此函数不会是不同的），但是您可以使用 const_cast 提示解决问题给编译器： const std::string& s = const_cast<const Foo&>(foo).GetString();

Answer 3

扩展MarkB's answer 并稍微说明可能比丢弃返回值更糟糕的情况：

#include <cmath>
#include <complex>

struct Foo {
   int x;
   double y;
   std::complex<char> z;
   // etc, etc
};

int evaluate(Foo f) { return f.x; }
double evaluate(Foo f) { return f.y; }
std::complex<char>(Foo f) { return f.z; }
//etc, etc

template <typename T> class Thingamajig
{
public:
    enum { value = sizeof (T); };
};

template <>
class Thingamajig<double> class Thingamajig
{
public:
    int value(int a) { return a/3; }
};

template <typename T> Thingamajig<T> thingamatize(const T& t)
{
    return Thingajamig<T>();
}

Foo myfoo = { 1, 2, 3 };
size_t result = sizeof(thingamatize(std::abs(4 - evaluate(myfoo))).value('B'));

确定应该选择double evaluate(Foo f) 是一个非常漫长的过程。

另请阅读：http://blogs.msdn.com/ericlippert/archive/2006/03/31/delegates-lambdas-type-inference-and-long-playing-records.aspx

“您今天想为您的编译器创建多少工作？™”

Answer 4

选择重载时不使用函数的返回类型。这就是语言的工作原理。

但是，隐式转换是根据上下文选择的。所以，技术上你可以通过返回可以隐式转换为引用和指针的东西来编译它。

#include <iostream>
#include <string>

struct Evil
{
    std::string* p;
    Evil(std::string* p): p(p) {}
    operator std::string*() const { return p; }
    operator std::string&() const { return *p; }
};

struct ConstEvil
{
    const std::string* p;
    ConstEvil(const std::string* p): p(p) {}
    operator const std::string*() const { return p; }
    operator const std::string&() const { return *p; }
};

class Foo {
    std::string s;
public:
    ConstEvil GetString() const { return ConstEvil(&s); }
    Evil GetString() { return Evil(&s); }
};

int main(int argc, char** argv){
    Foo foo;
    const std::string& s = foo.GetString(); // ok
    return 0;
}

但真正的答案是，在 constness 上重载的函数应该具有类似的返回类型。 （我想这就是约定“对可变事物使用指针，对不可变事物使用常量引用”的地方。）