c++构造函数

构造函数是干什么的

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

构造函数种类

class Complex
{
private:
	double m_real;
	double m_imag;
public:
	//无参数构造函数
	//如果创建一个类你没有写任何构造函数，则系统会自动生成默认的无参构造函数，函数为空，什么都不做。
	//只要你写了一个下面的某一种构造函数，系统就不会再自动生成这样一个默认的构造函数，如果希望有这样一个无参构造函数，则需要自己显示的写出来。
	Complex(void)
	 {
		 m_real = 0.0;
		 m_imag = 0.0;
     }
    //一般构造函数（也称重载构造函数）
    //一般构造函数可以有各种参数形式，一个类可以有多个一般构造函数，前提是参数的个数或者类型不同（这是基于c++重载函数原理）
    //复制构造函数（也称为拷贝构造函数）
    //复制构造函数为类对象本身的引用，用于已经存在的对象复制出一个新的该类对象，一般在函数中会将已存在对象的数据成员的值复制到一新创建的对象中、
    //若没有显示的写复制构造函数，则系统会默认创建一个复制构造函数，但当类中有指针成员时，由系统默认创建该复制构造函数就会存在风险，，具体的原因好深拷贝，浅拷贝有关系。
  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;

 //把等号左边的对象再次传出
 //目的是为了支持连等。例如：a=b=c  ,这里首先运行b=从、
 //然后运行a = （b=c的返回值，这里应该是复制c值后的b对象）
    return *this;
  }
};

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

void main()
{
	//调用了无参构造函数，数据成员初值被赋为0.0
	Complex c1,c2;
	//调用一般构造函数，数据成员初始值被赋为定值
	Comolex 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
}

复制构造函数

几个原则：复制构造函数是一种特殊的构造函数，具有单个形参（常用const修饰）是对该类类型的阴用，当定义一个新对象并用一个同类型的对象对它进行初始化时，将显示使用复制复制构造函数。当该类型的对象传递给函数或者从函数返回该类型的对象时，将隐式调用复制构造函数。
c++支持两种初始化形式：复制初始化（int a = 5）和直接初始化（int a（5））；对于其他了新鲜感没有什么区别，对于类类型直接初始化直接调用实参匹配的构造函数，复制初始化总是调用复制构造函数，也就是说：
A x（2）;//直接初始化，调用构造函数
A y = x; //复制初始化，调用复制构造函数。
必须定义复制构造函数的情况：
只包含类类型成员或内置类型（但不是指针类型）成员的类，无需显示的定义复制构造函数也可以复制；有的类有一个数据成员是指针，或者是有成员表示在构造函数中分配的其他资源，这两种情况都必须定义复制构造函数，

什么情况下使用复制构造函数：
类对象需要拷贝时，拷贝构造函数将会被调用，一下情况都会调用拷贝构造函数：
1.一个对象以值传递的方式传入函数体
2.一个对象以值传递的方式从函数返回
3.一个对象需要通过另外一个对象进行初始化。

深拷贝和浅拷贝
所谓的深拷贝，指的是在对象复制时，只对对象中的数据成员进行简单的赋值，默认拷贝构造函数执行的也是浅拷贝，在‘深拷贝’的情况下，对于对象中动态成员就不能仅仅简单的赋值了，而应该重新动态的分配空间。

如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝。

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

#include<iostream>
#include<string.h>
class Person
{
public:
	//构造函数
	Person(char *N)
	{
		cout<<"一般构造函数调用！\n"；
		m_pName = new char[strlen(pN)+1];
		//在堆中开辟一个内存块存放pN所指的字符串
		if(m_pNname !=NULL)
		{
			//如果m_pName不是空指针，则把形参指针pN所指的字符串复制给它
			strcpy(m_pName,pN);
		}
	}
	//系统创建的默认复制构造函数，只做为模式拷贝
	Persion（Persion &p ）
	{
		//使两个字符串指针指向同一地址位置
		m_pName = p.m_pName;
	}
	~Persionb()
	{
		delete m_pName;
	}
private:
	char *m_pNmae;
};

void main()
{
	Persion man("lujun");
	Persion woman(man);
	//结果导致man和woman的指针都指向了同一个地址
	//函数结束析构时，同一个地址被delete两次
	//下面是自己设计的复制构造函数，函数的实现是利用‘深拷贝’，即不让指针指向同一个地址，而是重新申请一块内存给新的对象的指针数据成员
	Persion(Persion &chs)
	{
		//用运算符new为新对象的指针数据成员分配空间
		if(m_pNname)
		{
			//复制内容
			strcpy(m_pName，chs.m_pName);
		}
		//则新创建的对象m_pName与原对象chs的m_pName不在指向同一个地址了。
	}
	
}

重载赋值操作符:
通过定义operate=的函数，可以对赋值进行定义，向其他任何函数一样，操作符函数有一个返回值和形参表，形参表必须具有与该操作符操作数书目相同的形参（如果操作符是一个成员，则包含隐狮式this形参）。赋值是二元运算，所以该操作符函数由两个形参：第一个形参（隐含this指针）对于左操作数，第二个形参对应右操作数。
一个应用了对赋值号重载的拷贝构造函数的例子如下：

#include<iostrean>
using namespace std;
class A
{
	public:
		int A(int);'//构造函数
		A(const A&);//拷贝构造函数
		~A();
		void print();
		int *print;
		A&operator = (const A&);
};
A::A(int p)
{
	point  = new int；
	*point=p；
}
A::A(const A&b)
{
	*this = b;
	cout<<"调用拷贝构造函数"<<endl；
}
A::~A()
{
	delete point;
}

void A::print()
{
	cout<<"Address:"<<point <<"value:"<<*point <<endl;
		
}
A&A::operetor=(const A &b)
{
	if(this != &b)
	{
		delete point ;
		point = new int ;
		*point = *b.point;
	}
}
int main()
{
	A x(2);
	A y = x;
	x.print();
	delete x.point;
	y.print();
	return 0;
	
}