c++构造函数自己梳理

c++的学习曲线很陡，一直都没有完全把基础学会，一直都是学了忘学了忘，最终决定写博客记录下来，以后好复习。

先放一位博主的链接：http://blog.csdn.net/tiantang46800/article/details/6938762，本文完全借用他的例子，又根据自己的理解做了一下验证。

                                       c++类的构造函数详解                        

一、 构造函数是干什么的

class Counter
{

public:
         // 类Counter的构造函数
         // 特点：以类名作为函数名，无返回类型
         Counter()
         {
                m_value = 0;
         }
         
private:
      
         // 数据成员
         int m_value;
}

       该类对象被创建时，编译系统对象分配内存空间，并自动调用该构造函数->由构造函数完成成员的初始化工作。

eg:    Counter c1;
        编译系统为对象c1的每个数据成员(m_value)分配内存空间，并调用构造函数Counter( )自动地初始化对象c1的m_value值设置为0

故：

        构造函数的作用：初始化对象的数据成员。

二、 构造函数的种类

1、分为默认构造函数  ，一个类只能有一个默认构造函数：注意有参的构造函数也可以是默认构造函数，见下面例子。

2、一般构造函数

3、复制构造函数

举例：
class Complex 
{         

private :
        double    m_real;
        double    m_imag;

public:

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

　　　　cout<<"11111"<<endl;
        } 
        
        //    一般构造函数（也称重载构造函数），是有参数的
        //  一般构造函数可以有各种参数形式,一个类可以有多个一般构造函数，前提是参数的个数或者类型不同（基于c++的重载函数原理）

　　  //  如果 Complex(double real = 0.0, double imag = 0.0 ) 和Complex(void) 同时存在，在定义  Complex test ；时会出现错误，因为这样存在二义性。

       // 不知道会调用哪一个构造函数，这样会导致错误。
        //  例如：你还可以写一个 Complex( int num)的构造函数出来
        //  创建对象时根据传入的参数不同调用不同的构造函数
        Complex(double real, double imag)
        {
             m_real = real;
             m_imag = imag;    

　　　　cout<<"222222222"<<endl;     
         }
　　　

 　　//    复制构造函数（也称为拷贝构造函数）

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

　　//所谓的浅拷贝就是在复制对象的时候，如果存在指针的成员，只会复制指针的值，不会重新分配空间，这样就会导致存在多个指针指向一块空间，导致析构的时候出现段错误。
        Complex(const Complex & c)
        {
                // 将对象c中的数据成员值复制过来
                m_real = c.m_real;
                m_img    = c.m_img;

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

　　　　　// cout<<"44444444"<<endl;
        }

        // 等号运算符重载
        // 注意，这个类似复制构造函数，将=右边的本类对象的值复制给等号左边的对象，它不属于构造函数，等号左右两边的对象必须已经被创建
        // 若没有显示的写=运算符重载，则系统也会创建一个默认的=运算符重载，只做一些基本的拷贝工作
        Complex &operator=( const Complex &rhs )
        {
                // 首先检测等号右边的是否就是左边的对象本，若是本对象本身,则直接返回
                if ( this == &rhs ) 
                {
                        return *this;
                }
                
                // 复制等号右边的成员到左边的对象中
                this->m_real = rhs.m_real;
                this->m_imag = rhs.m_imag;
                // cout<<"555555"<<endl;
               // 把等号左边的对象再次传出
               // 目的是为了支持连等 eg:    a=b=c 系统首先运行 b=c
               // 然后运行 a= ( b=c的返回值,这里应该是复制c值后的b对象)    
                return *this;
        }

　　~Complex ()

　　　　{
　　　　cout<<"delete func "<<m_real<<" "<<m_imag<<endl;
　　　　}

};

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

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

    
}

三、思考与测验

1. 仔细观察复制构造函数

        Complex(const Complex & c)
        {
                // 将对象c中的数据成员值复制过来
                m_real = c.m_real;
                m_img = c.m_img;
        }    
        
为什么函数中可以直接访问对象c的私有成员？

答：因为所谓的访问控制是对于类来说的，而不是对于实例来说。一个类当然可以访问所有自己的类的实例的私有成员了

2. 挑战题，了解引用与传值的区别

  Complex test1(const Complex& c)
  {

　　　 cout<<"func_test1"<<endl;
          return c;
  }
  //test1(a);

　func_test1

   33333333
   delete func 0 0

　//c 返回的时候创建了一个匿名对象，调用复制构造函数，因为没有对象做左值，然后再调用析构函数。

  Complex test2(const Complex c)
  {

　　  cout<<"func_test2"<<endl;
         return c;
   }

   //test2(a);

33333333
func_test2
33333333
delete func 0 0
delete func 0 0

函数是值传递，首先建立一个临时对象，然后返回C, 构造一个匿名对象，然后因为没有变量做左值，这样匿名对象会先析构，然后再析构最开始的临时对象。

   
   Complex test3()
   {

　　　　cout<<"func_test3"<<endl;
          static Complex c(1.0,5.0);
          return c;
   }

//b = test3();

func_test3
222222222
33333333
555555
delete func 1 5

1、调用一般构造函数， 2、返回的时候， 创建了一个匿名对象，调用复制构造函数  3、因为b 是之前存在的对象，所以=号是重载，4、 然后析构这个匿名对象

  Complex& test4()
  {

　　  cout<<"func_test4"<<endl;
         static Complex c(1.0,5.0);
         return c;
  }

 //b =  test4();

 func_test4
222222222
555555

1、调用了一般构造函数， 2、因为返回的是引用，所以不需创建一个临时对象，返回引用的前提是返回之后，其内存不会释放，因为c 是static 的，所以是不会释放的。3、因为b是之前定义的，所以 调用了=号的重载函数。

 //test2(1.2);

44444444
func_test2
33333333
delete func 1.2 0
delete func 1.2 0

//首先调用了一个类型转换构造函数，然后返回的时候调用复制构造函数， 然后再进行析构

 //test1(1.2);  

44444444
func_test1
33333333
delete func 1.2 0
delete func 1.2 0

//首先调用了一个类型转换构造函数，然后返回的时候调用复制构造函数， 然后再进行析构

  void main()
  {
        Complex a,b;
    
        // 下面函数执行过程中各会调用几次构造函数，调用的是什么构造函数？
    
       test1(a);
       test2(a);
     
       b = test3();
       b = test4();
     
       test2(1.2);
       // 下面这条语句会出错吗？
       test1(1.2);     //test1( Complex(1.2 )) 呢 这个不会出错，和上面函数的调用是一致的，现在还未完全明白，
  }

四、附录(浅拷贝与深拷贝)

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

【浅拷贝与深拷贝】

#include <iostream.h>
#include <string.h>
class Person 
{
public :
        
        // 构造函数
        Person(char * pN)
        {
              cout << "一般构造函数被调用 !\n";
              m_pName = new char[strlen(pN) + 1];
              //在堆中开辟一个内存块存放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)+ 1];

         if(m_pName)         
         {
                 // 复制内容
                strcpy(m_pName ,chs.m_pName);
         }
      
        // 则新创建的对象的m_pName与原对象chs的m_pName不再指向同一地址了
}