C++编写的Vector3类

信心满满的带了作品去顽石面试，结果在第二个环节被问到了3D数学，果断坑了，领教了一遍Unity3D只是工具，3D数学、图形算法才王道的思想。人家说的在理，也感觉自己太浮躁了，从现在开始一点一点的学回来！下面是一个最基础了Vector3类，其中基本包含了向量常用的方法，也是“3D数学基础 图形与游戏开发”这本书6.2章节的一个例子，感觉很不错，手打了一遍，多加了点注释。另外这个例子里有2个bug，（在159、176这两行）我个人暂时解决不了，有心人可以copy到vs里看一看

#include<math.h>

/*
 * 3D向量类
 */
class Vector3
{
public:
    //定义 x,y,z轴
    float x, y, z;
    
    //默认构造函数，不执行任何操作
    Vector3() {}

    //复制构造函数
    Vector3(const Vector3 &a) : x(a.x), y(a.y), z(a.z) {}

    //初始化构造函数
    Vector3(float nx, float ny, float nz) : x(nx), y(ny), z(nz) {}

    //标准对象操作
    Vector3 &operator = (const Vector3 &a)
    {
        x = a.x;
        y = a.y;
        z = a.z;
        return *this;
    }

    //置为零向量
    void zero() 
    { 
        x = y = z = 0.0f;    
    }

    //重载“==”操作符
    bool operator ==(const Vector3 &a) const
    {
        return x == a.x && y == a.y && z == a.z;
    }

    //重载“！=”操作符
    bool operator !=(const Vector3 &a) const
    {
        return x != a.x || y != a.y || z != a.z;
    }

    //重载一元“-”运算符
    Vector3 operator -() const
    {
        return Vector3(-x, -y, -z);    
    }

    //重载二元“+”运算符
    Vector3 operator +(const Vector3 &a) const
    {
        return Vector3(x + a.x, y + a.y, z + a.z);
    }

    //重载二元“-”运算符
    Vector3 operator -(const Vector3 &a) const
    {
        return Vector3(x - a.z, y - a.y, z - a.z);
    }

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

    //与标量的除法(不对除0进行检查)
    Vector3 operator /(float a) const
    {
        //获得倒数
        float reciprocalA = 1.0f / a;
        return Vector3(x * reciprocalA, y * reciprocalA, z * reciprocalA);
    }

    //重载简加运算符
    Vector3 &operator +=(const Vector3 &a)
    {
        x += a.x;
        y += a.y;
        z += a.z;
        return *this;
    }

    //重载简减运算符
    Vector3 &operator -=(const Vector3 &a)
    {
        x -= a.x;
        y -= a.y;
        z -= a.z;
        return *this;
    }

    //重载简乘运算符
    Vector3 &operator *=(const Vector3 &a)
    {
        x *= a.x;
        y *= a.y;
        z *= a.z;
        return *this;
    }

    //重载简乘运算符
    Vector3 &operator /=(const Vector3 &a)
    {
        x /= a.x;
        y /= a.y;
        z /= a.z;
        return *this;
    }

    //向量标准化(在没有改变本质关系的前提下，把向量的长度标准化为1)
    void normalize()
    {
        float magSq = x * x + y * y + z * z;
        //除零检查
        if(magSq > 0.0f)
        {
            //向量长度的倒数
            float magOver = 1.0f / sqrt(magSq);
            x *= magOver;
            y *= magOver;
            z *= magOver;
        }
    }

    //向量点乘，重载标准的乘法运算符
    float operator *(const Vector3 &a) const
    {
        return x * a.x + y * a.y + z * a.z;
    }

    /*
     * 非成员函数
     */

    //向量求模
    inline float vectorMag(const Vector3 &a)
    {
        return sqrt(a.x * a.x + a.y * a.y + a.z * a.z);
    }

    //向量叉乘
    inline Vector3 crossProduct(const Vector3 &a, const Vector3 &b)
    {
        return Vector3
        (
            a.x * b.y - a.y * b.x,
            a.y * b.z - a.z * b.y,
            a.z * b.x - a.x * b.z
        );
    }

    //标量左乘
    inline Vector3 operator *(float k, const Vector3 &v)
    {
        return Vector3(k * v.x, k * v.y, k * v.z);
    }

    //计算2点之间的距离
    inline float distance(const Vector3 &a, const Vector3 &b)
    {
        //得到向量
        float dx = a.x - b.x;
        float dy = a.y - b.y;
        float dz = a.z - b.z;
        //返回向量的大小
        return sqrt(dx * dx + dy * dy + dz * dz); 
    }

    //全局零向量
    extern const Vector3 kZeroVector;
};