三维向量类Vector类封装，包含三维向量一些基本运算

（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;
}