Question

我想知道如何为不同的返回类型（const和非const迭代器）实际重载std::vector::begin()或类似的方法，如 std::vector<int>::iterator it = vect.begin();和std::vector<int>::const_iterator 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();
}

error: no viable conversion from 'B' to 'A' A x = c.f();

调用返回B的方法，为什么编译器不会从A x推断出需要调用另一个方法，以及我的测试程序和stl_vector代码之间有什么区别？

Answer 1

您没有看到过载，而是相关的iterator和const_iterator类型之间的转化：

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

如果vect为非常量，则vect.begin()会返回vector<int>::iterator，然后可以将其转换为vector<int>::const_iterator。由于const的正确性原因，不允许进行反向转换。

这与const成员函数的限定问题基本无关，它确实允许重载。

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

1 个答案: