C++:我的容器的 std::equal 段错误

Question

我正在实现一个像 std::vector 这样的容器，目的是学习 C++ 及其习惯用法。

为了重载运算符==，我先写了自己的版本:

bool operator==(const Vector& other) const{
    if (_size == other._size) {
        for (int i = 0; i < _size; i++)
            if (!(_elements[i] == other[i]))
                return false;
        return true;
    }
    return false;
}

然后我将运算符定义为一个自由函数并简化实现如下:

template <typename T>
bool operator==(const Vector<T>& first, const Vector<T>& second){
    std::cout << "Comparing" << std::endl;
    return std::equal(first.begin(), first.end(), second.begin(), second.end());
}

我的第一个实现效果很好，但第二个实现出现段错误。

使用此示例测试实现:

#include <iostream>
#include "vector.hpp"
int main(int argc, char** argv) {
    Vector<int> v;
    Vector<int> v1;

    for (int i = 0; i<5; i++)
        v1.push_back(i);

    v = v1;
    for (auto i : v)
        std::cout << i << std::endl;

    if (v == v1)    // This line gives segfault
        std::cout << "Equal" << std::endl;
    else
        std::cout << "Different" << std::endl;

    return 0;
}

正在打印的最后一个字符串是“Comparing”(由运算符 == 打印)，然后我得到段错误。

这是我的 Vector 实现的概述:

template <typename T>
class Vector {
private:
    T* _elements = nullptr;
    size_type _capacity = 0;
    size_type _size = 0;
public:
    Vector () = default;

    // Copy constructor
    Vector (const Vector& other) {

        _capacity = other.capacity();
        if(_elements)
            delete[] _elements;
        _size = other.size();
        _elements = static_cast<T*>((void*)new char[_capacity*sizeof(T)]);
        for(int i = 0; i < _size; i++)
            new(&_elements[i]) T(other[i]);

    }

    // Copy Assignment
    Vector& operator=(Vector other){

        swap(*this, other);
        return *this;

    }

    template<typename U>
    friend void swap(Vector<U>& first, Vector<U>& second);

    template<typename U>
    friend bool operator==(const Vector<U>& first, const Vector<U>& second);

    T* begin(){
        return _elements;
    }

    T* end(){
        return &_elements[_size];
    }

    T* begin() const{
        return begin();
    }

    T* end() const{
        return end();
    }

    void push_back(const T& e){

        if(_size >= _capacity)
            reserve(1+_capacity*2);

        new (&_elements[_size++]) T{e};

    }
    ...
};

template<typename T>
void swap(Vector<T>& first, Vector<T>& second){

    using std::swap;
    // Unqualified function call resolved by the ADL
    swap(first._capacity, second._capacity);
    swap(first._size, second._size);
    swap(first._elements, second._elements);

}

template <typename T>
bool operator==(const Vector<T>& first, const Vector<T>& second){
    std::cout << "Comparing" << std::endl;
    return std::equal(first.begin(), first.end(), second.begin(), second.end());
}

我不知道我做错了什么。如果需要更多详细信息，请告诉我。

多谢指教!

P.S.: 我正在用 clang++ -std=c++14 编译

Answer 1

您的问题是 const 版本的 begin 和 end 中的无限循环:

T* begin() const{
    return begin();
}

当堆栈大小耗尽时，该循环将产生段错误。它仅在您的 operator== 的第二个版本中调用，第一个版本不会触发它。

只需将实现替换为与非常量版本相同的实现:

T* begin() const{
    return _elements;
}

T* end() const{
    return &_elements[_size];
}

您可能还会考虑 const_iterator，例如，为您的某些方法返回 const T* 而不是 T* - 但这是另一个话题下次再说:)