（1）网上参考的三维向量类
/*--------------------------------------------------
* 类名称：三维向量类-Vector.h
* 类作用：用于三维空间中向量常见的数学运算.
* 创建人：Edited by huangwang
* 创建时间：2017年6月19日
*--------------------------------------------------*/
#ifndef __VECTOR_H__
#define __VECTOR_H__
#include <math.h>
template <class T>
struct Vector3
{
// 创建一个三维向量向量
Vector3 (T x_=0, T y_=0, T z_=0) : x(x_), y(y_), z(z_) {}
// 设置三维向量三个方向上的坐标
void set (T x_, T y_, T z_) { x=x_; y=y_; z=z_; }
// 三维向量归一化
Vector3 normalize() const { return((*this) / norm()); }
double norm () const { return sqrt(normSquared()); }
T normSquared () const { return x*x+y*y+z*z; }
// BOOL型操作运算符
bool operator == (const Vector3& v) const { return x==v.x && y==v.y && z==v.z; }
bool operator != (const Vector3& v) const { return x!=v.x || y!=v.y || z!=v.z; }
// 常见的运算符
Vector3 operator + (const Vector3 &v) const { return Vector3(x+v.x, y+v.y, z+v.z); }
Vector3& operator += (const Vector3 &v) { x+=v.x; y+=v.y; z+=v.z; return *this; }
Vector3 operator - () const { return Vector3(-x, -y, -z); }
Vector3 operator - (const Vector3 &v) const { return Vector3(x-v.x, y-v.y, z-v.z); }
Vector3& operator -= (const Vector3 &v) { x-=v.x; y-=v.y; z-=v.z; return *this; }
Vector3 operator * (T s) const { return Vector3(x*s, y*s, z*s); }
Vector3& operator *= (float s) { x*=s; y*=s; z*=s; return *this; }
Vector3 operator / (float s) const { ASSERT(s); return (*this)* (1/s); }
Vector3& operator /= (float s) { ASSERT(s); return (*this)*=(1/s); }
// 三维向量坐标
T x, y, z;
};
template <class T> inline
//三维向量点积
T Dot (const Vector3<T>& l, const Vector3<T>& r)
{
return l.x*r.x + l.y*r.y + l.z*r.z;
}
// 三维向量叉积
template <class T> inline
Vector3<T> Cross (const Vector3<T>& l, const Vector3<T>& r)
{
return Vector3<T>(
l.y*r.z - l.z*r.y,
l.z*r.x - l.x*r.z,
l.x*r.y - l.y*r.x );
}
// 三维向量混合积
template <class T> inline
T BlendProduct (const Vector3<T>& l, const Vector3<T>& m, const Vector3<T>& r)
{
return Dot(Cross(l, m), r);
}
//各种三维向量类型的定义
typedef Vector3<char> Vector3c;
typedef Vector3<int> Vector3i;
typedef Vector3<float> Vector3f;
typedef Vector3<double> Vector3d;
#endif
（2）自己封装的三维向量类Vector3D
.h
//#pragma once
/*------Vector3D---------------------------------------------
类作用：三维向量类，提供向量的基本运算
作者：HuangWang
日期：2017年11月22日
-------------------------------------------------------------*/
#ifndef VECTOR3D_H
#define VECTOR3D_H
#include <math.h>
class Vector3D
{
public:
Vector3D();//默认的构造函数
Vector3D(const double p);//将向量的三个分量都初始化为一个数
Vector3D(const double v[]);//以一个double型的数值初始化三维向量
Vector3D(const double x_,const double y_,const double z_);//以三个double型数值初始化向量三个分量
Vector3D(const My3DPoint &p);//用My3DPoint构造三维向量
// Vector3D(const My3DPointWithNormalvector &p);//用My3DPointWithNormalvector初始化三维向量
Vector3D(const Vector3D &a); //复制构造函数
~Vector3D(void);//析构函数
void SetVector3D(const double tempx,const double tempy,const double tempz);//设置三维向量三个方向上的坐标
double DotProduct(const Vector3D &other)const;//三维向量点积
void CrossProduct(const Vector3D & l, const Vector3D & r);//三维向量叉积
Vector3D CrossProduct(const Vector3D &v)const;//三维向量叉积
double magnitude()const;//三个向量分量的平方和的根
double magnitudeSquared()const;//三个向量分量的平方和
void normalize();//向量归一化
double Distance (const Vector3D &a,const Vector3D &b);//两个向量之间的距离
double Distance (const Vector3D &v)const;//两个向量之间的距离
void SetZero();//置为0向量
void Vector3DMax(const Vector3D &v);//将当前向量与v的xyz分量比较得到较大分量
void Vector3DMin(const Vector3D &v);//将当前向量与v的xyz分量比较得到较小分量
void setNegative(const Vector3D &v);//将形参向量v取负赋值给当前向量
void setNegative();//将当前向量取负
void add(const Vector3D & a, const Vector3D & b);//将当前向量设置为a和b向量的和
void subtract(const Vector3D &a, const Vector3D &b);//将当前向量设置为a和b向量的差
void multiply(double s, const Vector3D & a);//将当前向量设置为数字s与向量a的数乘
void arrayMultiply(const Vector3D &a, const Vector3D &b);//将当前向量设置为向量a与向量b各个分量的乘积
// BOOL型操作运算符
bool operator == (const Vector3D& v) const //判断两个向量是否相等
{
return x==v.x && y==v.y && z==v.z;
}
bool operator != (const Vector3D& v) const //判断两个向量是否不相等
{
return x!=v.x || y!=v.y || z!=v.z;
}
// 常见的运算符
Vector3D& operator = (const Vector3D &v) //赋值运算
{
x=v.x;
y=v.y;
z=v.z;
return *this;
}
Vector3D operator + (const Vector3D &v) const//两个向量相加
{
return Vector3D(x+v.x, y+v.y, z+v.z);
}
Vector3D& operator += (const Vector3D &v) //两个向量相加
{
x+=v.x; y+=v.y; z+=v.z;
return *this;
}
Vector3D operator - () const //向量取反
{
return Vector3D(-x, -y, -z);
}
Vector3D operator -(const Vector3D &v) const //两个向量相减
{
return Vector3D(x-v.x, y-v.y, z-v.z);
}
Vector3D& operator -= (const Vector3D &v) //两个向量相减
{
x-=v.x; y-=v.y; z-=v.z;
return *this;
}
Vector3D operator * (const double s) const //向量数乘
{
return Vector3D(x*s, y*s, z*s);
}
Vector3D& operator *= (const double s) //向量数乘
{
x*=s; y*=s; z*=s;
return *this;
}
Vector3D operator / (const double s) const //向量除以一个数
{
ASSERT(s);
return (*this)* (1/s);
}
Vector3D& operator /= (const double s) //向量除以一个数
{
ASSERT(s); return (*this)*=(1/s);
}
bool operator< (const Vector3D&v) const
{
if( x < v.x) return true;
if( x > v.x) return false;
if( y < v.y) return true;
if( y > v.y) return false;
if( z < v.z) return true;
if( z > v.z) return false;
return false;
}
public:
double x,y,z;//xyz三个分量的大小
};
inline Vector3D operator *(const double s,const Vector3D &v)//内联函数 向量前乘一个数
{
return Vector3D(s*v.x,s*v.y,s*v.z);
}
#endif
.cpp
#include "StdAfx.h"
#include "Vector3D.h"
//默认构造函数
Vector3D::Vector3D()
{
}
//将向量的三个分量都初始化为一个数
Vector3D::Vector3D(const double p)
{
x=p;
y=p;
z=p;
}
//用一个double型的数组初始化三维向量
Vector3D::Vector3D(const double v[]):x(v[0]),y(v[1]),z(v[2])
{
}
//三个double型的数值分别初始化x,y,z三个分量
Vector3D::Vector3D(const double x_,const double y_,const double z_):x(x_),y(y_),z(z_)
{
}
//复制构造函数
Vector3D::Vector3D(const Vector3D &a){
x=a.x;
y=a.y;
z=a.z;
}
//以My3DPoint结构体作为参数构造向量
Vector3D::Vector3D(const My3DPoint &p)
{
x=p.X;
y=p.Y;
z=p.Z;
}
以My3DPointWithNormalvector结构体作为参数构造向量
//Vector3D::Vector3D(const My3DPointWithNormalvector &p)
//{
// x=p.zuobiao.X;
// y=p.zuobiao.Y;
// z=p.zuobiao.Z;
//}
//默认析构函数
Vector3D::~Vector3D(void)
{
}
//设置向量的XYZ坐标
void Vector3D::SetVector3D(const double tempx,const double tempy,const double tempz)
{
x=tempx;
y=tempy;
z=tempz;
}
//两向量的点积
double Vector3D::DotProduct(const Vector3D &other)const
{
return x*other.x + y*other.y + z*other.z;
}
//两向量的叉积
void Vector3D::CrossProduct(const Vector3D & l, const Vector3D & r)
{
double a = (l.y * r.z) - (l.z * r.y);
double b = (l.z * r.x) - (l.x * r.z);
double c = (l.x * r.y) - (l.y * r.x);
x = a;
y = b;
z = c;
}
Vector3D Vector3D::CrossProduct(const Vector3D &v)const
{
Vector3D temp;
temp.CrossProduct(*this,v);
return temp;
}
//三个向量分量平方和的根
double Vector3D::magnitude()const
{
return sqrt(x * x + y * y + z * z);
}
//三个向量分量的平方和
double Vector3D::magnitudeSquared()const
{
return x * x + y * y + z * z;
}
//向量标准化
void Vector3D::normalize()
{
double m = magnitude();
if (m)
{
const double il = double(1.0) / m;
x *= il;
y *= il;
z *= il;
}
}
//两个向量之间的距离
double Vector3D::Distance (const Vector3D &a,const Vector3D &b)
{
double dx = a.x - b.x;
double dy = a.y - b.y;
double dz = a.z - b.z;
return sqrt(dx * dx + dy * dy + dz * dz);
}
double Vector3D::Distance(const Vector3D &v)const
{
Vector3D tempObject;
double dis;
dis=tempObject.Distance(*this,v);
return dis;
}
//将三维向量置为0向量
void Vector3D::SetZero()
{
x=0;
y=0;
z=0;
}
//将当前向量与v的XYZ分量相比，得到较大的xyz分量
void Vector3D::Vector3DMax(const Vector3D &v)
{
x=x>v.x?x:v.x;
y=y>v.y?y:v.y;
z=z>v.z?z:v.z;
}
//将当前向量与v的XYZ分量相比，得到较大的xyz分量
void Vector3D::Vector3DMin(const Vector3D &v)
{
x=x<v.x?x:v.x;
y=y<v.y?y:v.y;
z=z<v.z?z:v.z;
}
//将形参向量v取负赋值给当前向量
void Vector3D::setNegative(const Vector3D &v)
{
x = -v.x;
y = -v.y;
z = -v.z;
}
//将当前向量取负
void Vector3D::setNegative()
{
x = -x;
y = -y;
z = -z;
}
//将当前向量设置为a和b向量的和
void Vector3D::add(const Vector3D & a, const Vector3D & b)
{
x = a.x + b.x;
y = a.y + b.y;
z = a.z + b.z;
}
//将当前向量设置为a和b向量的差
void Vector3D::subtract(const Vector3D &a, const Vector3D &b)
{
x = a.x - b.x;
y = a.y - b.y;
z = a.z - b.z;
}
//将当前向量设置为数字s与向量a的数乘
void Vector3D::multiply(double s, const Vector3D & a)
{
x = a.x * s;
y = a.y * s;
z = a.z * s;
}
//将当前向量设置为向量a与向量b各个分量的乘积
void Vector3D::arrayMultiply(const Vector3D &a, const Vector3D &b)
{
x = a.x * b.x;
y = a.y * b.y;
z = a.z * b.y;
}
(3) 自己封装的二维向量类Vector2D
.h
//#pragma once
/*------Vector2D---------------------------------------------
类作用：二维向量类，提供向量的基本运算
作者：HuangWang
日期：2017年11月22日
-------------------------------------------------------------*/
#ifndef VECTOR2D_H
#define VECTOR2D_H
#include <math.h>
class Vector2D
{
public:
Vector2D();
Vector2D(const double p);//将向量的两个分量都初始化为一个数
Vector2D(const double v[]);//以一个double型的数组初始化二维向量
Vector2D(const double x_,const double y_);//分别以X方向的数和Y方向的数创建一个的向量
Vector2D(const My2DPoint &p);//用My2DPoint构造二维向量
Vector2D(const Vector2D &a); //复制构造函数
~Vector2D(void);//析构函数
void SetVector2D(const double tempx,const double tempy);//设置二维向量两个方向上的坐标
double DotProduct(const Vector2D &other)const;//二维向量点积
double CrossProduct(const Vector2D &v)const;//二维向量叉积
double magnitude()const;//两个向量分量的平方和的根
double magnitudeSquared()const;//两个个向量分量的平方和
void normalize();//向量归一化
double Distance (const Vector2D &a,const Vector2D &b);//两个向量之间的距离
double Distance (const Vector2D &v)const;//两个向量之间的距离
void SetZero();//置为0向量
void Vector2DMax(const Vector2D &v);//将当前向量与v的xy分量比较得到较大分量
void Vector2DMin(const Vector2D &v);//将当前向量与v的xy分量比较得到较小分量
void setNegative(const Vector2D &v);//将形参向量v取负赋值给当前向量
void setNegative();//将当前向量取负
void add(const Vector2D & a, const Vector2D & b);//将当前向量设置为a和b向量的和
void subtract(const Vector2D &a, const Vector2D &b);//将当前向量设置为a和b向量的差
void multiply(double s, const Vector2D & a);//将当前向量设置为数字s与向量a的数乘
void arrayMultiply(const Vector2D &a, const Vector2D &b);//将当前向量设置为向量a与向量b各个分量的乘积
// BOOL型操作运算符
bool operator == (const Vector2D& v) const //判断两个向量是否相等
{
return x==v.x && y==v.y;
}
bool operator != (const Vector2D& v) const //判断两个向量是否不相等
{
return x!=v.x || y!=v.y;
}
// 常见的运算符
Vector2D& operator = (const Vector2D &v) //赋值运算
{
x=v.x;
y=v.y;
return *this;
}
Vector2D operator + (const Vector2D &v) const//两个向量相加
{
return Vector2D(x+v.x, y+v.y);
}
Vector2D& operator += (const Vector2D &v) //两个向量相加
{
x+=v.x; y+=v.y;
return *this;
}
Vector2D operator - () const //向量取负
{
return Vector2D(-x, -y);
}
Vector2D operator -(const Vector2D &v) const //两个向量相减
{
return Vector2D(x-v.x, y-v.y);
}
Vector2D& operator -= (const Vector2D &v) //两个向量相减
{
x-=v.x; y-=v.y;
return *this;
}
Vector2D operator * (const double s) const //向量数乘 后乘一个数
{
return Vector2D(x*s, y*s);
}
Vector2D& operator *= (const double s) //向量数乘 后乘一个数
{
x*=s; y*=s;
return *this;
}
Vector2D operator / (const double s) const //向量除以一个数
{
ASSERT(s);
return (*this)* (1/s);
}
Vector2D& operator /= (const double s) //向量除以一个数
{
ASSERT(s); return (*this)*=(1/s);
}
bool operator< (const Vector2D&v) const
{
if( x < v.x) return true;
if( x > v.x) return false;
if( y < v.y) return true;
if( y > v.y) return false;
return false;
}
public:
double x,y;//xy两个分量的大小
};
inline Vector2D operator *(const double s,const Vector2D &v)//内联函数 向量前乘一个数
{
return Vector2D(s*v.x,s*v.y);
}
#endif
.cpp
#include "StdAfx.h"
#include "Vector2D.h"
//默认构造函数
Vector2D::Vector2D()
{
}
//将向量的两个分量都初始化为一个数
Vector2D::Vector2D(const double p)
{
x=p;
y=p;
}
//以一个double型的数组初始化二维向量
Vector2D::Vector2D(const double v[]):x(v[0]),y(v[1])
{
}
//分别以两个double型的数值初始化向量的两个分量
Vector2D::Vector2D(const double x_,const double y_):x(x_),y(y_)
{
}
//复制构造函数
Vector2D::Vector2D(const Vector2D &a){
x=a.x;
y=a.y;
}
//以My2DPoint结构体作为参数构造向量
Vector2D::Vector2D(const My2DPoint &p)
{
x=p.X;
y=p.Y;
}
//默认析构函数
Vector2D::~Vector2D(void)
{
}
//设置向量的XYZ坐标
void Vector2D::SetVector2D(const double tempx,const double tempy)
{
x=tempx;
y=tempy;
}
//两向量的点积
double Vector2D::DotProduct(const Vector2D &other)const
{
return x*other.x + y*other.y;
}
double Vector2D::CrossProduct(const Vector2D &v)const
{
return x*v.y-y*v.x;
}
//三个向量分量平方和的根
double Vector2D::magnitude()const
{
return sqrt(x * x + y * y);
}
//三个向量分量的平方和
double Vector2D::magnitudeSquared()const
{
return x * x + y * y;
}
//向量标准化
void Vector2D::normalize()
{
double m = magnitude();
if (m)
{
const double il = double(1.0) / m;
x *= il;
y *= il;
}
}
//两个向量之间的距离
double Vector2D::Distance (const Vector2D &a,const Vector2D &b)
{
double dx = a.x - b.x;
double dy = a.y - b.y;
return sqrt(dx * dx + dy * dy );
}
double Vector2D::Distance(const Vector2D &v)const
{
Vector2D tempObject;
double dis;
dis=tempObject.Distance(*this,v);
return dis;
}
//将三维向量置为0向量
void Vector2D::SetZero()
{
x=0;
y=0;
}
//将当前向量与v的XY分量相比，得到较大的xy分量
void Vector2D::Vector2DMax(const Vector2D &v)
{
x=x>v.x?x:v.x;
y=y>v.y?y:v.y;
}
//将当前向量与v的XY分量相比，得到较小的xy分量
void Vector2D::Vector2DMin(const Vector2D &v)
{
x=x<v.x?x:v.x;
y=y<v.y?y:v.y;
}
//将形参向量v取负赋值给当前向量
void Vector2D::setNegative(const Vector2D &v)
{
x = -v.x;
y = -v.y;
}
//将当前向量取负
void Vector2D::setNegative()
{
x = -x;
y = -y;
}
//将当前向量设置为a和b向量的和
void Vector2D::add(const Vector2D & a, const Vector2D & b)
{
x = a.x + b.x;
y = a.y + b.y;
}
//将当前向量设置为a和b向量的差
void Vector2D::subtract(const Vector2D &a, const Vector2D &b)
{
x = a.x - b.x;
y = a.y - b.y;
}
//将当前向量设置为数字s与向量a的数乘
void Vector2D::multiply(double s, const Vector2D & a)
{
x = a.x * s;
y = a.y * s;
}
//将当前向量设置为向量a与向量b各个分量的乘积
void Vector2D::arrayMultiply(const Vector2D &a, const Vector2D &b)
{
x = a.x * b.x;
y = a.y * b.y;
}如果您觉得这篇博文有用，请访问我的个人站：http://www.stubbornhuang.com，更多博文干货等着您。
