C++ 自己实现vector容器

#include <initializer_list>
namespace my{
template<typename T>
class Alloctor {
public:
	T* allocate(size_t length) {
		cout << " Malloc " << length << endl;
		return (T*)malloc(sizeof(T)*length); // malloc方法返回void*, (T*)void* 是将void*转为T*类型，void*是无类型的指针。
	}
	void deallocate(T* p) {
		cout << " Dealloc " << p << endl;
		free(p); // free 方法不需要指定长度，malloc的真实长度只有自己知道，申请部分的头部应该记录了申请大小。
	}
	
	void construct(T* p, const T& val) { // 在p地址上 执行T(val)的构造函数
		cout << "Construct" << endl;
		new (p)T(val);
	}
	void destroy(T* p) {
		cout << "destroy" << endl;
		//delete p; 只能从malloc返回的指针开始释放，不能释放一部分，这是free要求的。delete=free+destructor
		p->~T();
	}
};

template<typename T>
class vector {
public:
	vector() : begin_(nullptr), end_(nullptr), end_of_storage_(nullptr), alloc(nullptr) {}
	vector(size_t size) {
		cout << "constructor(size)" << endl;
		alloc = new Alloctor<T>;
		begin_ = alloc->allocate(size);
		end_ = begin_;
		end_of_storage_ = begin_ + size;
	}
	vector(const vector<T>& vec) {
		cout << "copy, const&" << endl;
		alloc = new Alloctor<T>;
		size_t size = vec.end_ - vec.begin_;
		begin_ = alloc->allocate(size);
		end_ = begin_ + size;
		end_of_storage_ = end_;

		T* cur = begin_;
		for (T* p = vec.begin_; p != vec.end_; ++p, ++cur) {
			alloc->construct(cur, *p);
		}
	}
	vector(vector<T>&& vec) {
		cout << "copy, &&" << endl;
		begin_ = vec.begin_;
		end_ = vec.end_;
		end_of_storage_ = vec.end_of_storage_;
		alloc = vec.alloc;

		vec.begin_ = nullptr;
		vec.end_ = nullptr;
		vec.end_of_storage_ = nullptr;
		vec.alloc = nullptr;
	}
	vector(const std::initializer_list<T>& list) {
		size_t size = list.size();
		alloc = new Alloctor<T>;
		begin_ = alloc->allocate(size);
		end_ = begin_ + size;
		end_of_storage_ = end_;

		T* iter = begin_;
		for (const auto& val: list) {
			alloc->construct(iter, val);
			iter++;
		}
	}
	vector<T>& operator=(const vector<T>& vec) { // ??? 返回值不需要模板?
		cout << "operator, &" << endl;
		if (this == &vec) return *this;
		alloc->deallocate(begin_);
		delete alloc;

		alloc = new Alloctor<T>;
		size_t size = vec.end_ - vec.begin_;
		begin_ = alloc->allocate(size);
		end_ = begin_ + size;
		end_of_storage_ = end_;
		
		T* cur = begin_;
		for (T* p = vec.begin_; p != vec.end_; ++p) {
			alloc->construct(cur, *p);
		}

		return *this;
	}
	vector<T>& operator=(vector<T>&& vec) {
		cout << "operator, &&" << endl;
		begin_ = vec.begin_;
		end_ = vec.end_;
		end_of_storage_ = vec.end_of_storage_;
		alloc = vec.alloc;
		
		vec.begin_ = nullptr;
		vec.end_ = nullptr;
		vec.end_of_storage_ = nullptr;
		vec.alloc = nullptr;
		return *this;
	}

	~vector() {
		cout << "destruct vector" << endl;
		alloc->deallocate(begin_); // 可以delete, free空指针，但是不能是野指针
		delete alloc;
	}

	void push_back(const T& val) {
		cout << "push" << endl;
		if (end_ == end_of_storage_) {
			resize();
		}
		alloc->construct(end_, val);
		end_ += 1;
	}

	void pop_back() {
		cout << "pop" << endl;
		if (end_ == begin_) return;
		alloc->destroy(--end_);
	}

	T& operator[](size_t index) {
		return *(begin_+index);
	}	

private:
	T* begin_;
	T* end_; // [)
	T* end_of_storage_; // [)
	Alloctor<T>* alloc; // 注意释放

	void resize() {
		cout << "---- Resize ----" << endl;
		size_t size = end_of_storage_ - begin_;
		T* new_begin = alloc->allocate(2*size? size != 0 : 4);
		T* new_ptr = new_begin;
		for (T* p = begin_; p != end_; ++p, ++new_ptr) {
			alloc->construct(new_ptr, *p);
		}
		alloc->deallocate(begin_);
		begin_ = new_begin;
		end_ = new_begin + size;
		end_of_storage_ = begin_ + 2 * size;
	}

};

void test() {
	vector<int> vec1;
	vector<int> vec2(2);
	vector<int> vec3(vec2);
	vec2.push_back(1);
	vec2.push_back(2);
	cout << vec2[0] << " " << vec2[1] << endl;
	vector<int> vec4 = vec2;
	vec1 = vec2;
	vec4.pop_back();
	cout <<vec4[0] << " " << endl;
	vec2.push_back(3);
	vector<int> vec5 = std::move(vec3);
	vector<int> vec6 = {1, 2, 3};
	cout << "END" << endl;
}