C ++：我的容器的std :: equal segmentation fault

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;
}

正在打印的最后一個字符串是“比較”（由運算符==打印），然后出現分段錯誤。

這是我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());
}

我不知道我在做什么錯。 讓我知道是否需要更多詳細信息。

感謝您的建議！

PS：我正在使用clang ++ -std = c ++ 14進行編譯

Answer 1

您的問題是begin和end的const版本中的無限循環 ：

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

當堆棧大小用盡時，該循環將產生分段錯誤。 僅在operator==的第二個版本中調用它，第一個版本不會觸發它。

只需將實現替換為用於非const版本的實現即可：

T* begin() const{
    return _elements;
}

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

您可能還會考慮const_iterator ，例如，對於某些方法，返回const T*而不是T* -但這是另一回事了：)