C++；：std:：我的容器存在相等分段错误 我正在实现一个容器，例如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;
}

bool运算符==（常量向量和其他）常量{
如果（_size==其他。_size）{
对于（int i=0；i<\u size；i++）
if（！（_元素[i]==其他[i]））
返回false；
返回true；
}
返回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());
}

模板
布尔运算符==（常数向量和第一个、常数向量和第二个）{
std:：cout您的问题是
const
版本的
begin
和
end
中的无限循环：

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

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

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

T* begin() const{
    return _elements;
}

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

您也可以考虑使用
const\u迭代器
，例如，对于某些方法，返回
const T*
，而不是
T*
，但这是另一个时间的主题：）
您的问题是
const
版本的
begin
和
end
中的无限循环：

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

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

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

T* begin() const{
    return _elements;
}

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

您也可以考虑使用
const\u迭代器
，例如，对于某些方法，返回
const T*
，而不是
T*
，但这是另一个时间的主题：）
您的问题是
const
版本的
begin
和
end
中的无限循环：

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

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

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

T* begin() const{
    return _elements;
}

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

您也可以考虑使用
const\u迭代器
，例如，对于某些方法，返回
const T*
，而不是
T*
，但这是另一个时间的主题：）
您的问题是
const
版本的
begin
和
end
中的无限循环：

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

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

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

T* begin() const{
    return _elements;
}

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

您也可以考虑
const\u迭代器
，例如，对于某些方法，返回
const T*
而不是
T*
，但这是另一次的主题：）
调试器说了什么？您显示的代码可能不是真正的代码：
begin（）
和
end（））
不是
常量
，因此不能在
操作符==
中调用它，其中参数是
常量向量&
。我希望看到
推回
。在
结束（）
看起来是错误的，尽管我不确定仅仅为了获取该“元素”的地址而禁止对数组进行超出其边界的解引用。我会写
返回\u elements+\u size
，我确信它是有效的。
SEGFAULT
，实际上，大多数时候最容易捕获的错误（可能除了语法错误）。只需在调试器中启动它，然后查看stacktrace。@5gon12eder我认为它很好：调试器说了什么？您显示的代码不能是真正的代码：
begin（）
和
end（）
不是
常量
，因此不能在
操作符==
中调用它，其中参数是
常量向量&
。我希望看到
推回
。在
结束（）
看起来是错误的，尽管我不确定仅仅为了获取该“元素”的地址而禁止对数组进行超出其边界的解引用。我会写
返回\u elements+\u size
，我确信它是有效的。
SEGFAULT
，实际上，大多数时候最容易捕获的错误（可能除了语法错误）。只需在调试器中启动它，然后查看stacktrace。@5gon12eder我认为它很好：调试器说了什么？您显示的代码不能是真正的代码：
begin（）
和
end（）
不是
常量
，因此不能在
操作符==
中调用它，其中参数是
常量向量&
。我希望看到
推回
。在
结束（）
看起来是错误的，尽管我不确定仅仅为了获取该“元素”的地址而禁止对数组进行超出其边界的解引用。我会写
返回\u elements+\u size
，我确信它是有效的。
SEGFAULT
，实际上，大多数时候最容易捕获的错误（可能除了语法错误）。只需在调试器中启动它，然后查看stacktrace。@5gon12eder我认为它很好：调试器说了什么？您显示的代码不能是真正的代码：
begin（）
和
end（）
不是
const
，因此不能在
操作符==
中调用它，其中参数是
const Vector&
。我想看看
push_back
。
end（）
中的
return&\u元素[\u size]
看起来是错误的，尽管我不是实际的