c++三维向量如何定义、赋值和输出？

是从文件中读取字符后，赋值给三维向量

2025-03-14 00:35:32

推荐回答（4个）

回答1：

1、三维向量：

若向量a=(a1,b1,c1),向量b=(a2,b2,c2),
向量a+向量b=（a1+a2,b1+b2,c1+c2)
向量a·向量b=a1a2+b1b2+c1c2
向量a×向量b=(b1c2-b2c1,c1a2-a1c2,a1b2-a2b1)

2、例程：

////---------------------------------------------------------------------
////    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

回答2：

3维变量，，直接for()for()for()嵌套。。试试

回答3：

//数组定义
int shuzu[a][b][c];(其中a,b,c是已知的)
//赋值
for（i=0;i for(j=0;j for(k=0;k {
cin>>shuzu[i][j][k];

}
//输出
for（i=0;i for(j=0;j for(k=0;k {
cout<
}

回答4：

输入运算符重载

最新问答

er50焊丝化学成分是检熔敷金属还是原材料

昆明自驾游到珠海长隆要多少多长时间

艺术学院繁体字怎么写

电脑登陆不上校园网怎么回事？手机可以登陆，电脑就是不行。

基金中的购买、赎回、定投、转换和定投管理和交易撤销是什么意思？？？

现代日本对世界历史有什么贡献

王者荣耀百穿铭文都适合什么英雄

在WPS Office 中如果在某一段落内双击鼠标，将选中哪些内容？

为什么上市公司章程中，显示的前几大股东持股比例合计不足100%？

孔雀在中国古代象征什么？