【C++STL】模拟实现vector容器

**模拟实现Vector容器**

在C++标准库中，`std::vector`是最常用的序列容器之一。它提供了动态数组的功能，并且支持随机访问、插入和删除等操作。在本文中，我们将尝试模拟实现一个类似于`std::vector`的容器。

###1. 类定义首先，我们需要定义一个名为 `MyVector` 的类，继承自 `std::allocator`：

cpptemplate <typename T>
class MyVector : public std::allocator<T> {
public:
 // ...
};

这里，我们使用了模板来使得 `MyVector` 可以容纳任意类型的元素。

###2. 构造函数我们需要定义一个构造函数，用于初始化 `MyVector` 对象：

cpptemplate <typename T>
class MyVector : public std::allocator<T> {
public:
 explicit MyVector(size_t n =0) : _capacity(n), _size(0) {}

private:
 size_t _capacity;
 size_t _size;
};

在这个构造函数中，我们设置了容器的初始大小为 `n`，同时也初始化了 `_capacity` 和 `_size` 成员变量。

###3. resize()

当我们需要改变容器的大小时，可以使用 `resize()` 函数：

cpptemplate <typename T>
class MyVector : public std::allocator<T> {
public:
 void resize(size_t n) {
 if (n > _capacity) {
 // ...
 } else if (n < _size) {
 // ...
 }
 }

private:
 size_t _capacity;
 size_t _size;
};

在这个函数中，我们需要检查新的大小是否大于当前容器的大小。如果是，则需要重新分配内存空间；如果小于，则需要删除多余的元素。

###4. push_back()

当我们需要添加新元素时，可以使用 `push_back()` 函数：

cpptemplate <typename T>
class MyVector : public std::allocator<T> {
public:
 void push_back(const T& value) {
 if (_size == _capacity) {
 // ...
 }
 _data[_size++] = value;
 }

private:
 size_t _capacity;
 size_t _size;
 T* _data;
};

在这个函数中，我们需要检查当前容器是否已满。如果是，则需要重新分配内存空间；否则，可以直接添加新元素。

###5. pop_back()

当我们需要删除最后一个元素时，可以使用 `pop_back()` 函数：

cpptemplate <typename T>
class MyVector : public std::allocator<T> {
public:
 void pop_back() {
 if (_size ==0) {
 // ...
 }
 _data[--_size] = T();
 }

private:
 size_t _capacity;
 size_t _size;
 T* _data;
};

在这个函数中，我们需要检查当前容器是否为空。如果是，则什么也不做；否则，可以直接删除最后一个元素。

###6. operator[]当我们需要访问指定位置的元素时，可以使用 `operator[]` 函数：

cpptemplate <typename T>
class MyVector : public std::allocator<T> {
public:
 T& operator[](size_t n) {
 if (n >= _size) {
 // ...
 }
 return _data[n];
 }

private:
 size_t _capacity;
 size_t _size;
 T* _data;
};

在这个函数中，我们需要检查指定位置是否超出当前容器的大小。如果是，则什么也不做；否则，可以直接返回指定位置的元素。

###7. at()

当我们需要访问指定位置的元素时，可以使用 `at()` 函数：

cpptemplate <typename T>
class MyVector : public std::allocator<T> {
public:
 T& at(size_t n) {
 if (n >= _size) {
 // ...
 }
 return _data[n];
 }

private:
 size_t _capacity;
 size_t _size;
 T* _data;
};

在这个函数中，我们需要检查指定位置是否超出当前容器的大小。如果是，则抛出异常；否则，可以直接返回指定位置的元素。

###8. begin() 和 end()

当我们需要访问容器的开始和结束时，可以使用 `begin()` 和 `end()` 函数：

cpptemplate <typename T>
class MyVector : public std::allocator<T> {
public:
 iterator begin() { return _data; }
 iterator end() { return _data + _size; }

private:
 size_t _capacity;
 size_t _size;
 T* _data;
};

在这个函数中，我们可以直接返回容器的开始和结束指针。

###9. empty()

当我们需要检查容器是否为空时，可以使用 `empty()` 函数：

cpptemplate <typename T>
class MyVector : public std::allocator<T> {
public:
 bool empty() const { return _size ==0; }

private:
 size_t _capacity;
 size_t _size;
};

在这个函数中，我们可以直接检查当前容器的大小是否为零。

###10. size()

当我们需要获取容器的大小时，可以使用 `size()` 函数：

cpptemplate <typename T>
class MyVector : public std::allocator<T> {
public:
 size_t size() const { return _size; }

private:
 size_t _capacity;
 size_t _size;
};

在这个函数中，我们可以直接返回当前容器的大小。

###11. capacity()

当我们需要获取容器的最大容量时，可以使用 `capacity()` 函数：

cpptemplate <typename T>
class MyVector : public std::allocator<T> {
public:
 size_t capacity() const { return _capacity; }

private:
 size_t _capacity;
 size_t _size;
};

在这个函数中，我们可以直接返回当前容器的最大容量。

###12. reserve()

当我们需要改变容器的最大容量时，可以使用 `reserve()` 函数：

cpptemplate <typename T>
class MyVector : public std::allocator<T> {
public:
 void reserve(size_t n) { _capacity = n; }

private:
 size_t _capacity;
 size_t _size;
};

在这个函数中，我们可以直接改变当前容器的最大容量。

###13. max_size()

当我们需要获取容器的最大可能大小时，可以使用 `max_size()` 函数：

cpptemplate <typename T>
class MyVector : public std::allocator<T> {
public:
 size_t max_size() const { return std::numeric_limits<size_t>::max(); }

private:
 size_t _capacity;
 size_t _size;
};

在这个函数中，我们可以直接返回最大可能大小。

###14. operator==当我们需要比较两个容器是否相等时，可以使用 `operator==` 函数：

cpptemplate <typename T>
class MyVector : public std::allocator<T> {
public:
 bool operator==(const MyVector& other) const { return _size == other._size && std::equal(_data, _data + _size, other._data); }

private:
 size_t _capacity;
 size_t _size;
 T* _data;
};

在这个函数中，我们可以直接比较两个容器的大小和元素是否相等。

###15. operator!=当我们需要比较两个容器是否不相等时，可以使用 `operator!=` 函数：

cpptemplate <typename T>
class MyVector : public std::allocator<T> {
public:
 bool operator!=(const MyVector& other) const { return !(*this == other); }

private:
 size_t _capacity;
 size_t _size;
 T* _data;
};

在这个函数中，我们可以直接比较两个容器是否相等，然后取反结果。

###16. swap()

当我们需要交换两个容器的内容时，可以使用 `swap()` 函数：

cpptemplate <typename T>
class MyVector : public std::allocator<T> {
public:
 void swap(MyVector& other) { std::swap(_data, other._data); }

private:
 size_t _capacity;
 size_t _size;
 T* _data;
};

在这个函数中，我们可以直接交换两个容器的内容。

###17. get_allocator()

当我们需要获取容器的分配器时，可以使用 `get_allocator()` 函数：

cpptemplate <typename T>
class MyVector : public std::allocator<T> {
public:
 allocator_type get_allocator() const { return *this; }

private:
 size_t _capacity;
 size_t _size;
};

在这个函数中，我们可以直接返回容器的分配器。

###18. emplace_back()

当我们需要添加新元素时，可以使用 `emplace_back()` 函数：

cpptemplate <typename T>
class MyVector : public std::allocator<T> {