构造函数

函数传参的方式有几种呢？我们可以分为三种（1）值传递（2）指针传递（3）引用传递

构造函数可以分为三种：默认构造函数、重载构造函数、复制构造函数

先参照下面的代码：

 

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

}

 思考与测验：

 

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

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

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

  Complex test1(const Complex& c)
  {
          return c;
  }
  
  Complex test2(const Complex c)
  {
         return c;
   }
   
   Complex test3()
   {
          static Complex c(1.0,5.0);
          return c;
   }
  
  Complex& test4()
  {
         static Complex c(1.0,5.0);
         return c;
  }
  
  void main()
  {
        Complex a,b;
    
        // 下面函数执行过程中各会调用几次构造函数，调用的是什么构造函数？
    
       test1(a);
       test2(a);
     
       b = test3();
       b = test4();
     
       test2(1.2);
       // 下面这条语句会出错吗？
       test1(1.2);     //test1( Complex(1.2 )) 呢？
  }

 

 首先，我们详细解释一下什么是【深拷贝】与【浅拷贝】，观察下面的代码：

//C++浅拷贝与深拷贝
#include <iostream>
#include <string.h>

using namespace std;

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 women(man)是，man和women的指针是指向同一块内存地址的，然后我们继续执行，当函数执行完毕时，我们发现调用了两次析构函数来析构我们开辟的指针内存区域。这就会造成我们常说的野指针现象。

所以，当成员变量中含有指针时，我们需要定义自己的复制构造函数。定义如下：

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

 

 

-----------------------------------------------------

另外需要记住的几个地方是：

 

构造函数的作用是：  保证每个对象的数据成员具有合适的初始值。

（1）构造函数的名字与类的名字相同，他可以不带参数，也可以带任意个参数，但是，构造函数没有返回值。

（2）构造函数允许被重载，调用时，实参决定了该调用哪一个构造函数。只要创建了该类型的对象，编译器就会运行一个构造函数。

（3）之前我们介绍过，可以把是否为const函数来作为函数能否重载的依据，但是，构造函数没有const类型。之前，只有   const对象才可以调用const成员函数，现在，非const对象也可以调用const构造函数。

转载于:https://www.cnblogs.com/CBDoctor/archive/2012/02/04/2338050.html