c++入门之 再话类

对于类，其结构并不难，但要理解其设计思想也并不容易，在此，我们可以通过下面的代码进一步理解和使用类：

 # ifndef VECTOR_H_
 # define VECTOR_H_
 # include "iostream"

 namespace VECTOR //注意，这里对这个类定义了名称空间，实际上，在写自己的类时，也应该定义自己的名称空间
 {
     class Vector
     {
     public:
         enum Mode{RECT,POL};//因为这个量需要用户自己去设定
     private:           //注意：私有成员（无论是函数还是变量）只能被类内部成员访问
         double x;
         double y;
         double mag;
         double ang;
         Mode mode;

         void set_mag();
         void set_ang();
         void set_x();
         void set_y();   //体会将这些函数放在这里的用意!!
     public:             //共有成员可以被所有访问！！理解这个意思
         Vector();//构造函数
         Vector(double n1,double n2,Mode form = RECT);//注意，这里有默认参数
         void reset(double n1, double n2, Mode form = RECT);
         ~Vector();//析构函数
         double xval() const{ return x; }
         double yval() const{ return y; }
         double magval() const{ return mag; }
         double angval() const{ return ang; }
         void polar_mode();
         void rect_mode();

         Vector operator+(const Vector &b) const;
         Vector operator-(const Vector &b) const;
         Vector operator-() const;
         Vector operator*(double n) const;

         friend Vector operator*(double n, const Vector &a);//注意这里采用了友元函数的做法，应该显示包含所有参数
         friend std::ostream & operator<<(std::ostream &os, const Vector & v);//昨天没有思考返回引用是否存在问题？？？因为局部变量被销毁的问题
     };

 }
 # endif

该类定义中：除了备注的一些以外，总结这么几点：

1 定义了一个类的时候，限定了该类的名称空间通常是一件好事，以免自己的变量和别人的发生了冲突

2   公有还是私有并无界限之分，完全取决于程序的功能。

3  我们通常会发现：当定义一个类成员函数时，通常需要：构造函数，析构函数，甚至友元函数

4  私有成员（无论是变量还是函数）只能被类内部的成员进行访问，而共有成员 可以被其他类甚至其他任何东西访问。究其本质：公有部分 是提供的接口

下面给出该定义：

 # include"cmath"  //从下文的调用方法来看，这里应该是函数库，而不是类库
 # include "vector.h"
 using std::sqrt;   //注意 std 包含了很多
 using std::sin;
 using std::cos;
 using std::atan;
 using std::atan2;
 using std::cout;

 namespace VECTOR  //名称空间的意义是很有必要的
 {
     const double Rad_to_deg = 45.0 / atan(1.0);
     void Vector::set_ang()
     {
         mag = sqrt(x*x + y*y); //求极长
     }

     void Vector::set_ang()
     {
         if (x == 0.0  && y == 0.0)
             ang = 0.0;
         else
             ang = atan2(y, x);//求极角
     }

     void Vector::set_x() //这些是私有函数
     {
         x = mag*cos(ang);//私有函数可以访问私有变量表明私有成员也可以相互访问
     }

     void Vector::set_y()
     {
         y = mag*sin(ang);
     }

     Vector::Vector()
     {
         x = y = mag = ang = 0.0;
         mode = RECT;
     }

     Vector::Vector(double n1, double n2, Mode form)
     {
         mode  = form;
         if (form == RECT)
         {
             x = n1;
             y = n2;
             set_mag();//访问了私有成员
             set_ang();//体会这里的设计思想
         }
         else if (form == POL)
         {
             mag = n1;
             ang = n2;
             set_x();
             set_y();
         }
         else
         {
             cout << "Incorrect 3rd argument to Vector()--";
             cout << "vector set to 0\n";
             x = y = mag = ang = 0.0;
             mode =RECT;
         }
     }
     void Vector::reset(double n1, double n2, Mode form)
     {
         mode = form;
         if (form = RECT)
         {
             x = n1;
             y = n2;
             set_mag();
             set_ang();
         }
         else if (form = POL)
         {
             mag = n1;
             ang= n2;
             set_x();
             set_y();
         }
         else
         {
             cout << "Incorrect 3rd argument to Vector()--";
             cout << "vector set to 0\n";
             x = y = mag = ang = 0.0;
             mode = RECT;
         }
     }
     Vector::~Vector()//
     {

     }

     void Vector::polar_mode()
     {
         mode = POL;
     }

     void Vector::rect_mode()
     {
         mode = RECT;
     }

     Vector Vector::operator+(const Vector &b) const
     {
         return Vector(x + b.x, y + b.y);
     }

     Vector Vector::operator-(const Vector &b) const
     {
         return Vector(x - b.x, y - b.y);
     }

     Vector Vector::operator-() const
     {
         return Vector(-x, -y);
     }
 

        Vector Vector::operator*(double n) const

        {
          return(n*x,x*y)
        }

     Vector operator*(double n, const Vector & a)
     {
         return a*n; //注意，虽然这里进行了返回，但并没有结束，而是继续调用了成员函数，
     }

     std::ostream & operator<<(std::ostream & os, const Vector & v)
     {
         if (v.mode == Vector::RECT)
             os << "(x,y) = (" << v.x << "," << v.y << ")";
         else if (v.mode == Vector::POL)
         {
             os << "(m,a) = (" << v.mag << "," << v.ang + Rad_to_deg << ")";
         }
         else
             os << "Vector object mode is invalid";
     }
 }

1.  我们注意107行和112行的代码：本质上，进行了加法和减法之后，得到的是一个新的类对象，但由于这个类对象不止一种表示形式(直角坐标和极坐标),这里巧妙的利用了 返回构造函数的执行。这告诉我们：构造函数并不仅仅用于初始化，构造函数的本意：构造新的对象，一定要认识这一本质特征和思想。

2  我们注意124行的代码：return a*n; 本质上，对象乘以一个数无法实现，但这里，其实，并没有返回，而是回去重新调用了上面的*。

3 注意：129行和131行：if (v.mode == Vector::RECT)。为何要加Vector::RECT而不是RECT，这是因为：

友元函数虽然在public中，但友元函数并不在类作用域中！！！ 这对于所有友元函数都成立！！！