C++ 重载 getter 两次，一次返回指针，另一次返回 const 引用，失败

Question

正如标题所说，我正在尝试将 getter 重载到 return 两个指向成员变量的指针（mutator method) and a const reference (inspector 方法）。

请注意，上面link中的示例使用了一个引用和一个const引用，我不想要这个。

#include <vector>

class A {
public:
    A() : v() {}
    const std::vector<int>& get_v() const {return  v;}
    std::vector<int>*       get_v()       {return  &v;}
private:
    std::vector<int> v;
};

int main() {
    A a;
    a.get_v()->size();  // ok
    a.get_v().size();   // error: request for member ‘size’ in ‘a.A::get_v()’,
                        //        which is of pointer type ‘std::vector<int>*’
                        //        (maybe you meant to use ‘->’ ?)
}

它似乎工作正常，直到我尝试使用它抛出上面给出的错误描述。这种不当行为是否有原因（以及解决方法）？

Answer 1

It seems to work ok until I try to use it throwing the error description given above.

a.get_v().size();

那段代码显然是错误的，因为std::vector<int>* get_v()returns一个指针。关于尝试访问指针成员的错误消息非常清楚，这是您不能做的事情。要修复它，您需要使用箭头运算符取消引用指针，就像您在上面的行中所做的那样。

How can you say which one is used?

一个重载是非常量的，只能在非常量对象上调用。另一个是 const，可以在 const 和非常量对象上调用，但永远不会在非常量对象上调用它，因为非常量重载是首选。它是首选，因为它不需要将非常量对象参数转换为 const。对 const 成员函数的调用将需要这样的转换。不需要参数转换的重载优于那些需要转换的重载。因此，对于非常量对象参数，总是调用非常量版本。

the following also fails

std::vector<int>& v = a.get_v();

a 仍然是非常量，因此选择了 returns 指针的重载。您不能将非指针引用绑定到指针。

如果您想调用 returns 非常量对象上的 const 引用的函数，那么您必须给它另一个名称，这样它就没有比它更受欢迎的重载.

Do you have a reference for this?

我会引用 cppreference.com 因为这是非常基本的东西 - 尽管规则有点复杂。如果您怀疑它的正确性，请查找标准。

首先，关于成员函数重载的一些知识：

If any candidate function is a member function (static or non-static), but not a constructor, it is treated as if it has an extra parameter (implicit object parameter) which represents the object for which they are called and appears before the first of the actual parameters.

我认为很明显这两个重载都是候选者，因为它们具有相同的名称。它们也是可行的，因为它们具有正确数量的参数并且它们是可转换的。那么，哪种重载是首选？

For each pair of viable function F1 and F2, the implicit conversion sequences from the i-th parameter to i-th argument are ranked to determine which one is better

F1 is determined to be a better function than F2 if implicit conversions for all arguments of F1 are not worse than the implicit conversions for all arguments of F2, and

1) there is at least one argument of F1 whose implicit conversion is better than the corresponding implicit conversion for that argument of F2

...

好的，所以更好的转换序列是首选...哪个更好？让我们首先弄清楚转换序列是什么。唯一的参数是隐式对象参数。传递参数的类型是非常量 A.

非常量的重载有一个非常量类型的隐式对象参数A（它在这里并不真正相关，但它在实践中作为指针传递）。非常量 A 不需要转换为非常量 A 因为它是完全匹配。这将被视为身份转换。

const 的重载具有 const A 类型的隐式对象参数。 A 可以隐式转换为 const A.

两次转化的排名相同。在这种情况下，需要遵循一长串规则。 None 个适用，直到最后一部分：

f) Or, if not that, S1 and S2 only differ in qualification conversion, and the cv-qualification of the result of S1 is a subset of the cv-qualification of the result of S2

恒等式转换是常量转换的一个子集。因此它更好。我认为身份可能也更好，因为 cv-conversion 在计算身份转换时需要两次转换......不过我找不到关于那个的规则。

Answer 2

A a 不是常量，因此编译器无法应用 const std::vector<int>& get_v() const {return v;}

这个有效：

#include <vector>

class A {
public:
    A() : v() {}
    const std::vector<int>& get_v() const {return  v;}
    std::vector<int>*       get_v()       {return  &v;}
private:
    std::vector<int> v;
};

int main() {
    A a;
    a.get_v()->size();  // ok
    const A b;
    b.get_v().size();   // ok
}

已编辑 - 添加说明

为什么 b.get_v()->size(); 失败了？

来自there：

Best viable function

For each pair of viable function F1 and F2, the implicit conversion sequences from the i-th parameter to i-th argument are ranked to determine which one is better [...]

1) there is at least one argument of F1 whose implicit conversion is better than the corresponding implicit conversion for that argument of F2

案例 1：const std::vector<int>& get_v() const {return v;} 我们不需要转换任何东西

案例 2：std::vector<int>* get_v() {return &v;} 我们需要将指针 this 从 const A 转换为 A - 我们不能隐式地做，只能用 const_cast

所以编译器选择了情况 1。

C++ 重载 getter 两次，一次返回指针，另一次返回 const 引用，失败

C++ overloading getter twice, one returning pointer and the other const reference, fails

c++

getter

pointers

reference

constants