C++ 基础知识六

一.浅拷贝和深拷贝

默认拷贝构造函数可以完成对象的数据成员值得简单复制，但是当对象的数据资源是指针时，默认拷贝构造函数只会进行地址和值的复制，不会复制空间，导致析构函数析构两次，同一个空间被释放了两次，编译时会报错。

浅拷贝：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

class Text6_1
{
public:
	Text6_1(int a,int b,char *name)
	{
		m_a = a;
		m_b = b;

		m_name = (char *)malloc(sizeof(char) * 100);
		strcpy(m_name,name);
	}
	
	~Text6_1 ()
	{
		if(m_name != NULL)
		{
			free(m_name);
		}
		printf ("***********析构被调用**********\n");
	}

	void print()
	{
		printf("m_a = %d,m_b = %d,m_name = %s\n",m_a ,m_b ,m_name);
	}
private:
	int m_a;
	int m_b;
	//char m_name[20];
	char *m_name;
};

int main()
{
	Text6_1 t1(10,20,"hello");
	t1.print();

	Text6_1 t2 = t1; //浅拷贝：拷贝指针时，只拷贝了地址，并未拷贝空间，释放时释放了两次但是只有一块空间
	t2.print();

	return 0;

}

解决浅拷贝： 深拷贝(自己手写拷贝构造函数)

class Text6_2
{
public:
	Text6_2(int a,int b,char *name)
	{
		m_a = a;
		m_b = b;

		m_name = (char *)malloc(sizeof(char) * 100);
		strcpy(m_name,name);
	}
	//自己写拷贝构造，防止浅拷贝
	//手动编写拷贝构造函数，进行深拷贝
	Text6_2(const Text6_2 &obj)
	{
		m_a = obj.m_a;
		m_b = obj.m_b;
		m_name = (char *)malloc(sizeof(char) * 100);
		strcpy(m_name,obj.m_name);

		printf("------拷贝构造被调用------\n");
	}
	
	~Text6_2 ()
	{
		if(m_name != NULL)
		{
			free(m_name);
		}
		printf ("***********析构被调用**********\n");
	}

	void print()
	{
		printf("m_a = %d,m_b = %d,m_name = %s\n",m_a ,m_b ,m_name);
	}
private:
	int m_a;
	int m_b;
	char *m_name;
};

int main()
{
	Text6_2 t1(10,20,"hello");
	t1.print();

	Text6_2 t2 = t1;
	return 0;
}

拷贝构造的私有化：

只需要函数申明，不写函数体。

class Text6_3
{
private:  //只需要申明，不需要写函数体
	Text6_3(const Text6_3 &obj);

public:
	Text6_3(int a)
	{
		m_a = a;
	}
	void print()
	{
		printf("m_a = %d\n",m_a);
	}
private:
	int m_a;

};

int main6_3()
{
	Text6_3 t1(10);
	t1.print();
	//拷贝构造私有，无法调用
	//Text6_3 t2 = t1;  //无法访问private
	//t2.print();

	return 0;
}

二. 对象初始化列表

1.使用原因

一个类中的成员，它本身也是一个类或者是一个结构，这个成员只有一个带参数的构造函数，没有默认的构造函数，这时候对这个类成员进行初始化，就要调用这个类成员的带参数构造函数。

类成员中若有const修饰，必须在对象初始化的时候，给const int m 。 赋值当类成员中含有一个const对象时，或者是一个引用时，他们也必须要通过成员初始化列表进行初始化，因为这两种对象要在声明后马上初始化，而在构造函数中，做的是对他们的赋值，这样是不被允许的。 

#include <stdio.h>


class Text7_1
{
public:
	Text7_1(int a)
	{
		m_a = a;
		printf("7_1构造函数被调用 m_a = %d\n",m_a);
	}
	// 析构的顺序和构造的顺序相反，先构造的后析构
	~Text7_1()
	{
		printf("7_1析构函数被调用 m_a = %d\n",m_a);
	}
private:
	int m_a;
};

class Text7_2
{
	// 对象初始化列表,在构造函数后面加：,后面加上要初始化的对象
	// 对象初始化列表要比当前类的构造函数先执行
	// 对象的初始化先后顺序和 在对象初始化列表 的顺序无关，和在类中的声明先后顺序有关 
public:
	Text7_2():m_a(10),m_b(20),m_c(30)
	{
		printf("7_2构造函数  \n");
	}

	~Text7_2()
	{
		printf("7_2析构函数\n");
	}
private:
	Text7_1 m_a;
	Text7_1 m_c;
	Text7_1 m_b;

};

int main()
{
	//没有默认的无参构造函数
	Text7_1 t1(40);

	Text7_2 t2;

	return 0;
}

三.构造中调用构造函数

#include <stdio.h>

class Text9_1
{
public:
	Text9_1(int a,int b,int c)  //构造函数
	{
		m_a = a;
		m_b = b;
		m_c = c;
		printf("1111111111111构造函数被调用 m_a = %d,m_b = %d,m_c = %d\n" ,m_a ,m_b ,m_c);
		//printf("m_a = %d,m_b = %d,m_c = %d\n",m_a ,m_b ,m_c);
	}

	Text9_1(int a,int b)
	{
		m_a = a;
		m_b = b;
		printf("222222222222构造函数被调用 m_a = %d,m_b = %d\n",m_a ,m_b);
		//printf("m_a = %d,m_b = %d\n",m_a ,m_b);
		Text9_1(a, b, 90);
	}

	~Text9_1()  //析构函数
	{
		printf("析构函数被调用 m_a = %d,m_b = %d.m_c = %d\n",m_a ,m_b,m_c );
		//printf("m_a = %d,m_b = %d\n",m_a ,m_b );
	}

	void print()
	{
		printf("m_a = %d,m_b = %d\n",m_a ,m_b);
	}

private:
	int m_a;
	int m_b;
	int m_c;

};
int main()
{
	//Text9_1 t1(1,2);	//构造函数被调用
	//t1.print();

	Text9_1 t2(3,4);

	return 0;
}






我们知道，当定义一个对象时，会按顺序做2件事情：

1）分配好内存（非静态数据成员是未初始化的）

2）调用构造函数（构造函数的本意就是初始化非静态数据成员）
Text9_1 t2，这里已经为t2分配了内存，在调用t2的构造函数时，还未结束就执行另一个构造函数，这时会产生一个匿名的临时对象，在第一个构造函数中m_c初始化为90，但是在t2中m_c却没有得到初始化，所以析构时m_c的值不确定是未知的。尽量不要使用构造中调用构造。