类和对象-----构造与析构

构造和析构函数

对对象的初始化和群清理也是特别重要的问题
一个对象如果没有初始状态,对其使用后果也是未知的,同样一个对象,没有及时清理,也会造成一定的安全问题
c++利用了构造函数和析构函数解决上述问题,这两个函数将会被编译器自动调用,完成对象的初始化和清理工作.对象的初始化和清理工作是编译器强制我们需要做的事情,因此如果我们不提供构造和析构,编译器会提供他们的空实现.

语法

//构造函数 :类名(){}

//1.没有返回值,也不写void
//2.函数名称和类名相同
//3.构造函数可以有参数,因此可以发生重载
//4.程序在调用对象会自动调用构造,无须手动调用,而且只会调用一次


//析构函数: ~类名(){}

//1.没有返回值,也不写void
//2.函数名称和类名相同,在前面加上~
//3.不可以有参数,不可以发生重载
//4.程序在对象销毁前会自动调用析构,无须手动调用,而且只会调用一次

class Person()
{	
public:
	Person()
		{ 
			cout << "构造函数的调用 "<< endl;
		}
	~Person()
	{
		cout << "析构函数的调用" << endl;
	}
};
//第一种 test01在main函数中调用,构造析构都会显示发生
void test01()
{
	Person p; // 在栈上的数据,01执行完后,释放这个对象
}

int main()
{	
	test01();
	return 0;
}

//第二种 Person p在main函数中创建  只有构造函数调用会显示,没有析构显示,有,但是是瞬间发生并消失,整个main结束会发生析构
int main()
{	
	Person p;  
	return 0;
}

构造函数的分类及调用

按参数 有参数和无参数
按类型 普通构造和拷贝构造
三种调用方式 : 括号法 显示法 隐式转换法

class Person()
{	
public:
	Person()
		{ 
			cout << "无参(默认)构造函数的调用 "<< endl;
		}
	Person(int a)
		{
			age = a;
			cout << "有参构造函数的调用 "<< endl;
		}
	//拷贝构造函数  不可以改本体 使用const 
	Person(const Person &p)
		{ 
		//将传入的人身上所有属性拷贝到自己身上
			age = p.age;
			cout << "拷贝构造函数的调用 "<< endl;
		}
	
	~Person()
	{
		cout << "析构函数的调用" << endl;
	}
	int age; 
};
//调用
void test01()
{
	//1.括号法
	Person p;  // 默认构造函数调用  显示无参函数调用和析构函数调用
	Person p2(10);  //有参构造函数  显示有参函数调用和析构函数
	Person p3(p2);  ///拷贝构造函数  显示拷贝函数调用和析构函数

//注意事项
//调用默认构造哈数,不要加()
//因为编译器会认为是一个函数的声明 Person p1(); ,不会认为在创建对象

	cout << ""p2的年龄:" << p2.age ;  //10
	cout << ""p3的年龄:" << p3.age ;	  //10
    //2.显示法
	Person p1;  //无参
	Person p2 = Person (10);  //有参  
	 Person (10);  //匿名对象 特点;当前行执行结束后,系统立即收回匿名对象
	 cout << "aaaa"<< endl;
// 顺序 :有参函数调用 析构函数调用  aaaa
	Person p3 = Person (p2) ;;//拷贝

//隐式转换法
Person p4 = 10;   //有参  Person p4 = Person (10);
Person p5 = p4; //拷贝构造

}

int mian ()
{
	test01();

]

拷贝构造函数调用时机

c++中拷贝构造函数调用时机: 三种
1.使用一个已经创建完毕的对象来初始化一个对象
2.值传递的方式给函数参数传值
3.以值方式返回局部对象
调用规则:
1.如果用户定义有参构造函数,c++不提供默认无参构造函数,但是还是会提供默认拷贝构造函数
2.如果用户定义拷贝构造函数,c++不再提供其他构造函数

深拷贝与浅拷贝

深拷贝是面试问题经典问题,也是常见的一个坑
浅拷贝: 简单赋值拷贝操作
深拷贝 :在堆中重新申请空间,进行拷贝操作

class Person()
{	
public:
	Person()
		{ 
			cout << "无参(默认)构造函数的调用 "<< endl;
		}
	Person(int age)
		{
			m_Age = age;
			cout << "有参构造函数的调用 "<< endl;
		}
	~Person()
	{
		cout << "析构函数的调用" << endl;
	}	
	int m_Age;


void test01()
{
	Person p1(18);
	cout << "p1 的年龄 :" << p1.age << endl;
	Person p2(p1); //我们没有定义 但编译器自动生成拷贝构造函数   属于浅拷贝
	cout << "p2 的年龄 :" << p2.age << endl;

}

int main()
{
	test01();
	return 0;
}

class Person()
{	
public:
	Person()
		{ 
			cout << "无参(默认)构造函数的调用 "<< endl;
		}
	Person(int age, int height)
		{
			m_Age = age;
			m_Height = new int(height);
			cout << "有参构造函数的调用 "<< endl;
		}
	~Person()
	{
	//析构代码,将堆区开辟的数据做释放操作
	if(m_Height != NULL)
	{
		delete m_Height;
		m_Height = NULL;
	}
		cout << "析构函数的调用" << endl;
	}	
	int m_Age;
	int *m_Height;


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

}

int main()
{
	test01();
	return 0;
}

上述代码会崩

原因: 浅拷贝使堆区内存重复释放

浅拷贝的问题用深拷贝解决

Person (const Person &p)
{
	cout << "person拷贝构造函数调用" << endl;
	m_Age = p.m_Age;
	//m_Height = p.m_Height;   编译器默认实现这行代码
	//深拷贝操作
	m_Height = new int (*p.m_Height);
}

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