在尝试实现MyVector时，我最终得到了：
#include <iostream>
#include <string>
using namespace std;
template <typename T>
class MyVector
{
int m_size = 0;
int m_capacity = 0;
T* m_data = nullptr;
public:
MyVector()
{
cout << "defautl ctor" << endl;
realloc(2);
}
MyVector(const MyVector& v)
: m_size(v.m_size),
m_capacity(v.m_capacity)
{
cout << "copy ctor" << endl;
m_data = new T[m_size];
*m_data = *v.m_data;
}
MyVector(MyVector&& v)
: m_size(v.m_size),
m_capacity(v.m_capacity)
{
cout << "move ctor" << endl;
m_data = move(v.m_data);
v.m_data = nullptr;
v.m_size = 0;
v.m_capacity = 0;
}
MyVector& operator= (const MyVector& v)
{
cout << "copy assignment operator" << endl;
// m_size = v.m_size;
// m_capacity = v.m_capacity;
// *m_data = *v.m_data;
MyVector<int> copy = v;
swap(*this, copy);
return *this;
}
void push_back(const T& value)
{
if (!(m_size < m_capacity))
{
// cout << value << " size is " << m_size << " capacity is " << m_capacity << endl;
realloc(m_size*2);
// return;
}
m_data[m_size++] = value;
}
T& operator[] (int index)
{
cout << "index " << index << " of size " << m_size << endl;
if (!(index < m_size))
cout << "index out of bounds" << endl;
return m_data[index];
}
int size()
{
return m_size;
}
T* begin()
{
return &m_data[0];
}
T* end()
{
return &m_data[size()];
}
private:
void realloc(int new_capacity)
{
// cout << __func__ << " new capacity " << new_capacity << endl;
T* data = new T[new_capacity];
for (int i = 0; i < m_size; i++)
data[i] = m_data[i];
delete[] m_data;
m_data = data;
m_capacity = new_capacity;
}
};
int main(int argc, char** argv)
{
cout << "starting..." << endl;
MyVector<int> a;
a.push_back(7);
MyVector<int> d;
d = a;
cout << a[0] << endl;
cout << d[0] << endl;
return 0;
}
其中operator=为
MyVector& operator= (const MyVector& v)
{
cout << "copy assignment operator" << endl;
// m_size = v.m_size;
// m_capacity = v.m_capacity;
// *m_data = *v.m_data;
MyVector<int> copy = v; // copy and swap
swap(*this, copy);
return *this;
}
然而，这似乎导致了一种递归行为。那么，我对复制和交换方法的理解是错误的吗？或者我还缺少什么？
如注释中所述，您没有为MyVector实现swap()函数，因此语句swap(*this, copy);正在调用std::swap()(使用using namespace std;的许多陷阱之一(，它将再次调用您的operator=，因此您看到了递归行为。
此外，您的复制构造函数没有正确实现。它不是将输入数组中的所有元素复制到新数组中。它只复制第一个元素。
此外，您还缺少一个用来释放已分配数组的析构函数。
此外，由于MyVector同时具有复制和移动构造函数，因此您的两个赋值operator=的可以(也应该(合并为一个按值获取MyVector的运算符。这使编译器可以根据调用方分别传入的是左值还是右值来决定是使用复制语义还是移动语义调用运算符。然后，无论给出什么，操作员都可以只使用swap，因为在输入操作员之前，输入已经被复制或移动。
试试类似的东西：
#include <iostream>
#include <string>
#include <algorithm>
#include <stdexcept>
template <typename T>
class MyVector
{
int m_size = 0;
int m_capacity = 0;
T* m_data = nullptr;
public:
MyVector()
{
std::cout << "default ctor" << std::endl;
realloc(2);
}
MyVector(const MyVector& v)
{
std::cout << "copy ctor" << std::endl;
realloc(v.m_capacity);
std::copy_n(v.m_data, v.m_size, m_data);
m_size = v.m_size;
}
MyVector(MyVector&& v)
{
std::cout << "move ctor" << std::endl;
v.swap(*this);
}
~MyVector()
{
std::cout << "dtor" << std::endl;
delete[] m_data;
}
MyVector& operator= (MyVector v)
{
std::cout << "assignment operator" << std::endl;
v.swap(*this);
return *this;
}
void push_back(const T& value)
{
if (m_size >= m_capacity)
{
// std::cout << value << " size is " << m_size << " capacity is " << m_capacity << std::endl;
realloc(m_size * 2);
}
m_data[m_size] = value;
++m_size;
}
T& operator[] (int index)
{
std::cout << "index " << index << " of size " << m_size << std::endl;
if (index < 0 || index >= m_size)
throw std::out_of_range("index out of bounds");
return m_data[index];
}
int size() const
{
return m_size;
}
T* begin()
{
return &m_data[0];
}
T* end()
{
return &m_data[m_size];
}
void swap(MyVector &other)
{
std::swap(m_data, other.m_data);
std::swap(m_size, other.m_size);
std::swap(m_capacity, other.m_capacity);
}
private:
void realloc(int new_capacity)
{
// std::cout << __func__ << " new capacity " << new_capacity << std::endl;
T* data = new T[new_capacity];
std::copy_n(m_data, m_size, data);
std::swap(m_data, data);
m_capacity = new_capacity;
delete[] data;
}
};
// for std::swap() to use via ADL...
void swap(MyVector &v1, MyVector &v2)
{
v1.swap(v2);
}