C++程序创建自定义向量类的程序

前言

向量是在很多科学、工程和数学领域都经常用到的一个重要数据结构。在C++中，我们可以使用STL库中的vector来实现向量操作，但是在某些情况下，需要自定义向量类，以便于更好地满足实际的应用需求。下面，我将介绍如何在C++中创建自定义向量类的程序，并提供相应的示例代码。

创建Vector类

首先，在C++中，我们可以用一个类来表示向量，该类可以包含向量长度、向量的起点、终点等信息。代码如下：

#include <iostream>
#include <cmath>

using namespace std;

class Vector {
public:
    Vector(int x=0, int y=0) : x(x), y(y) {}

    int getX() const {
        return x;
    }

    int getY() const {
        return y;
    }

    double length() const {
        return sqrt(x*x + y*y);
    }

    friend Vector operator+(const Vector& v1, const Vector& v2) {
        return Vector(v1.x+v2.x, v1.y+v2.y);
    }

    friend Vector operator-(const Vector& v1, const Vector& v2) {
        return Vector(v1.x-v2.x, v1.y-v2.y);
    }

private:
    int x, y;
};

int main() {
    Vector v1(3, 4), v2(1, 2);
    Vector v3 = v1 + v2;
    Vector v4 = v1 - v2;
    cout << "v1 = (" << v1.getX() << ", " << v1.getY() << ")" << endl;
    cout << "v2 = (" << v2.getX() << ", " << v2.getY() << ")" << endl;
    cout << "v1 + v2 = (" << v3.getX() << ", " << v3.getY() << "), length = " << v3.length() << endl;
    cout << "v1 - v2 = (" << v4.getX() << ", " << v4.getY() << "), length = " << v4.length() << endl;
    return 0;
}

在上面的代码中，我们定义了一个Vector类，并实现了向量的加、减、求长度等操作。

操作符重载

为了方便使用，我们可以为自定义的向量类重载各种操作符，例如加法、减法、乘法等。下面是一个重载加法和减法运算符的例子：

friend Vector operator+(const Vector& v1, const Vector& v2) {
    return Vector(v1.x+v2.x, v1.y+v2.y);
}

friend Vector operator-(const Vector& v1, const Vector& v2) {
    return Vector(v1.x-v2.x, v1.y-v2.y);
}

使用重载后的加法和减法运算符，可以更方便地实现向量加、减等操作，例如：

Vector v1(3, 4), v2(1, 2);
Vector v3 = v1 + v2;
Vector v4 = v1 - v2;

封装和继承

在实际应用中，我们会遇到一些需求，例如需求输出两个向量夹角的余弦值，或者将向量类拓展为二维或三维向量类等。这些需求可以通过封装和继承来实现。下面给出相应的代码示例。

封装：

class Vector {
public:
    Vector(int x=0, int y=0) : x(x), y(y) {}

    ...

    double angle(const Vector& v) const {
        double cosTheta = dotProduct(*this, v) / (this->length() * v.length());
        return cosTheta;
    }

private:
    int x, y;

    static double dotProduct(const Vector& v1, const Vector& v2) {
        return v1.x*v2.x + v1.y*v2.y;
    }
};

在上面的代码中，我们实现了一个夹角函数，该函数能够计算出两个向量的夹角余弦值。这里我们使用了静态成员函数来实现点积运算，而不必在类外部实现相应的函数。

继承：

class Vector2D : public Vector {
public:
    Vector2D(int x=0, int y=0) : Vector(x, y) {}

    double crossProduct(const Vector2D& v) const {
        return this->getX()*v.getY() - this->getY()*v.getX();
    }
};

class Vector3D : public Vector {
public:
    Vector3D(int x=0, int y=0, int z=0) : Vector(x, y), z(z) {}

    int getZ() const {
        return z;
    }

    Vector3D crossProduct(const Vector3D& v) const {
        int x = this->getY()*v.getZ() - this->getZ()*v.getY();
        int y = this->getZ()*v.getX() - this->getX()*v.getZ();
        int z = this->getX()*v.getY() - this->getY()*v.getX();
        return Vector3D(x, y, z);
    }

private:
    int z;
};

在上面的代码中，我们定义了两个类：二维向量类和三维向量类，它们都继承自Vector类。这里我们使用了继承来实现向量类的拓展，使得我们可以更方便地操作二维或三维向量。