构造函数、析构函数、拷贝构造函数
默认情况下,c++编译器至少给一个类添加3个函数
1.默认构造函数(无参,函数体为空)
2.默认析构函数(无参,函数体为空)
3.默认拷贝构造函数,对属性进行值拷贝
构造函数调用规则如下:
如果用户定义有参构造函数 c++不在提供默认无参构造 但是会提供默认拷贝构造
如果用户定义拷贝构造函数 c++不会再提供其他构造函数
自己写的高级构造函数会屏蔽编译器提供的低级构造函数
1.构造函数和析构函数
构造函数
没有返回值
函数名与类名相同
构造函数可以有实参,可以发生重载
创建对象的时候,构造函数会自动调用
创建对象的时候,构造函数会自动调用,而且只调用一次
析构函数
没有返回值 不写void
函数名和类名相同 在名称前加~
析构函数不可以有参数,不可以发生重载
对象的销毁前 会自动调用析构函数 而且只会调用一次
class Person
{
public:
//构造函数
Person()
{
cout << "Person构造函数的调用" << endl;
}
//析构函数
~Person()
{
cout << "Person的析构函数调用" << endl;
}
};
2.构造函数的分类及调用
构造函数的分类:
按参数构造 无参构造(默认构造) 和 有参构造
按类型分类 普通构造 拷贝构造
#include <iostream>
using namespace std;
class Person
{
public:
//构造函数
Person()
{
cout << "Person的无参构造函数调用" << endl;
}
Person(int a)
{
age = a;
cout << "Person的有参构造函数调用" << endl;
}
//拷贝构造函数
Person(const Person &p)
{
//将传入的人身上的所有属性,拷贝到当前对象身上
age = p.age;
cout << "Person的拷贝构造函数调用" << endl;
}
~Person()
{
cout << "Person的析构函数调用" << endl;
}
int age;
};
调用
2.1括号法,常用
执行Person p();时,编译器会认为是一个函数的声明,不会认为在创建对象
类比void func();
Person p1; //默认构造函数调用
Person p2(10); //有参构造函数
Person p3(p2); //拷贝构造函数
注意事项
调用默认构造函数的时候,不要加()
下面这行代码,编译器会认为是一个函数的声明,不会认为在创建对象
Person p();
void func();
cout << "p2的年龄为:" << p2.age << endl;
cout << "p3的年龄为:" << p3.age << endl;
2.2显示法
Person p1;
Person p2 = Person(10); //有参构造
Person p3 = Person(p2); //拷贝构造(Person p3(p2))
//Person(10); //匿名对象 特点:当前执行结束后,系统会立即回收掉匿名对象
//注意事项
// 不要利用拷贝构造函数 初始化匿名对象 编译器会认为Person(p3)===Person p3;
//Person(p3); 编译器认为重定义
2.3隐式转换法
Person p4 = 10; 相当于写了 Person p4 = Person(10);
Person p4 = 10; //相当于写了 Person p4 = Person(10);
Person p5 = p4; //拷贝构造
3.拷贝构造函数
1.使用一个已经创建完毕的对象来初始化一个新对象
//2.值传递的方式给函数参数传值
3.值方式返回局部对象
class Person
{
public:
Person()
{
cout << "Person默认构造函数调用" << endl;
}
Person(int age)
{
m_Age = age;
cout << "Person有参构造函数调用" << endl;
}
Person(const Person& p)
{
m_Age = p.m_Age;
cout << "Person拷贝构造函数调用" << endl;
}
~Person() {
cout << "析构函数调用" << endl;
}
public:
int m_Age;
};
3.1使用一个已经创建完毕的对象来初始化一个新对象
void test01()
{
Person p1(10);
Person p2(p1);
cout << "P2的年龄为: " << p2.m_Age << endl;
}
3.2值传递的方式给函数参数传值
doWork(p);
其实相当于隐式转换法:Person p1 = p;相当于:Person p1§;
void doWork(Person p)
{
}
void test02()
{
Person p;
doWork(p); //其实相当于隐式转换法:Person p1 = p;相当于:Person p1(p);
}
3.3值方式返回局部对象
Person p = doWork2();
相当于:Person p = Person(p1);
Person doWork2()
{
Person p1;
cout << (int*)&p1 << endl;
return Person(p1);
}
void test03()
{
Person p = doWork2(); //相当于:Person p = Person(p1);
cout << (int*)&p << endl;
}
4.深拷贝和浅拷贝
浅拷贝:简单的赋值拷贝操作
深拷贝:再堆区重新申请空间,然后进行拷贝操作
4.1浅拷贝
存在问题:堆区重复释放
#include <iostream>
using namespace std;
//深拷贝与浅拷贝
class Person
{
public:
Person()
{
cout << "Person的默认构造函数调用" << endl;
}
Person(int age,int height)
{
//在堆区创建整型数据
//new返回的是该数据类型的指针
m_Height = new int(height);
cout << "Person的有参构造函数调用" << endl;
m_Age = age;
}
~Person()
{
//析构代码,将堆区开辟的数据做释放操作
if (m_Height != NULL)
{
delete m_Height;
m_Height = NULL;
}
cout << "Person的析构函数调用" << endl;
}
int m_Age;
int* m_Height;
};
void test01()
{
Person p1(18,160);
cout << "p1的年龄为: " << p1.m_Age << "身高为:"<<*p1.m_Height<< endl;
//虽然堆区内的数据已经被delete了,但是p1里的指针还是不为空,所以判断还是会true
Person p2(p1); //栈,先进后出,p2先被释放
cout << "p2的年龄为: " << p2.m_Age << "身高为:"<<*p2.m_Height<< endl;
}
int main()
{
test01();
}
4.2深拷贝
p1和p2各指向一块堆区,堆区指向的数据是一样的,但是指针指向的内存是不一样的
//自己实现拷贝构造函数 解决浅拷贝带来的问题
Person(const Person& p)
{
cout << "Person拷贝构造函数调用" << endl;
m_Age = p.m_Age;
//m_Height = p.m_Height; 编译器默认实现的就是这行代码
//深拷贝操作
m_Height = new int(*p.m_Height); //m_Height是个地址变量,解引用(加*之后)才是地址中的整型数据,new要创建一块int数据空间
}