重载运算符实现数学库：向量与矩阵的完整实现

说实话，数学库是C++运算符重载最经典的实战场景。我当年刚入行时，第一个独立负责的模块就是给公司自研引擎写一个轻量级数学库。那时候我才真正体会到——运算符重载用得好，代码能写得像数学公式一样优雅；用得不好，那就是一场灾难。

今天咱们就来聊聊，怎么给向量类和矩阵类实现一套完整的运算符重载。我会把我在项目中踩过的坑、积累的经验，一并分享给你。

为什么需要运算符重载？

你想想看，如果没有运算符重载，写向量加法得这样：

Vector3 result = a.add(b);

有了运算符重载，我们可以写成：

Vector3 result = a + b;

哪个更直观？显然是后者。数学库的消费者通常是图形程序员、游戏开发者，他们脑子里想的是数学公式，不是函数调用。运算符重载让代码和思维之间没有隔阂。

向量类的核心设计

我们先从向量类开始。以三维向量为例，它包含x、y、z三个分量。

class Vector3 {
public:
    float x, y, z;

    // 构造函数
    Vector3() : x(0), y(0), z(0) {}
    Vector3(float x, float y, float z) : x(x), y(y), z(z) {}

    // 基本算术运算符
    Vector3 operator+(const Vector3& rhs) const {
        return Vector3(x + rhs.x, y + rhs.y, z + rhs.z);
    }

    Vector3 operator-(const Vector3& rhs) const {
        return Vector3(x - rhs.x, y - rhs.y, z - rhs.z);
    }

    // 标量乘法
    Vector3 operator*(float scalar) const {
        return Vector3(x * scalar, y * scalar, z * scalar);
    }

    // 点积
    float dot(const Vector3& rhs) const {
        return x * rhs.x + y * rhs.y + z * rhs.z;
    }

    // 叉积
    Vector3 cross(const Vector3& rhs) const {
        return Vector3(
            y * rhs.z - z * rhs.y,
            z * rhs.x - x * rhs.z,
            x * rhs.y - y * rhs.x
        );
    }

    // 复合赋值运算符
    Vector3& operator+=(const Vector3& rhs) {
        x += rhs.x; y += rhs.y; z += rhs.z;
        return *this;
    }

    Vector3& operator*=(float scalar) {
        x *= scalar; y *= scalar; z *= scalar;
        return *this;
    }

    // 下标运算符
    float& operator[](int index) {
        return (&x)[index];
    }

    const float& operator[](int index) const {
        return (&x)[index];
    }

    // 负号运算符
    Vector3 operator-() const {
        return Vector3(-x, -y, -z);
    }

    // 相等比较
    bool operator==(const Vector3& rhs) const {
        return x == rhs.x && y == rhs.y && z == rhs.z;
    }

    bool operator!=(const Vector3& rhs) const {
        return !(*this == rhs);
    }
};

// 标量左乘（友元函数）
Vector3 operator*(float scalar, const Vector3& vec) {
    return vec * scalar;
}

// 输出流运算符
std::ostream& operator<<(std::ostream& os, const Vector3& vec) {
    os << "(" << vec.x << ", " << vec.y << ", " << vec.z << ")";
    return os;
}

个人经验：我习惯把下标运算符实现为访问连续内存的方式——(&x)[index]。这样做的前提是x、y、z在内存中是连续排列的。C++标准保证这一点，因为它们是同一个访问说明符下的成员变量。但如果你在成员之间插入了其他访问说明符，那就不能这么玩了。

矩阵类的设计要点

矩阵类比向量复杂得多。我们以4x4矩阵为例，它在3D图形中最常用。

class Matrix4 {
private:
    float data[4][4];  // 行主序存储

public:
    Matrix4() {
        // 初始化为单位矩阵
        for (int i = 0; i < 4; ++i)
            for (int j = 0; j < 4; ++j)
                data[i][j] = (i == j) ? 1.0f : 0.0f;
    }

    // 矩阵乘法
    Matrix4 operator*(const Matrix4& rhs) const {
        Matrix4 result;
        for (int i = 0; i < 4; ++i) {
            for (int j = 0; j < 4; ++j) {
                result.data[i][j] = 0;
                for (int k = 0; k < 4; ++k) {
                    result.data[i][j] += data[i][k] * rhs.data[k][j];
                }
            }
        }
        return result;
    }

