C++学习笔记（十）：类

类的定义：

C++中使用关键字 class 来定义类, 其基本形式如下:

 class 类名
 {
     public:
         //公共的行为或属性

     protected:
         //受保护的行为或属性

     private:
         //私有的行为或属性
 };

示例：

 class Point
 {
     public:
         void setPoint(int x, int y);
         void printPoint();

     private:
         int xPos;
         int yPos;
 };

类的实现：

（1）在类定义时定义成员函数：

 #include <iostream>

 using namespace std;

 class Point
 {
     public:
 void setPoint(int x, int y) //实现setPoint函数
 {
     xPos = x;
     yPos = y;
 }

 void printPoint()       //实现printPoint函数
 {
     cout<< "x = " << xPos << endl;
     cout<< "y = " << yPos << endl;
 }

     private:
 int xPos;
 int yPos;
 };

 int main()
 {
     Point M;//用定义好的类创建一个对象 点M
     M.setPoint(, ); //设置 M点 的x,y值
     M.printPoint();     //输出 M点 的信息

     return ;
 }

（2）在类外定义成员函数：

格式：

 返回类型 类名::成员函数名(参数列表)
 {
     //函数体
 }

示例：

 #include <iostream>

 using namespace std;

 class Point
 {
     public:
 void setPoint(int x, int y); //在类内对成员函数进行声明
 void printPoint();

     private:
 int xPos;
 int yPos;
 };

 void Point::setPoint(int x, int y) //通过作用域操作符 '::' 实现setPoint函数
 {
     xPos = x;
     yPos = y;
 }

 void Point::printPoint()       //实现printPoint函数
 {
     cout<< "x = " << xPos << endl;
     cout<< "y = " << yPos << endl;
 }

 int main()
 {
     Point M;//用定义好的类创建一个对象 点M
     M.setPoint(, ); //设置 M点 的x,y值
     M.printPoint();     //输出 M点 的信息

     return ;
 }

构造函数：

构造函数是以类名作为函数名，无返回类型的函数，该类对象被创建时，编译系统对象分配内存空间，并自动调用该构造函数，由构造函数完成成员的初始化工作。

种类：

 class Complex
 {         

 private :
         double    m_real;
         double    m_imag;

 public:

         //    无参数构造函数
         // 如果创建一个类你没有写任何构造函数,则系统会自动生成默认的无参构造函数，函数为空，什么都不做
         // 只要你写了一个下面的某一种构造函数，系统就不会再自动生成这样一个默认的构造函数，如果希望有一个这样的无参构造函数，则需要自己显示地写出来
         Complex(void)
         {
              m_real = 0.0;
              m_imag = 0.0;
         } 

         //    一般构造函数（也称重载构造函数）
         // 一般构造函数可以有各种参数形式,一个类可以有多个一般构造函数，前提是参数的个数或者类型不同（基于c++的重载函数原理）
         // 例如：你还可以写一个 Complex( int num)的构造函数出来
         // 创建对象时根据传入的参数不同调用不同的构造函数
         Complex(double real, double imag)
         {
              m_real = real;
              m_imag = imag;
          }

         //    复制构造函数（也称为拷贝构造函数）
         //    复制构造函数参数为类对象本身的引用，用于根据一个已存在的对象复制出一个新的该类的对象，一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中
         //    若没有显示的写复制构造函数，则系统会默认创建一个复制构造函数，但当类中有指针成员时，由系统默认创建该复制构造函数会存在风险，具体原因请查询 有关 “浅拷贝” 、“深拷贝”的文章论述
         Complex(const Complex & c)
         {
                 // 将对象c中的数据成员值复制过来
                 m_real = c.m_real;
                 m_img    = c.m_img;
         }            

         // 类型转换构造函数，根据一个指定的类型的对象创建一个本类的对象
         // 例如：下面将根据一个double类型的对象创建了一个Complex对象
         Complex::Complex(double r)
         {
                 m_real = r;
                 m_imag = 0.0;
         }

         // 等号运算符重载
         // 注意，这个类似复制构造函数，将=右边的本类对象的值复制给等号左边的对象，它不属于构造函数，等号左右两边的对象必须已经被创建
         // 若没有显示的写=运算符重载，则系统也会创建一个默认的=运算符重载，只做一些基本的拷贝工作
         Complex &operator=( const Complex &rhs )
         {
                 // 首先检测等号右边的是否就是左边的对象本，若是本对象本身,则直接返回
                 if ( this == &rhs )
                 {
                         return *this;
                 }

                 // 复制等号右边的成员到左边的对象中
                 this->m_real = rhs.m_real;
                 this->m_imag = rhs.m_imag;

                // 把等号左边的对象再次传出
                // 目的是为了支持连等 eg:    a=b=c 系统首先运行 b=c
                // 然后运行 a= ( b=c的返回值,这里应该是复制c值后的b对象)
                 return *this;
         }

 };

 //下面使用上面定义的类对象来说明各个构造函数的用法：

 void main()
 {
         // 调用了无参构造函数，数据成员初值被赋为0.0
         Complex c1，c2;

         // 调用一般构造函数，数据成员初值被赋为指定值
         Complex c3(1.0,2.5);
         // 也可以使用下面的形式
         Complex c3 = Complex(1.0,2.5);

         //    把c3的数据成员的值赋值给c1
         //    由于c1已经事先被创建，故此处不会调用任何构造函数
         //    只会调用 = 号运算符重载函数
         c1 = c3;

         //    调用类型转换构造函数
         //    系统首先调用类型转换构造函数，将5.2创建为一个本类的临时对象，然后调用等号运算符重载，将该临时对象赋值给c1
         c2 = 5.2;

        // 调用拷贝构造函数( 有下面两种调用方式)
         Complex c5(c2);
         Complex c4 = c2;  // 注意和 = 运算符重载区分,这里等号左边的对象不是事先已经创建，故需要调用拷贝构造函数，参数为c2

 }

