Question

我实现了一个像std :: vector这样的容器，目的是学习C ++及其习语。

为了重载operator ==，我首先编写了自己的版本：

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

正在打印的最后一个字符串是＆＃34;比较＆＃34; （由运营商打印==），然后我得到分段错误。

这是我的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==的第二个版本中调用，第一个版本不会触发它。

只需使用与非const版本相同的实现替换实现：

T* begin() const{
    return _elements;
}

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

您可能还会考虑const_iterator，例如，对某些方法返回const T*而不是T* - 但这是另一个主题的另一个主题：）

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

1 个答案: