C++ 使用const关键字重载签名相同的方法

我想知道，对于不同的返回类型（常量迭代器和非常量迭代器），如何实际重载

std:：vector:：begin（）

或类似的方法，如

std:：vector:：iterator it=vect.begin（）和
std:：vector:：const_迭代器cit=vect.begin（）

因为，只在返回类型上不同的函数不能重载。然后我浏览了一下
stl_vector.h
，发现这是可能的，因为其中一个函数是
const

324      /**                                                                       |   
325       *  Returns a read/write iterator that points to the first                |   
326       *  element in the %vector.  Iteration is done in ordinary                |   
327       *  element order.                                                        |   
328       */                                                                       |   
329      iterator                                                                  |   
330      begin()                                                                   |   
331      { return iterator(this->_M_impl._M_start); }                              |   
332                                                                                |   
333      /**                                                                       |   
334       *  Returns a read-only (constant) iterator that points to the            |   
335       *  first element in the %vector.  Iteration is done in ordinary          |   
336       *  element order.                                                        |   
337       */                                                                       |   
338      const_iterator                                                            |   
339      begin() const                                                             |   
340      { return const_iterator(this->_M_impl._M_start); }                        |   
341                                                                                |   
342      /**                                                                       |   
343       *  Returns a read/write iterator that points one past the last           |   
344       *  element in the %vector.  Iteration is done in ordinary                |   
345       *  element order.                                                        |   
346       */                                                                       | 

然后我试着在测试程序中模仿这种结构，但我遇到了一个让我困惑的错误，因为逻辑看起来和我一样：

struct A
{
};

struct B
{
};


struct C
{
    A f() const {
        std::cout << "A" << "\n";
        return A();
    }
    B f() {
        std::cout << "B" << "\n";
        return B();
    }
};


int main(){
    C c;
    A x = c.f();
}

结构A
{
};
结构B
{
};
结构C
{
f（）常数{
std:：cout您没有看到重载，而是相关的
迭代器
和
常量迭代器
类型之间的转换：

std::vector<int>::const_iterator cit = vect.begin();

std:：vector:：const_迭代器cit=vect.begin（）；

如果
vect
为非常量，则
vect.begin（）
返回一个
vector:：iterator
，然后可以将其转换为
vector:：const\u iterator
。出于常量正确性原因，不允许反向转换

这在很大程度上与成员函数的
const
限定问题无关，后者确实允许重载。
尝试使c const…
std:：vector:：iterator it；std:：vector:：const_iterator cit=it；
有效。不确定这是否是您的误解，但重载不是基于返回值选择的，而是在你的例子中，
c
不是常量，因此非常量方法被调用