对象的初始化和清理
构造函数和析构函数
对象的初始化和清理是非常重要的安全问题
- 一个对象或者变量没有初始化状态,对其使用后果是未知的
- 同样的使用完一个对象或变量,没有及时的处理,也会造成一定的安全问题
构造函数:创建对象时为对象的成员属性赋值,构造函数由编译器自动调用,无需手动调用
析构函数:对象销毁前自动调用,执行一些清理工作
当我们不提供构造和析构时,编译器会提供,而编译器提供的时空实现的
构造函数语法:类名(){}
- 无返回值也不写void
- 函数名称与类名相同
- 可以有参数,因此可以发生重载
- 程序再调用对象时候会自动调用,无须手动调用,而且仅会调用一次
析构函数语法:~类名(){}
- 无返回值也不写void
- 函数名称与类名相同,在前面加上~
- 不可以有参数,因此不可以发生重载
- 对象销毁前自动调用析构,无需手动调用,且仅调用一次
#include <iostream>
using namespace std;
class Person
{
public:
Person()
{
cout << "构造函数的调用" << endl;
}
~Person()
{
cout << "析构函数的调用" << endl;
}
};
void test01()
{
Person p;
} //为局部变量,函数调用后被立刻释放,因此析构和构造函数都会被调用
int main()
{
Person p2; //仅调用构造函数,析构函数在main函数执行完才会调用
test01();
return 0;
}
构造函数的分类
- 按照参数分类,可以分为有参和无参的构造函数,无参又称为默认构造函数
- 按照类型分类分为普通构造和拷贝构造
#include <iostream>
using namespace std;
class Person
{
public:
int age;
Person() //无参构造函数
{
cout << "默认构造函数的调用" << endl;
}
Person(int a)
{
age = a;
cout << "有参构造函数的调用" << endl;
}
Person(const Person& p)
{
age = p.age;
cout << "拷贝构造函数的调用" << endl;
}
~Person() //析构函数
{
cout << "析构函数的调用" << endl;
}
};
void test01()
{
Person p1;//调用无参的构造函数
Person p2(10);//调用有参的构造函数
Person p3(p2);//调用拷贝构造函数
}
void test02()
{
//括号法
Person p1(10);
//ps:调用无参构造函数不能加括号,如果加了编译器会认为i这是一个函数声明
//Person p2()not right
//显示法
Person p2= Person(10);
Person p3 = Person(p2);
//Person(10)单独写为匿名对象,当前行结束后,马上析构
//不能利用拷贝函数初始化匿名对象,编译器会认为是对象声明
//Person p5(p4);
//隐式转换法
Person p4 = 10;//Person p4 = Person(10);
Person p5 =p4;//Person p5 = Person(p4);
}
int main()
{
Person p2; //仅调用构造函数,析构函数在main函数执行完才会调用
test01();
return 0;
}
拷贝构造函数调用时机
C++中拷贝构造函数调用的时机通常有三种情况
- 使用一个已经创建完毕的对象来初始化一个新的对象
- 值传递的方式给函数参数传值
- 以值的方式返回局部对象
#include <iostream>
using namespace std;
class Person{
public:
Person(){
cout <<"无参构造函数调用"<<end;
mAge=0;
}
Person(int age){
cout <<"有参构造函数函数调用"<<end;
mAge=age;
}
Person(const Person &p){
mAge=p.age;
}
int age;
~Person(){
cout <<"Person析构构造函数调用"<<end;
}
};
//1.使用一个已经创建完毕的对象来初始化一个新的对象
void test01()
{
Person p1(20);
Person p2(p1);
}
//2.值传递的方式给函数参数传值
void doWork(Person p)
{
//此处的p是拷贝过的,在此处更改p的值对于test02()中的数据无影响。
}
void test02()
{
Person p;
dowork(p);
}
//3.值方式返回局部对象
Person doWork2()
{
Person p1;
cout<<(int*)&p1<<endl;
return p1;//用值的方式返回,返回的是拷贝出来的新的对象,而不是函数中的p1;
}
void test03()
{
Person p=doWork2();
cout<<(int*)&p<<endl;//打印地址可以发现该地址与上面doWork2()中p1的地址不同。
}
int main()
{
test01(); //1.使用一个已经创建完毕的对象来初始化一个新的对象
test02();//2.值传递的方式给函数参数传值
test03();//3.值方式返回局部对象
return 0;
}
构造函数的调用规则
默认情况下,C++编译器至少给一个类添加3个函数
- 默认构造函数无参(函数体为空)
- 默认析构函数无参 (函数体为空)
- 默认拷贝构造函数,对属性进行值拷贝
构造函数调用规则如下:
- 如果用户定义有参构造函数,c++不再提供默认无参构造,但是会提供默认拷贝构造
- 如果用户定义拷贝构造函数,C++不会再提供其它构造函数
#include <iostream>
using namespace std;
class Person{
public:
Person(){
cout <<"无参构造函数调用"<<end;
m_Age=0;
}
Person(int age){
cout <<"有参构造函数函数调用"<<end;
m_Age=age;
}
Person(const Person &p){
cout <<"拷贝构造函数函数调用"<<end;
m_Age=p.age;
}
int m_Age;
~Person(){
cout <<"Person析构构造函数调用"<<end;
}
};
void test01()
{
Person p;
p.m_Age=18;
Person p2(p); //当类中拷贝构造函数备注释掉后,p2的年龄依然为18,但不会输出"拷贝构造函数函数调用"的显示。
count <<"p2的年龄为:"<<p2.m_Age<<endl;
}
void test02()
{
Person p;//此时如果注释掉类中的默认构造函数,编译器会报错,因为当用户定义了有参构造函数,那么C++不再提供无参构造函数。
//如果讲有参和无参构造函数注释掉,则此行依然会出错,因为如果用户定义拷贝构造函数,C++不会再提供其它构造函数
Person p1;
Person p2(p1);//注释掉拷贝构造函数和默认构造函数,此段代码不会出错
}
int main()
{
test01();
test02();
return 0;
}
深拷贝与浅拷贝
浅拷贝:简单的赋值拷贝
深拷贝:在堆区重新申请空间,进行拷贝操作
#include <iostream>
using namespace std;
class Person{
public:
Person(){
cout <<"无参构造函数调用"<<end;
m_Age=0;
}
Person(int age,int height){
cout <<"有参构造函数函数调用"<<end;
m_Age=age;
m_Height=new int(height);
}
Person(const Person &p){
cout <<"拷贝构造函数函数调用"<<end;
m_Age=p.age;
//m_Height=p.m_Height;//此为编译器默认实现的代码
//深拷贝的操作
m_Height=new int(*p.m_Height);
}
int m_Age;
int *m_Height;
~Person(){
//析构代码,将堆区开辟数据做释放的操作
if(m_Height!=NULL)
{
delet m_Height;
m_Height=NULL;
}//此时会出错,因为此时p1和p2的身高所指向的空间是同一个空间,而当p2的析构函数释放该处的内存后(先进后出p2先被释放),p1的析构函数会再次释放此内存,因此会出错
//解决此问题应当自己写拷贝函数,使得两个函数指向的空间不同
cout <<"Person析构构造函数调用"<<end;
}
};
void test01()
{
Person p1(18,160);
cout<<"p1的年龄为:"<<p1.m_Age<<"身高为:"<<*p1.m_Height<<endl;
Person p2(p1);
cout<<"p2的年龄为:"<<p2.m_Age<<"身高为:"<<*p2.m_Height<<endl;
}
int main()
{
test01();
return 0;
}