C++程序旋转矩阵元素

在三维空间中，旋转操作是一个很常见的操作。对于一个二维平面中的向量来说，可以使用旋转矩阵进行旋转。同样的，对于一个三维空间中的向量，也可以使用旋转矩阵进行旋转。旋转矩阵是一个3×3的矩阵，表示对于三维空间中的三个坐标轴进行旋转的操作。

假设有一个三维向量v(x, y, z)，它绕着z轴旋转θ角度，那么它的旋转矩阵是：

|cosθ -sinθ 0|
|sinθ cosθ  0|
| 0    0    1|

其中，cosθ表示θ的余弦值，sinθ表示θ的正弦值。旋转操作是一个线性变换，因此向量v的旋转结果为：

|cosθ -sinθ 0|   |x|   |cosθ*x-sinθ*y| 
|sinθ cosθ  0| * |y| = |sinθ*x+cosθ*y|
| 0    0    1|   |z|   |      z       |

C++实现

下面，我们在C++中实现旋转矩阵的计算和向量的旋转操作。首先，我们定义一个3×3的矩阵类Matrix3x3，包含以下成员函数：

构造函数Matrix3x3()：将矩阵的所有元素初始化为0。
构造函数Matrix3x3(double m11, double m12, double m13, double m21, double m22, double m23, double m31, double m32, double m33)：将矩阵的所有元素初始化为给定的值。
成员函数double& operator()(size_t row, size_t col)：返回矩阵的(row, col)元素的引用。
成员函数Matrix3x3 operator*(const Matrix3x3& other) const：返回矩阵与other矩阵的乘积。
静态函数Matrix3x3 RotationX(double angle)：返回绕x轴旋转angle角度的旋转矩阵。
静态函数Matrix3x3 RotationY(double angle)：返回绕y轴旋转angle角度的旋转矩阵。
静态函数Matrix3x3 RotationZ(double angle)：返回绕z轴旋转angle角度的旋转矩阵。

代码如下所示：

#include <cmath>

class Matrix3x3 {
public:
    Matrix3x3() {
        for (size_t i = 0; i < 3; ++i) {
            for (size_t j = 0; j < 3; ++j) {
                data_[i][j] = 0.0;
            }
        }
    }

    Matrix3x3(double m11, double m12, double m13, double m21, double m22, double m23, double m31, double m32, double m33) {
        data_[0][0] = m11; data_[0][1] = m12; data_[0][2] = m13;
        data_[1][0] = m21; data_[1][1] = m22; data_[1][2] = m23;
        data_[2][0] = m31; data_[2][1] = m32; data_[2][2] = m33;
    }

    double& operator()(size_t row, size_t col) {
        return data_[row][col];
    }

    const double& operator()(size_t row, size_t col) const {
        return data_[row][col];
    }

    Matrix3x3 operator*(const Matrix3x3& other) const {
        Matrix3x3 result;
        for (size_t i = 0; i < 3; ++i) {
            for (size_t j = 0; j < 3; ++j) {
                result(i, j) = 0.0;
                for (size_t k = 0; k < 3; ++k) {
                    result(i, j) += data_[i][k] * other(k, j);
                }
            }
        }
        return result;
    }

    static Matrix3x3 RotationX(double angle) {
        double cos_angle = cos(angle);
        double sin_angle = sin(angle);
        return Matrix3x3(1.0, 0.0, 0.0, 0.0, cos_angle, -sin_angle, 0.0, sin_angle, cos_angle);
    }

    static Matrix3x3 RotationY(double angle) {
        double cos_angle = cos(angle);
        double sin_angle = sin(angle);
        return Matrix3x3(cos_angle, 0.0, sin_angle, 0.0, 1.0, 0.0, -sin_angle, 0.0, cos_angle);
    }

    static Matrix3x3 RotationZ(double angle) {
        double cos_angle = cos(angle);
        double sin_angle = sin(angle);
        return Matrix3x3(cos_angle, -sin_angle, 0.0, sin_angle, cos_angle, 0.0, 0.0, 0.0, 1.0);
    }

private:
    double data_[3][3];
};

接下来，我们定义一个3维向量类Vector3，包含以下成员函数：

构造函数Vector3()：将向量的所有元素初始化为0。
构造函数Vector3(double x, double y, double z)：将向量的三个元素初始化为给定的值。
成员函数double& operator[](size_t index)：返回向量的第index个元素的引用。
成员函数const double& operator[](size_t index) const：返回向量的第index个元素的常引用。
静态函数Vector3 Rotate(const Vector3& v, const Matrix3x3& m)：将向量v进行矩阵m的旋转操作，返回旋转后的向量。

代码如下所示：

class Vector3 {
public:
    Vector3() {
        for (size_t i = 0; i < 3; ++i) {
            data_[i] = 0.0;
        }
    }

    Vector3(double x, double y, double z) {
        data_[0] = x; data_[1] = y; data_[2] = z;
    }

    double& operator[](size_t index) {
        return data_[index];
    }

    const double& operator[](size_t index) const {
        return data_[index];
    }

    static Vector3 Rotate(const Vector3& v, const Matrix3x3& m) {
        double x = m(0, 0) * v[0] + m(0, 1) * v[1] + m(0, 2) * v[2];
        double y = m(1, 0) * v[0] + m(1, 1) * v[1] + m(1, 2) * v[2];
        double z = m(2, 0) * v[0] + m(2, 1) * v[1] + m(2, 2) * v[2];
        return Vector3(x, y, z);
    }

private:
    double data_[3];
};

上述代码中，通过使用[]操作符重载实现了向量的元素访问。同时，定义了Rotate静态函数，完成了向量的旋转操作。

最后，我们给出一个例子，演示如何使用旋转矩阵对三维向量进行旋转。假设有一个三维向量v(-1, 2, 3)，我们将它绕着z轴旋转45度，然后绕着y轴旋转30度，再绕着x轴旋转60度。代码如下所示：

#include <iostream>

int main() {
    Vector3 v(-1.0, 2.0, 3.0);

    Matrix3x3 m = Matrix3x3::RotationZ(45.0 * M_PI / 180.0)
                *Matrix3x3::RotationY(30.0 * M_PI / 180.0)
                * Matrix3x3::RotationX(60.0 * M_PI / 180.0);

    Vector3 result = Vector3::Rotate(v, m);

    std::cout << "Original vector: (" << v[0] << ", " << v[1] << ", " << v[2] << ")" << std::endl;
    std::cout << "Rotated vector: (" << result[0] << ", " << result[1] << ", " << result[2] << ")" << std::endl;

    return 0;
}

在上述代码中，向量v被定义为(-1, 2, 3)，然后我们使用Matrix3x3类的静态函数RotationZ、RotationY和RotationX分别得到绕z轴、y轴和x轴旋转的旋转矩阵，然后将它们乘起来得到总的旋转矩阵m。向量v被传入Rotate静态函数中，得到旋转后的向量result，最后输出结果。