仿写向量类vector，至少实现：push_back()在表尾插入元素、insert()在向量的某位置插入元素、clear()清空向量中的元素、size()返回向量中元素的个数、empty()判断是否为空、erase()删除元素等功能。不用仿写迭代器。

好的，谢谢您的提问。以下是 ChitGPT 对您的问题的回答：

您可以仿写一个向量类Vector，其中至少要实现以下几个功能：

1. push_back()函数：在向量的末尾插入一个元素，可以通过动态扩展内部存储器来实现。

2. insert()函数：在向量的任意位置插入一个元素，可以通过自行实现一个复制函数来实现从目标位置到末尾的所有元素向后移动一个位置，然后再把新元素插入到目标位置。

3. clear()函数：清空向量中的所有元素，可以通过删除所有元素并将长度设置为0来实现。

4. size()函数：返回向量中元素的个数，可以直接返回向量长度。

5. empty()函数：判断是否为空，可以直接使用size()函数判断向量长度是否为0。

6. erase()函数：删除元素，可以自行实现一个复制函数来实现从目标位置到末尾的所有元素向前移动一个位置，然后再从末尾删除一个元素。

这些功能可以通过类的数据成员和成员函数来实现。以下是一个示例代码：

#include <iostream>
#include <stdlib.h>

using namespace std;

template <typename T>
class Vector
{
public:
    Vector() : m_size(0), m_capacity(0), m_data(nullptr) {}
    Vector(int n, const T& val) : m_size(0), m_capacity(0), m_data(nullptr) { assign(n, val); }
    Vector(const Vector& other) : m_size(0), m_capacity(0), m_data(nullptr) { assign(other); }
    Vector& operator=(const Vector& other);

    T& operator[](int i) { return m_data[i]; }
    const T& operator[](int i) const { return m_data[i]; }

    void push_back(const T& val);
    void insert(int pos, const T& val);
    void clear();
    int size() const { return m_size; }
    bool empty() const { return m_size == 0; }
    void erase(int pos);

private:
    void assign(int n, const T& val);
    void assign(const Vector& other);
    void reserve(int n);
    void resize(int n);
    void destroy();

private:
    int m_size;
    int m_capacity;
    T* m_data;
};

template <typename T>
Vector<T>& Vector<T>::operator=(const Vector<T>& other)
{
    if (this != &other) {
        destroy();
        assign(other);
    }
    return *this;
}

template <typename T>
void Vector<T>::push_back(const T& val)
{
    if (m_size == m_capacity) {
        reserve(max(2 * m_capacity, 1));
    }
    m_data[m_size++] = val;
}

template <typename T>
void Vector<T>::insert(int pos, const T& val)
{
    if (pos < 0 || pos > m_size) {
        return;
    }

    if (m_size == m_capacity) {
        reserve(max(2 * m_capacity, 1));
    }
    for (int i = m_size - 1; i >= pos; i--) {
        m_data[i + 1] = m_data[i];
    }
    m_data[pos] = val;
    m_size++;
}

template <typename T>
void Vector<T>::clear()
{
    destroy();
    m_size = 0;
}

template <typename T>
void Vector<T>::erase(int pos)
{
    if (pos < 0 || pos >= m_size) {
        return;
    }

    for (int i = pos; i < m_size - 1; i++) {
        m_data[i] = m_data[i + 1];
    }
    m_size--;
}

template <typename T>
void Vector<T>::assign(int n, const T& val)
{
    resize(n);
    for (int i = 0; i < m_size; i++) {
        m_data[i] = val;
    }
}

template <typename T>
void Vector<T>::assign(const Vector<T>& other)
{
    resize(other.m_size);
    for (int i = 0; i < m_size; i++) {
        m_data[i] = other.m_data[i];
    }
}

template <typename T>
void Vector<T>::reserve(int n)
{
    if (n <= m_capacity) {
        return;
    }
    T* new_data = new T[n];
    for (int i = 0; i < m_size; i++) {
        new_data[i] = m_data[i];
    }
    delete[] m_data;
    m_data = new_data;
    m_capacity = n;
}

template <typename T>
void Vector<T>::resize(int n)
{
    reserve(n);
    if (n >= m_size) {
        for (int i = m_size; i < n; i++) {
            m_data[i] = T();
        }
    }
    m_size = n;
}

template <typename T>
void Vector<T>::destroy()
{
    if (m_data != nullptr) {
        delete[] m_data;
        m_data = nullptr;
        m_capacity = 0;
    }
}

int main()
{
    Vector<int> vec;
    cout << "push_back 1, 2, 3" << endl;
    vec.push_back(1);
    vec.push_back(2);
    vec.push_back(3);
    cout << "size: " << vec.size() << endl;
    cout << "empty: " << vec.empty() << endl;
    cout << "insert 0 at pos 0" << endl;
    vec.insert(0, 0);
    cout << "size: " << vec.size() << endl;
    cout << "erase at pos 1" << endl;
    vec.erase(1);
    cout << "size: " << vec.size() << endl;
    cout << "clear" << endl;
    vec.clear();
    cout << "size: " << vec.size() << endl;
    cout << "empty: " << vec.empty() << endl;

    return 0;
}

希望能够满足您的需求，如有不足之处还请指正。