    // 矩阵与向量乘法（变换向量）
    Vector3 operator*(const Vector3& vec) const {
        // 齐次坐标变换
        float w = data[3][0] * vec.x + data[3][1] * vec.y + 
                  data[3][2] * vec.z + data[3][3];
        if (w != 0) {
            return Vector3(
                (data[0][0] * vec.x + data[0][1] * vec.y + 
                 data[0][2] * vec.z + data[0][3]) / w,
                (data[1][0] * vec.x + data[1][1] * vec.y + 
                 data[1][2] * vec.z + data[1][3]) / w,
                (data[2][0] * vec.x + data[2][1] * vec.y + 
                 data[2][2] * vec.z + data[2][3]) / w
            );
        }
        return Vector3();
    }

    // 下标运算符（双重下标）
    float* operator[](int row) {
        return data[row];
    }

    const float* operator[](int row) const {
        return data[row];
    }

    // 转置
    Matrix4 transpose() const {
        Matrix4 result;
        for (int i = 0; i < 4; ++i)
            for (int j = 0; j < 4; ++j)
                result.data[i][j] = data[j][i];
        return result;
    }

    // 逆矩阵（简化版，仅适用于仿射变换）
    Matrix4 inverse() const {
        // 这里用高斯-约当消元法实现
        // 实际项目中建议使用成熟的算法库
        Matrix4 result;
        float temp[4][8];
        
        // 构建增广矩阵
        for (int i = 0; i < 4; ++i) {
            for (int j = 0; j < 4; ++j) {
                temp[i][j] = data[i][j];
                temp[i][j + 4] = (i == j) ? 1.0f : 0.0f;
            }
        }
        
        // 消元过程（省略具体实现，篇幅原因）
        // ...
        
        return result;
    }
};

注意：我曾经在项目中犯过一个低级错误——矩阵乘法没有考虑行主序和列主序的区别。OpenGL用的是列主序，DirectX用的是行主序。如果你在两种API之间混用，矩阵乘法的结果会完全错误。我的建议是：统一用一种存储方式，并在文档中明确标注。

运算符重载的避坑指南

写数学库的运算符重载，有几个坑我踩过不止一次，今天一并告诉你：

  1. 返回值类型的选择：算术运算符返回新对象（值返回），复合赋值运算符返回引用。这是C++的惯例，别搞反了。
  2. const正确性：不修改自身的成员函数一定要加const。我见过太多因为漏掉const导致无法调用的情况。
  3. 友元函数的必要性：标量左乘（如 2.0f * vec）必须用友元函数实现，因为左操作数不是Vector3类型。
  4. 性能考量：频繁的临时对象创建会带来性能开销。对于高性能场景，可以考虑表达式模板（Expression Templates）技术。

知识体系总览

下面这张图帮你理清数学库运算符重载的整体结构：

数学库运算符重载知识体系 运算符重载数学库 Vector3 向量类 算术运算符 + - * 点积 / 叉积 下标 / 负号 / 比较 Matrix4 矩阵类 矩阵 × 矩阵 矩阵 × 向量 转置 / 逆矩阵 关键设计原则 • 算术运算符返回值，复合赋值返回引用 • 标量左乘必须用友元函数 • 注意行主序与列主序的区别

完整示例：向量与矩阵的协同工作

有了上面的基础，我们来看看它们怎么配合使用：

int main() {
    // 创建向量
    Vector3 position(1.0f, 2.0f, 3.0f);
    Vector3 velocity(0.5f, 0.0f, 0.0f);
    
    // 向量运算
    Vector3 newPos = position + velocity * 2.0f;
    std::cout << "新位置: " << newPos << std::endl;
    
    // 创建变换矩阵
    Matrix4 translation;
    translation[0][3] = 5.0f;  // 沿X轴平移
    translation[1][3] = 3.0f;  // 沿Y轴平移
    
    // 矩阵变换向量
    Vector3 transformed = translation * position;
    std::cout << "变换后: " << transformed << std::endl;
    
    // 矩阵链式乘法
    Matrix4 rotation;  // 假设已填充旋转矩阵
    Matrix4 scale;     // 假设已填充缩放矩阵
    Matrix4 transform = translation * rotation * scale;
    
    return 0;
}

核心要点：运算符重载让数学库的使用者可以用自然的方式表达数学运算。但记住，重载的目的是提高可读性，不是炫技。如果一个运算符重载让代码更难理解，那就别用。

嗯，关于向量和矩阵的运算符重载，今天就聊到这儿。这些代码都是我实际项目中用过的模式，你拿过去稍作修改就能用。记住我提到的那些坑，尤其是行主序和列主序的问题——那是我用一次流片失败换来的教训。

公众号:蓝海资料掘金营，微信deep3321

← 上一章 📖 返回目录 下一章 →