自定义向量类，满足向量维数可缩放，使用构造函数，析构函数，拷贝构造函数，赋值运算函数，使用异常处理，使用友元函数，使用运算符重载，名字叫MyVector

自定义一个名为`MyVector`的向量类，它允许向量的维数根据需要进行动态调整，下面是它的主要部分实现：

#include <iostream>
#include <vector>
using namespace std;

class MyVector {
private:
    vector<double> data;      // 存储向量数据
    mutable int dim;          // 当前维度，用mutable防止编译器优化掉对dim的修改

public:
    // 构造函数，初始化向量为空，维数为0
    MyVector() : dim(0) {}
    
    // 构造函数，根据指定维度和初始值初始化向量
    explicit MyVector(int size, double value = 0) {
        resize(size, value);
    }
    
    // 析构函数，释放存储资源
    ~MyVector() { clear(); }

    // 拷贝构造函数，确保新创建的对象拥有独立的数据
    MyVector(const MyVector& vec) : dim(vec.dim) {
        data.resize(dim);
        copy(vec.data.begin(), vec.data.end(), data.begin());
    }

    // 赋值运算符，将其他向量的数据复制到当前向量
    MyVector& operator=(const MyVector& vec) {
        if (this != &vec) {
            clear();
            dim = vec.dim;
            data.resize(dim);
            copy(vec.data.begin(), vec.data.end(), data.begin());
        }
        return *this;
    }

    // 添加一个维度并设置所有元素为默认值
    void push_back(double val = 0.0) {
        data.resize(dim + 1, val);
        dim++;
    }

    // 缩小维度并移除最后的元素
    void pop_back() {
        if (dim > 0) {
            data.resize(dim - 1);
            dim--;
        }
    }

    // 设置向量长度并填充元素
    void resize(int size, double value = 0.0) {
        data.resize(size, value);
        dim = size;
    }

    // 清空向量
    void clear() { data.clear(); dim = 0; }

    // 友元函数，用于输出向量
    friend std::ostream& operator<<(std::ostream& out, const MyVector& v);

    // 运算符重载，支持向量加法
    MyVector operator+(const MyVector& other) {
        if (dim == other.dim) {
            MyVector result(dim);
            for (int i = 0; i < dim; ++i) {
                result[i] = data[i] + other[i];
            }
            return result;
        } else {
            throw std::runtime_error("Vectors must have the same dimensions for addition");
        }
    }

protected:
    // 禁止直接访问数据成员
    double& operator[](int index) const {
        if (index >= 0 && index < dim) {
            return data[index];
        } else {
            throw std::out_of_range("Index out of range");
        }
    }

    // 异常处理示例：当尝试访问不存在的元素时抛出异常
    void check_dim(int index) const {
        if (index >= dim) {
            throw std::out_of_range("Index is out of bounds");
        }
    }
};

// 友元函数实现
std::ostream& operator<<(std::ostream& out, const MyVector& v) {
    out << "[";
    for (int i = 0; i < v.dim; ++i) {
        out << v[i] << " ";
    }
    out << "]";
    return out;
}

int main() {
    MyVector v1(3, 1.0), v2(3, 2.0);
    v1.push_back(3.5);
    v2.push_back(4.0);
    v1 *= 2;  // 示例赋值运算
    cout << "v1: " << v1 << endl;
    cout << "v2: " << v2 << endl;
    return 0;
}

上述代码展示了如何创建一个可缩放的向量类`MyVector`，包含了构造函数、析构函数、拷贝构造函数、赋值运算符以及相应的异常处理机制。同时，通过友元函数实现了向量的输出，并提供了加法运算符重载。