C++ >>类和对象之 构造、析构函数

时间：2019年8月22日11:57:55
编译器：vs2017

构造函数，析构函数

 1. 构造函数与析构函数简介
 2. 构造函数分类和调用
 3. 构造函数的调用规则
 4. 拷贝函数的调用时机
 5. 深拷贝与浅拷贝

我的理解：析构函数女娲姐姐造人，从无到有，创建人（对象）， 然后人的五官和四肢对应着构造函数里面的形参，而析构函数像是人(构造函数)在贡献社会后，死去被推入火葬场，一切归于虚无。

// 构造函数语法 ： 类名(){}
/*
	1、构造函数，没有返回值也不写void
	2、函数名称与类名相同
	3、构造函数可以有参数，因此可以发生重载
	4、程序在调用对象时会自动构造函数，无须手动调用，而且只会调用一次
*/

// 析构函数语法：~类名(){}
/*
	1、析构函数，没有返回值也不写void
	2、函数名称与类名相同，在名称前加上 ~
	3、析构函数不可以有参数， 因此不可以发生重载
	4、程序在对象销毁前会自动调用析构，无须手动调用，而且只会调用一次
*/

#include <iostream>
using namespace std;

// 对象的初始化和清理

class Person
{
public:
	// 1、构造函数 进行初始化操作
	Person()
	{
		cout << " Person 构造函数的调用 " << endl;
	}

	// 2、析构函数 进行清理操作

	~Person()
	{
		cout << " Person 析构函数的调用 " << endl;
	}

};


// 构造和析构都是必须有的实现， 如果我们自己不提供，编译器会提供一个空实现的构造和析构函数
void test01()
{
	Person p;   //在栈上的数据， test01 执行完毕之后， 释放这个对象
}

int main()
{
	//test01();
	Person p;

	system("pause");
	return 0;    
}

构造函数的分类和调用

#include <iostream>
using namespace std;

// 1、构造函数的分类及调用
// 分类

// 按照参数分类  无参（默认）构造 和 有参构造
// 按照类型分类   普通构造   拷贝构造
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;
};


void test01()
{
	// 1、括号法
	//Person p1;     //默认构造函数调用
	//Person p2(10);   //有参函数构造
	//Person p3(p2);     // 拷贝函数构造的调用  括号里面写 p1 或 p2 或者任何数都行， 是常量就好

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


	//cout << " p2的年龄为： " << p2.age << endl;
	//cout << " p3的年龄为： " << p3.age << endl; // 如果括号里是 p2 ，那么显示的和上面一样。
	                                            //但是我自己添加了常量， 就显示添加的常量

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

	Person(10);       //匿名对象，  当前行执行结束后， 系统会自动回收掉匿名对象

	// 注意事项2
	// 不要利用拷贝构造函数  初始化匿名对象  编译器会认为Person(p3) == Person p3,  重定义
	// Person(p3);

	//3、隐士转换法
	Person p4 = 10;    //相当于写了  Person p4 = Person (10);
	Person p5 = p4;


}

int main()
{

	test01();

	system("pause");
	return 0;
}

构造函数的调用时机：

#include <iostream>
using namespace std;

// 构造函数的调用规则
// 1、创建一个类， C++编译器会给每个类都添加至少3个函数
// 默认构造   （空实现）
// 析构函数   （空实现）
// 拷贝函数	  （值拷贝）


// 2、如果我们写了有参构造函数， 编译器就不再提供默认构造， 但依然提供拷贝构造
// 如果我们写了拷贝构造函数， 编译器就不再提供提供其他普通的构造函数了

class Person
{
public:

	Person()
	{
		cout << " Person 的默认构造函数调用 " << endl;
	}

	Person(int age)
	{
		cout << " Person 的有参构造函数的调用 " << endl;
		m_Age = age;
	}

	Person(const Person & p)
	{
		m_Age = p.m_Age;
		cout << " Person 的拷贝构造函数的调用 " << endl;
	}


	~Person()
	{
		cout << " Person 析构函数调用 " << endl;
	}
	int m_Age;
};

void test01()
{
	Person p;
	p.m_Age = 18;

	Person p2(p);
	cout << " p2的年龄为： " << p2.m_Age << endl;
}

void test02()
{
	//Person p;
	Person p(28);
	Person p2(p);

	cout << " p2的年龄为： " << p2.m_Age << endl;

}


int main()
{
	//test01();
	test02;

	system("pause");
	return 0;
}

拷贝函数的调用时机

#include <iostream>
using namespace std;

// 拷贝构造函数调用时机

// 1、使用一个已经创建完毕的对象来初始化一个新对象

// 2、值传递的方式给函数参数传值

// 3、值方式返回局部对象

class Person
{
public:
	Person()
	{
		cout << " Person 默认构造函数调用 " << endl;
	}

	Person(int age)
	{
		cout << " Person 有参构造函数调用 " << endl;
		m_Age = age;
	}

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



	int m_Age;
};

// 1、使用一个已经创建完毕的对象来初始化一个新对象
void test01()
{
	Person p1(20);
	Person p2(p1);

	cout << " p2的年龄为： " << p2.m_Age << endl;

}

// 2、值传递的方式给函数参数传值
void doWork(Person)
{

}

void test02()
{
	Person p;
	doWork(p);
}


// 3、值方式返回局部对象
Person doWork2()
{
	Person p1;
	cout << (int*)&p1 << endl;
	return p1;
}

void test03()
{
	Person p = doWork2();
	cout << (int*)&p << endl;
}



int main()
{
	//test01();

	//test02();

	test03();

	system("pause");
	return 0;
}

深拷贝与浅拷贝

#include <iostream>
using namespace std;

//浅拷贝：简单的赋值拷贝操作


//深拷贝：在堆区(程序员手动开启数据，手动释放数据 )里重新申请空间，进行拷贝操作

class Person
{
public:
	// 构造函数
	Person()
	{
		cout << " Person 无参构造函数的调用 " << endl;
	}

	Person(int a, int height)
	{
		age = a;
		m_Height = new int(height);
		cout << " Person 有参构造函数的调用 " << endl;
	}

	//拷贝构造函数
	Person(const Person &p)   //拷贝出一份一模一样的数据出来
	{
		cout << " Person 拷贝构造函数的调用 " << endl;
		// 将传入的人身上的所有属性， 拷贝到我身上
		age = p.age;
		//m_Height = p.m_Height;  编译器默认就是实现这行代码
		//深拷贝操作
		m_Height = new int(*p.m_Height);
	}


	// 析构函数
	~Person()
	{
		//析构代码，将堆区开辟数据做释放操作
		if (m_Height != NULL)
		{
			delete m_Height;
			m_Height = NULL;
		}
		cout << " Person 析构函数的调用 " << endl;
	}

	int age;
	int *m_Height;
};


void test01()
{
	Person p1(18, 160);

	cout << " p1的年龄为： " << p1.age << " 身高： " << *p1.m_Height << endl;

	Person p2(p1);
	cout << " p1的年龄为： " << p2.age << " 身高： " << *p2.m_Height << endl;

}



int main()
{
	test01();

	system("pause");
	return 0;
}

// 如果属性有在堆区开辟的，一定要自己提供拷贝构造函数， 防止浅拷贝带来的问题