浅拷贝与深拷贝：

上面提到，如果没有自定义复制构造函数，则系统会创建默认的复制构造函数，但系统创建的默认复制构造函数只会执行“浅拷贝”，即将被拷贝对象的数据成员的值一一赋值给新创建的对象，若该类的数据成员中有指针成员，则会使得新的对象的指针所指向的地址与被拷贝对象的指针所指向的地址相同，delete该指针时则会导致两次重复delete而出错。下面是示例：

 #include <iostream.h>
 #include <string.h>
 class Person
 {
 public :

         // 构造函数
         Person(char * pN)
         {
               cout << "一般构造函数被调用 !\n";
               m_pName = new char[strlen(pN) + ];
               //在堆中开辟一个内存块存放pN所指的字符串
               if(m_pName != NULL)
               {
                  //如果m_pName不是空指针，则把形参指针pN所指的字符串复制给它
                    strcpy(m_pName ,pN);
               }
         }        

         // 系统创建的默认复制构造函数，只做位模式拷贝
         Person(Person & p)
         {
                   //使两个字符串指针指向同一地址位置
                  m_pName = p.m_pName;
         }

         ~Person( )
         {
                 delete m_pName;
         }

 private :

         char * m_pName;
 };

 void main( )
 {
         Person man("lujun");
         Person woman(man); 

         // 结果导致   man 和    woman 的指针都指向了同一个地址

         // 函数结束析构时
         // 同一个地址被delete两次
 }

 // 下面自己设计复制构造函数，实现“深拷贝”，即不让指针指向同一地址，而是重新申请一块内存给新的对象的指针数据成员
 Person(Person & chs);
 {
          // 用运算符new为新对象的指针数据成员分配空间
          m_pName=new char[strlen(p.m_pName)+ ];

          if(m_pName)
          {
                  // 复制内容
                 strcpy(m_pName ,chs.m_pName);
          }

         // 则新创建的对象的m_pName与原对象chs的m_pName不再指向同一地址了
 }

析构函数：

析构函数也是一种特殊的成员函数，它的作用是在对象消失时执行一系列的清理任务，例如可以释放内存等。

1. 析构函数与类名相同，在函数名前要加~符号
2. 析构函数没有参数，也不能重载，一个类中只能定义一个析构函数
3. 不能指定返回类型
4. 析构函数自动调用，不需要去显示调用

示例：

 Class Point 
 {
   Public : Int x,y 
 Public  
 Point();//构造函数 
 ~Point();
  } 
 Point::Point()//构造函数是实现 
 {
   X=;  
 Y=; 
 } 
 Point::~point() 
 { 
 Cout<<”(“<<x<<”,”<<y<<”)”<<endl; 
 }

析构函数在下边3种情况时被调用：

1. 对象生命周期结束，被销毁时；
2. delete指向对象的指针时，或delete指向对象的基类类型指针，而其基类虚构函数是虚函数时；
3. 对象i是对象o的成员，o的析构函数被调用时，对象i的析构函数也被调用。

this指针：

一个对象的this指针并不是对象本身的一部分，不会影响sizeof(对象)的结果。this作用域是在类内部，当在类的非静态成员函数中访问类的非静态成员的时候，编译器会自动将对象本身的地址作为一个隐含参数传递给函数。也就是说，即使你没有写上this指针，编译器在编译的时候也是加上this的，它作为非静态成员函数的隐含形参，对各成员的访问均通过this进行。

使用情况：

1. 在类的非静态成员函数中返回类对象本身的时候，直接使用 return *this；
2. 另外一种情况是当参数与成员变量名相同时，如this->n = n （不能写成n = n）。

类的this指针有以下特点：

1. this只能在成员函数中使用。
2. this在成员函数的开始前构造，在成员函数的结束后清除。