要完整c++代码以及算法：可靠性和可维护性 仿真涉及大量随机变量。动态阵列的使用将大大提高仿真效率和解决问题的规模。请设计矢量。 这个问题需要实现一个向量类模板，可以实现数据的存储和访问。 （1） [] 运算符只能访问现有元素。 （2）add方法可以在访问时自动扩展内部存储空间。 请注意，此向量的行为与 std：： 向量的行为不同。 函数接口定义： 模板<T类> 类向量 { ... } 裁判测试程序示例： <iostream>#include 使用命名空间标准; /* 待办事项：在这里写下你的代码！*/ int main（） { 矢量<int>品脱; 国际 n，m; CIN >> n >> m; for （ int i=0; i<n; i++ ） { add（） 可以自动给向量充气 vint.add（i）; } get_size（） 返回存储在向量中的元素数 cout << vint.get_size（） << endl; Cout << vint[m] << endl; remove（） 删除索引处从零开始的元素 Vint.remove（m）; cout << vint.add（-1） << endl; cout << vint[m] << endl; 矢量<int> vv = vint; cout << vv[vv.get_size（）-1] << endl; vv.add（m）; cout << vint.get_size（） << endl; }

以下是一个简单的向量类模板的 C++ 代码，可以实现数据的存储和访问，并且可以自动扩展内部存储空间。

#include <iostream>
#include <algorithm>

template<typename T>
class Vector {
private:
    T* data;
    size_t size;
    size_t capacity;

public:
    Vector() : data(nullptr), size(0), capacity(0) {}

    ~Vector() {
        if (data) {
            delete[] data;
        }
    }

    Vector(const Vector& other) : data(new T[other.capacity]), size(other.size), capacity(other.capacity) {
        std::copy(other.data, other.data + other.size, data);
    }

    Vector& operator=(const Vector& other) {
        if (this != &other) {
            T* new_data = new T[other.capacity];
            std::copy(other.data, other.data + other.size, new_data);
            delete[] data;
            data = new_data;
            size = other.size;
            capacity = other.capacity;
        }
        return *this;
    }

    void add(const T& value) {
        if (size == capacity) {
            capacity = capacity ? capacity * 2 : 1;
            T* new_data = new T[capacity];
            std::copy(data, data + size, new_data);
            delete[] data;
            data = new_data;
        }
        data[size++] = value;
    }

    void remove(size_t index) {
        if (index < size) {
            std::copy(data + index + 1, data + size, data + index);
            --size;
        }
    }

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

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

    size_t get_size() const {
        return size;
    }
};

int main() {
    Vector<int> vint;
    size_t n, m;
    std::cin >> n >> m;
    for (size_t i = 0; i < n; ++i) {
        vint.add(i);
    }
    std::cout << vint.get_size() << std::endl;
    std::cout << vint[m] << std::endl;
    vint.remove(m);
    std::cout << vint.add(-1) << std::endl;
    std::cout << vint[m] << std::endl;
    Vector<int> vv = vint;
    std::cout << vv[vv.get_size() - 1] << std::endl;
    vv.add(m);
    std::cout << vint.get_size() << std::endl;
    return 0;
}

该向量类模板使用动态数组来存储数据，可以在 add() 方法中自动扩展内部存储空间，可以使用 [] 运算符来访问现有元素，并且可以使用 remove() 方法删除索引处从零开始的元素。