在C++中创建自定义矢量类的程序

矢量是数学中非常常用的概念。在计算机科学中，矢量通常指在n维空间中的向量。C++ STL中提供了std::vector，但是有时候我们需要自己创建一个矢量类以满足自己的需求。

1. 定义矢量类

template<typename T>
class Vector {
private:
    T* data_;
    int size_;
public:
    Vector() : data_(nullptr), size_(0) {}
    Vector(int size) : data_(new T[size]), size_(size) { }
    ~Vector() { delete[] data_; }

    int size() const { return size_; }

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

以上代码是一个简单的矢量类的定义。矢量类的私有成员包含一个指向数组的指针和数组大小。这里使用了模板以支持任何类型的元素。类的默认构造函数将指针初始化为nullptr，大小初始化为0。有参构造函数将创建一个大小为size的数组并将指针指向它。类的析构函数将删除数组以释放内存。

2. 重载运算符

接下来我们需要重载运算符以实现向量之间的基本运算，例如加、减、数乘等。

template<typename T>
Vector<T> operator+(const Vector<T>& lhs, const Vector<T>& rhs) {
    assert(lhs.size() == rhs.size());
    Vector<T> res(lhs.size());
    for(int i = 0; i < lhs.size(); ++i) {
        res[i] = lhs[i] + rhs[i];
    }
    return res;
}

template<typename T>
Vector<T> operator-(const Vector<T>& lhs, const Vector<T>& rhs) {
    assert(lhs.size() == rhs.size());
    Vector<T> res(lhs.size());
    for(int i = 0; i < lhs.size(); ++i) {
        res[i] = lhs[i] - rhs[i];
    }
    return res;
}

template<typename T>
Vector<T> operator*(T k, const Vector<T>& rhs) {
    Vector<T> res(rhs.size());
    for(int i = 0; i < rhs.size(); ++i) {
        res[i] = k * rhs[i];
    }
    return res;
}

template<typename T>
Vector<T> operator*(const Vector<T>& lhs, T k) {
    Vector<T> res(lhs.size());
    for(int i = 0; i < lhs.size(); ++i) {
        res[i] = lhs[i] * k;
    }
    return res;
}

以上代码是向量的基本运算符重载。加、减、数乘都可以通过遍历数组实现。需要注意的是，C++的数组下标从0开始，所以for循环的控制变量也应该从0开始。

使用assert()宏可以在运行时检查条件，如果条件不满足则程序会抛出异常。在这里使用assert()宏可以保证向量之间的加、减运算要求两个向量具有相同的大小。

3. 示例代码

int main() {
    Vector<int> v1(3);
    Vector<int> v2(3);
    v1[0] = 1; v1[1] = 2; v1[2] = 3;
    v2[0] = 4; v2[1] = 5; v2[2] = 6;

    Vector<int> v3 = v1 + v2;
    Vector<int> v4 = v1 - v2;
    Vector<int> v5 = 2 * v1;
    Vector<int> v6 = v2 * 2;

    std::cout << "v1: ";
    for(int i = 0; i < v1.size(); ++i) {
        std::cout << v1[i] << " ";
    }
    std::cout << std::endl;

    std::cout << "v2: ";
    for(int i = 0; i < v2.size(); ++i) {
        std::cout << v2[i] << " ";
    }
    std::cout << std::endl;

    std::cout << "v1 + v2: ";
    for(int i = 0; i < v3.size(); ++i) {
        std::cout << v3[i] << " ";
    }
    std::cout << std::endl;

    std::cout << "v1 - v2: ";
    for(int i = 0; i < v4.size(); ++i) {
        std::cout << v4[i] << " ";
    }
    std::cout << std::endl;

    std::cout << "2 * v1: ";
    for(int i = 0; i < v5.size(); ++i) {
        std::cout << v5[i] << " ";
    }
    std::cout << std::endl;

    std::cout << "v2 * 2: ";
    for(int i = 0; i < v6.size(); ++i) {
        std::cout << v6[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}

以上是一个使用矢量类的示例程序。向量v1和v2分别被初始化为{1, 2, 3}和{4, 5, 6}，运用重载运算符进行加、减、数乘等运算输出结果。运行结果如下：

v1: 1 2 3
v2: 4 5 6
v1 + v2: 5 7 9
v1 - v2: -3 -3 -3
2 * v1: 2 4 6
v2 * 2: 8 10 12

4. 总结

自定义矢量类在C++编程中是很常见的。它能够为我们提供更加灵活的方式来实现多种操作。在实现时需要注意运算符重载的正确性。同时建议在构造函数、析构函数等方法中使用智能指针等机制，以避免内存泄漏等问题。