一.浅拷贝和深拷贝
默认拷贝构造函数可以完成对象的数据成员值得简单复制,但是当对象的数据资源是指针时,默认拷贝构造函数只会进行地址和值的复制,不会复制空间,导致析构函数析构两次,同一个空间被释放了两次,编译时会报错。
浅拷贝:
#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的值不确定是未知的。尽量不要使用构造中调用构造。