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

Затем я определил оператор как свободную функцию и упростил реализацию следующим образом:

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

Я не могу понять, что я делаю неправильно. Дайте мне знать, если нужно больше деталей.

Спасибо за совет!

П.С .: Я компилирую с помощью clang ++ -std = c ++ 14

0

Решение

Ваша проблема бесконечный цикл в 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* для некоторых из ваших методов — но это другая тема в другой раз 🙂

3

Другие решения


По вопросам рекламы ammmcru@yandex.ru
Adblock
detector