设计一个MyVector（矢量）类，在类中定义整型成员变量x，y ，z代表矢量在三维笛卡尔坐标系上的坐标，与一个浮点型成员变量myLength代表矢量本身的模长

（长度），并且定义以下成员函数：

1. 构造函数MyVector(int xx = 0, int yy = 0, int zz = 0)：用默认参数的方式创建一个MyVector对象，同时将x、y、z初始化为xx、yy、zz，计算myLength的值。

2. 析构函数~MyVector()：释放MyVector对象所占用的内存。

3. 成员函数getX()、getY()、getZ()分别返回矢量的x、y、z坐标。

4. 成员函数getLength()返回矢量的模长。

5. 成员函数setX(int xx)、setY(int yy)、setZ(int zz)分别设置矢量的x、y、z坐标，并重新计算myLength的值。

6. 成员函数normalize()将矢量归一化（即将矢量的模长变为1），并重新计算x、y、z的值。

7. 成员函数dotProduct(MyVector v)返回当前矢量与参数矢量v的点积。

8. 成员函数crossProduct(MyVector v)返回当前矢量与参数矢量v的叉积，结果也是一个MyVector对象。

9. 成员函数add(MyVector v)返回当前矢量与参数矢量v相加的结果，也是一个MyVector对象。

10. 成员函数subtract(MyVector v)返回当前矢量与参数矢量v相减的结果，也是一个MyVector对象。

11. 友元函数operator+、operator-、operator*分别表示两个矢量相加、相减、点乘的运算，返回的结果也是一个MyVector对象。

12. 友元函数operator*表示矢量与标量的乘法，返回的结果也是一个MyVector对象。

示例代码：

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

class MyVector {
private:
    int x, y, z;
    float myLength;

public:
    MyVector(int xx = 0, int yy = 0, int zz = 0) {
        x = xx;
        y = yy;
        z = zz;
        myLength = sqrt(x * x + y * y + z * z);
    }

    ~MyVector() {}

    int getX() const {
        return x;
    }

    int getY() const {
        return y;
    }

    int getZ() const {
        return z;
    }

    float getLength() const {
        return myLength;
    }

    void setX(int xx) {
        x = xx;
        myLength = sqrt(x * x + y * y + z * z);
    }

    void setY(int yy) {
        y = yy;
        myLength = sqrt(x * x + y * y + z * z);
    }

    void setZ(int zz) {
        z = zz;
        myLength = sqrt(x * x + y * y + z * z);
    }

    void normalize() {
        if (myLength != 0) {
            x /= myLength;
            y /= myLength;
            z /= myLength;
            myLength = 1;
        }
    }

    float dotProduct(MyVector v) const {
        return x * v.x + y * v.y + z * v.z;
    }

    MyVector crossProduct(MyVector v) const {
        int xx = y * v.z - z * v.y;
        int yy = z * v.x - x * v.z;
        int zz = x * v.y - y * v.x;
        return MyVector(xx, yy, zz);
    }

    MyVector add(MyVector v) const {
        int xx = x + v.x;
        int yy = y + v.y;
        int zz = z + v.z;
        return MyVector(xx, yy, zz);
    }

    MyVector subtract(MyVector v) const {
        int xx = x - v.x;
        int yy = y - v.y;
        int zz = z - v.z;
        return MyVector(xx, yy, zz);
    }

    friend MyVector operator+(const MyVector& v1, const MyVector& v2) {
        return v1.add(v2);
    }

    friend MyVector operator-(const MyVector& v1, const MyVector& v2) {
        return v1.subtract(v2);
    }

    friend float operator*(const MyVector& v1, const MyVector& v2) {
        return v1.dotProduct(v2);
    }

    friend MyVector operator*(const MyVector& v, float k) {
        int xx = v.x * k;
        int yy = v.y * k;
        int zz = v.z * k;
        return MyVector(xx, yy, zz);
    }
};

int main() {
    MyVector v1(1, 2, 3);
    MyVector v2(4, 5, 6);
    MyVector v3 = v1 + v2;
    MyVector v4 = v1 - v2;
    float d = v1 * v2;
    MyVector v5 = v1 * 2;
    cout << v3.getX() << " " << v3.getY() << " " << v3.getZ() << endl;
    cout << v4.getX() << " " << v4.getY() << " " << v4.getZ() << endl;
    cout << d << endl;
    cout << v5.getX() << " " << v5.getY() << " " << v5.getZ() << endl;
    return 0;
}

输出结果：

5 7 9
-3 -3 -3
32
2 4 6