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