用C++设计一个三维向量的类

答案:2 悬赏:30 手机版

解决时间 2021-02-28 14:26

提问者网友：孤山下
2021-02-28 07:41

用C++设计一个三维向量的类

最佳答案

五星知识达人网友：零点过十分
2021-02-28 07:50

////---------------------------------------------------------------------
//// Basic 3D vector class
////
//// Author: Michael K. Steliaros (Superscape)
//// Last modification date: 24-11-2000
////
//// Original author: Paul C. Gregory (Superscape)
//// Creation date: 04-01-1996
////---------------------------------------------------------------------

#ifndef VECTOR3D_H
#define VECTOR3D_H

#include
#include
#include

#ifndef PI
#define PI 3.14159265358979323846f
#endif

class Vector3D
{
public:
Vector3D() : m_X(0.0f), m_Y(0.0f), m_Z(0.0f) { }
Vector3D(const Vector3D& V) : m_X(V.m_X), m_Y(V.m_Y), m_Z(V.m_Z) { }
Vector3D(float X, float Y, float Z) : m_X(X), m_Y(Y), m_Z(Z) { }
~Vector3D() { }

float X() const { return(m_X); }
void X(const float X) { m_X = X; }
float Y() const { return(m_Y); }
void Y(const float Y) { m_Y = Y; }
float Z() const { return(m_Z); }
void Z(const float Z) { m_Z = Z; }

float& operator[](unsigned int i) // Array access to elements
{
switch(i){
case 0 : return(m_X);
case 1 : return(m_Y);
case 2 : return(m_Z);
default : return(m_Z);
}
}

Vector3D& operator=(const Vector3D& V) // Assignment
{ m_X = V.m_X; m_Y = V.m_Y; m_Z = V.m_Z; return(*this); }

Vector3D operator-() const // Negation
{ return(Vector3D(-m_X, -m_Y, -m_Z)); }

Vector3D operator+(const Vector3D& V) const // Sum
{ return(Vector3D(m_X + V.m_X, m_Y + V.m_Y, m_Z + V.m_Z)); }
Vector3D& operator+=(const Vector3D& V)
{ m_X += V.m_X; m_Y += V.m_Y; m_Z += V.m_Z; return(*this); }

Vector3D operator-(const Vector3D& V) const // Difference
{ return(Vector3D(m_X - V.m_X, m_Y - V.m_Y, m_Z - V.m_Z)); }
Vector3D& operator-=(const Vector3D& V)
{ m_X -= V.m_X; m_Y -= V.m_Y; m_Z -= V.m_Z; return(*this); }

float operator*(const Vector3D& V) const // Dot product
{ return(m_X * V.m_X + m_Y * V.m_Y + m_Z * V.m_Z); }

Vector3D operator*(const float Scale) const // Scale
{ return(Vector3D(m_X * Scale, m_Y * Scale, m_Z * Scale)); }
Vector3D operator/(const float Scale) const
{ return(operator*(1.0f / Scale)); }

Vector3D& operator*=(const float Scale) // Scale self
{ m_X *= Scale; m_Y *= Scale; m_Z *= Scale; return(*this); }
Vector3D& operator/=(const float Scale)
{ return(operator*=(1.0f / Scale)); }

Vector3D& operator*=(const Vector3D& Scale) // Component scale
{ m_X *= Scale.m_X; m_Y *= Scale.m_Y; m_Z *= Scale.m_Z; return(*this); }

float Magnitude2() const // Vector length^2
{ return((m_X * m_X) + (m_Y * m_Y) + (m_Z * m_Z)); }
float Magnitude() const // Vector length
{ return(static_cast(sqrt(Magnitude2()))); }

void fabs() // Make elements +ve
{
if(m_X < 0.0f) m_X = -m_X;
if(m_Y < 0.0f) m_Y = -m_Y;
if(m_Z < 0.0f) m_Z = -m_Z;
}

void Unit() // Make unit length
{
float len = Magnitude();

if(len == 0.0f){
m_X = len;
m_Y = len;
m_Z = len;
}
else{
len = 1.0f / len;
m_X *= len;
m_Y *= len;
m_Z *= len;
}
}

Vector3D operator%(const Vector3D& V) const // Cross product
{
return(Vector3D((m_Y * V.m_Z) - (m_Z * V.m_Y),
(m_Z * V.m_X) - (m_X * V.m_Z),
(m_X * V.m_Y) - (m_Y * V.m_X)));
}
Vector3D& operator%=(const Vector3D& V)
{
Vector3D T(*this);

m_X = (T.m_Y * V.m_Z) - (T.m_Z * V.m_Y);
m_Y = (T.m_Z * V.m_X) - (T.m_X * V.m_Z);
m_Z = (T.m_X * V.m_Y) - (T.m_Y * V.m_X);

return(*this);
}

float operator^(const Vector3D& V) const // Vector angle
{
Vector3D T = *this % V;
float x = *this * V;
float y = T.Magnitude();
int cx = 0, cy = 0;

if(x > 0.0f) cx += 1; else if(x < 0.0f) cx += 2;
if(y > 0.0f) cy += 1; else if(y < 0.0f) cy += 2;

switch((cx << 2) | cy){
case 1 : // x == 0 && y > 0
return(PI / 2.0f);
case 2 : // x == 0 && y < 0
return(-PI / 2.0f);
case 5 : // x > 0 && y > 0
return((y > x) ? PI / 2.0f - static_cast(atan(x / y)) :
static_cast(atan(y / x)));
case 6 : // x > 0 && y < 0
return(-((-y > x) ? PI / 2.0f - static_cast(atan(x / -y)) :
static_cast(atan(-y / x))));
case 8 : // x < 0 && y == 0
return(PI);
case 9 : // x < 0 && y > 0
return(PI - ((y > -x) ? PI / 2.0f - static_cast(atan(-x / y)) :
static_cast(atan(y / -x))));
case 10 : // x < 0 && y < 0
return(((y < x) ? PI / 2.0f - static_cast(atan(x / y)) :
static_cast(atan(y / x)) - PI));
default :
return(0.0f);
}
}

int operator==(const Vector3D& Cmp) const // Vector equality
{ return((m_X == Cmp.m_X) && (m_Y == Cmp.m_Y) && (m_Z == Cmp.m_Z)); }

int operator!=(const Vector3D& Cmp) const // Vector inequality
{ return((m_X != Cmp.m_X) || (m_Y != Cmp.m_Y) || (m_Z != Cmp.m_Z)); }

void Debug(FILE* fd)
const { fprintf(fd, "[%.3f, %.3f, %.3f]\n", m_X, m_Y, m_Z); }

protected:
float m_X; // Vector elements
float m_Y;
float m_Z;
};

#endif // VECTOR3D_H

全部回答

1楼网友：詩光轨車
2021-02-28 08:05

#include
#include
class Vector
{
private:// 不加也可以
double a,b,c;
public:
Vector(double _a,double _b,double _c):a(_a),b(_b),c(_c){}
Vector(const Vector &A):a(A.a),b(A.b),c(A.c){}
double Elem1(){return a;}
double Elem2(){return b;}
double Elem3(){return c;}
double ABS();
double operator *(const Vector &A);
friend ostream& operator <<(ostream& output,Vector &A);
};
double Vector::ABS()
{
return sqrt(pow(a,2)+pow(b,2)+pow(c,2));
}
double Vector::operator*(const Vector &A)
{
return this->a*A.a+this->b*A.b+this->c*A.c;
}
ostream &operator <<(ostream& output,Vector &A)
{
output<<"("< return output;
}
void main()
{
Vector A(3.0,4.0,5.0);
Vector B(A);
cout<<"A:"< <<"B:"< <<"A*B="<}

我要举报

如以上问答信息为低俗、色情、不良、暴力、侵权、涉及违法等信息，可以点下面链接进行举报！