C++ Vector实现

#pragma once
template
class Vector
{
public:
	Vector()
	{
		ReAlloc(2);
	}
	//Vector(size_t capacity) :m_size(capacity), m_capacity(capacity)
	//{ 
	//	m_data = new T[m_capacity]; 
	//}
	~Vector()
	{
		delete[] m_data;
	}

	void push_back(const T& value)
	{
		if (m_size >= m_capacity)
			ReAlloc(m_capacity + m_capacity / 2);

		m_data[m_size++] = value;
	}

	const T& operator[](size_t index) const
	{
		return m_data[index];
	}

	T& operator[](size_t index)
	{
		return m_data[index];
	}

private:
	void ReAlloc(size_t newCapacity)
	{
		T* newBlock = new T[newCapacity];
		// 如果正在缩小容量
		if (newCapacity < m_size)
			m_size = newCapacity;

		for (size_t i = 0; i < m_size; i++)
			newBlock[i] = m_data[i];
		delete[] m_data;
		m_data = newBlock;
		m_capacity = newCapacity;
	}
private:
	T* m_data = nullptr;
	size_t m_size = 0;
	size_t m_capacity = 0;
};

#pragma once
#include 
struct Vector3
{
	float x = 0.0f, y = 0.0f, z = 0.0f;
	Vector3()
	{
		std::cout << "Created" << std::endl;
	}
	Vector3(float scalar)
		: x(scalar), y(scalar), z(scalar)
	{
		std::cout << "Created" << std::endl;
	}
	Vector3(float x, float y, float z)
		: x(x), y(y), z(z)
	{
		std::cout << "Created" << std::endl;
	}

	Vector3(const Vector3& other)
		: x(other.x), y(other.y), z(other.z)
	{
		std::cout << "Copy" << std::endl;
	}
	
	// 移动构造函数
	Vector3(Vector3&& other) noexcept
		: x(other.x), y(other.y), z(other.z)
	{
		std::cout << "Move" << std::endl;
	}

	~Vector3()
	{
		std::cout << "Destroy" << std::endl;
	}

	Vector3& operator=(const Vector3& other)
	{
		x = other.x;
		y = other.y;
		z = other.z;
		std::cout << "Copy" << std::endl;
		return *this;
	}

	// 移动赋值运算符
	Vector3& operator=(Vector3&& other) noexcept
	{
		x = other.x;
		y = other.y;
		z = other.z;
		std::cout << "Move" << std::endl;
		return *this;
	}

	friend std::ostream& operator<<(std::ostream&, const Vector3&);
};
std::ostream& operator<<(std::ostream& os, const Vector3& vec)
{
	os << vec.x << ", " << vec.y << ", " << vec.z;
	return os;
}

#include "Vector.h"
#include "Vector3.h"
int main()
{
	Vector b;
	b.push_back(Vector3(1.0f));
	b.push_back(Vector3(2, 3, 4));
	b.push_back(Vector3());

	return 0;
}

首先我们创建了一个Vector
它默认创建了一个长度为2的Vector3数组
调用两次Created

第一次push_back之前，创建了一个Vector3
调用一次Created

传入的是右值，通过const修饰符编译器转换为不可修改的左值

接下来才进入第一次push_back的代码块，
之后的操作就相当于内存推入数组对应位置。
调用一次Copy

const修饰符转换的左值在离开push_back代码块时被释放，
调用一次Destroy

第二次push_back前，先产生一个右值Vector3
调用一次Created

进入第二次push_back的代码块，
调用一次Copy

执行完第二次push_back，临时左值被释放
调用一次Destroy

第三次push_back前，先产生一个右值Vector3
调用一次Created

进入第三次push_back代码块，由于容量不足，先扩容原来容量的一半，
新的容量为3
调用三次Created

把前两次的值赋给新的容器，
调用两次Copy

删除旧容器
调用两次Destroy

把第三次的值推入新容器
调用一次Copy

执行完第三次push_back，临时左值被释放
调用一次Destroy

主函数代码块结束，释放Vector
调用三次Destroy