c++构造析构函数专题

构造函数和析构函数

#include<iostream>
#include<string>
using namespace std;
//对象的初始化和清理
//1 构造函数  进行初始化操作
class Person {
public:
	//构造函数
	Person() {
		cout << "Person 构造函数的调用;" << endl;
	}
	//析构函数
	~Person() {
		cout << "Person 析构函数的调用;" << endl;
	}
};
void test01() {
	Person p;
}
int main() {
	test01();
	return 0;
}

构造函数的分类和调用

#include<iostream>
#include<string>
using namespace std;
class Person {
public:
	//构造函数
public:
	int age;
	Person() {
		cout << "Person 默认构造函数的调用;" << endl;
	}
	Person(int n) {
		age = n;
		cout << "Person 有参构造函数的调用;" << endl;
	}

	//析构函数
	~Person() {
		cout << "Person 析构函数的调用;" << endl;
	}
	//拷贝构造函数
	Person(const Person &p) { 
		cout << "Person 拷贝构造函数调用;" << endl;
		age = p.age;
	}
};
int main() {

	//括号法
	Person p1;//默认构造函数的调用
	Person p2(10);//有参构造函数的调用
	Person p3(p2);
	cout << "p2的年龄为：" << p2.age << endl;
	cout << "p3的年龄为：" << p3.age << endl;

	//注意事项
	//调用默认构造函数时，不要加（）
	//不会创建对象 下面这行代码编译器会认为是一个函数的声明 不会认为在创建对象
	Person p();

	//显示法
	Person p1;             
	Person p2 = Person(10); //有参构造
	Person p3 = Person(p2);//拷贝构造

	Person(10);//匿名对象  特点：当前行执行结束后，系统会立即回收匿名对象

	//不要利用拷贝构造函数，初始化匿名对象  编译器会认为Person (p3)==Person p3;
	//Person(p3); 

	//隐式转换法
	Person p4 = 10;//相当于 Person p4=Person(10);
	Person p5 = p4;
	return 0;
}

拷贝构造函数调用时机

c++中拷贝构造函数调用时机通常有三种情况

使用一个已经创建完毕的对象来初始化一个对象
值传递的方式给函数参数传值
以值方式返回局部对象

在这里插入代码片#include<iostream>
#include<string>
using namespace std;
class Person {
public:
	int age;
	Person() {
		age = 0;
		cout << "Person 默认构造函数的调用;" << endl;
	}
	Person(int n) {
		age = n;
		cout << "Person 有参构造函数的调用;" << endl;
	}

	//析构函数
	~Person() {
		cout << "Person 析构函数的调用;" << endl;
	}
	//拷贝构造函数
	Person(const Person &p) { 
		cout << "Person 拷贝构造函数调用;" << endl;
		age = p.age;
	}    
};
//拷贝构造函数调用时机
//1 使用一个已经创建完毕的对象来初始化一个新对象
void test01() {
	Person p1(20);
	Person p2(p1);
	cout << "p2的年龄为:" << p2.age << endl;
}
//2 值传递的方式给函数参数传值
void doWork(Person p) {

}
void test02() {
	Person p;
	doWork(p);    //实参传递给形参时会调用拷贝构造函数
}

//3 值方式返回局部对象
Person doWork2() {
	Person p1;
	return p1;
}

void test03() {
	Person p = doWork2();
}
int main() {
	//test01();
	//test02();
	test03();
	return 0;
}

构造函数调用规则

默认情况下，c++编译器至少给一个类添加三个函数
1 默认构造函数（无参，函数体为空）
2 默认析构函数（无参，函数体为空）
3 默认拷贝构造函数，对属性进行拷贝

构造函数调用规则如下：
1 如果用户定义有参构造函数，c++不再提供默认无参构造，但是会提供
默认拷贝构造
2 如果用户定义拷贝构造函数，c++不再提供其他构造函数

深拷贝与浅拷贝

浅拷贝：简单的赋值拷贝操作
深拷贝：在堆区重新申请空间，进行拷贝操作

#include<iostream>
#include<string>
using namespace std;

//深拷贝与浅拷贝
//浅拷贝带来的问题 堆区的内容重复释放
//浅拷贝带来的问题 用深拷贝来解决（重新写一个拷贝构造函数）
class Person {
public:
	int mAge;//年龄
	int *mHeight;//身高   (把身高开辟到堆区)
	Person() {
		cout << "Person的默认构造函数调用" << endl;
	}
	Person(int age,int height) {
		mAge = age;
		mHeight=new int(height);  //用指针来接受堆区的数据
		cout << "Person的有参构造函数调用" << endl;
	}
	Person(const Person &p) {
		cout << "Person的拷贝构造函数调用" << endl;
		mAge = p.mAge;       //编译器内部写的 没问题
		//mHeight = p.mHeight; 编译器默认实现
		//深拷贝操作
		mHeight=new int(*p.mHeight);
	}
	~Person() {
		//析构代码，将堆区开辟数据做释放操作
		if (mHeight != NULL) {
			delete mHeight;
			mHeight = NULL;
		}
		cout << "Person的析构函数调用" << endl;
	}
};

void test01() {
	Person p1(18,160);
	cout << "p1的年龄为：" << p1.mAge <<" 身高为:"<<*p1.mHeight<< endl;
	Person p2(p1);
	cout << "p2的年龄为：" << p2.mAge << " 身高为:" <<*p2.mHeight << endl;
}

int main() {
	test01();
	return 0;
}
//如果有属性在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题