15、C++对象的初始化和清理

一、构造函数和析构函数

构造函数：编译器自动调用，主要为对象成员属性赋值，

                  程序在调用对象时，自动调用构造函数

                   有参数，可以发生重载

析构函数：对象销毁前，系统自动调用，执行一些清理工作

                  程序在对象销毁前，自动调用析构函数，无需手动调用

                  没有参数，不可以重载

编译器提供的构造函数和析构函数是空的

二、构造函数的分类及调用

1.分类

参数分类：有参构造 和 无参构造（默认构造函数）

类型分类：普通构造 和 拷贝构造

//无参构造函数（默认构造函数）
    Person() { ...}
//有参构造函数
    Person(int a) {...}
//拷贝构造函数
    Person(const Person& per) { ..}
将参数中的对象的属性，拷贝到此对象的属性

2.调用

（1）括号法

    1.括号法
    Person p1;   //调用无参构造函数
    Person p2(10);    //调用有参构造函数
    Person p3(p2);    //调用拷贝构造函数

    //注意事项
    //调用默认构造函数不要加（）
    //原因：会被认为是函数声明
    Person p4();  //啥也没有调用
    //void func();

（2）显示法

    Person p1;
    Person p2 = Person(10);   //有参构造函数，给匿名对象起名字p2
    Person p3 = Person(p2);   //拷贝构造函数

    //匿名对象
    Person(10);  //匿名对象(有参构造函数),匿名对象:当前行执行结束后，系统立即回收匿名对象
    //cout << "aaaa" << endl;                    //构造完了马上析构
     
    //不要用拷贝构造，初始化匿名函数
    //Person(p2);  //编译器认为 Person(p2)==Person p2;（重定义）

（3）隐式转换法

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

#include<iostream>
using namespace std;

class Person
{
public:
	//无参构造函数（默认构造函数）
	Person()
	{
		m_Age = 0;
		cout << "person无参构造函数调用" << endl;
	}
	//有参构造函数
	Person(int a)
	{
		m_Age = a;
		cout << "person有参构造函数调用" << endl;
	}
	//拷贝构造函数
	Person(const Person& per)
	{
		cout << "person拷贝构造函数调用" << endl;
		//将参数中的对象的属性，拷贝到此对象的属性
		m_Age = per.m_Age;
		
	}
	~Person()
	{
		cout << "Person析构函数调用" << endl;
	}
public:
	int m_Age;
};

//构造函数的调用
void test01()
{
	//1.括号法
	Person p1;   //调用无参构造函数
	Person p2(10);	//调用有参构造函数
	Person p3(p2);	//调用拷贝构造函数

	//注意事项
	//调用默认构造函数不加（）
	//原因：会被认为是函数声明
	//Person p4();  //啥也没有调用
	//void func();


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

	//显示法
	Person p1;
	Person p2 = Person(10);   //有参构造函数，给匿名对象起名字p2
	Person p3 = Person(p2);   //拷贝构造函数

	//匿名对象
	Person(10);  //匿名对象(有参构造函数),匿名对象:当前行执行结束后，，系统立即回收匿名对象
	cout << "aaaa" << endl;					//构造完了马上析构
	 
	//不要用拷贝构造，初始化匿名函数
	//Person(p2);  //编译器认为 Person(p2)==Person p2;

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


}

int main()
{
	test01();

	system("pause");
	return 0;
}

三、拷贝构造函数调用时机

1.使用一个已经创建完备的对象来初始化一个新对象
void test01()
{
    Person p1;
    Person p2(p1);
}

2.值传递的方式给函数参数传值
void func(Person p)
{

}
void test02()
{
    Person p1;
    func(p1);
}

3.值方式返回局部对象

局部对象函数执行后被释放掉，（值方式Person,返回）创建新对象
Person func02()
{
    Person p;
    cout << "aaa" << endl;
    return p;  //返回时，新创建（拷贝）一个对象
}               
void test03()
{
    Person p = func02();    //先拷贝(return p)，后析构 Person p
    cout << "bbb" << endl;
}

 

#include<iostream>
using namespace std;

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


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

//2.值传递的方式给函数参数传值
void func(Person p)
{

}
void test02()
{
	Person p1;
	func(p1);
}

//3.值方式返回局部对象
Person func02()	//局部对象函数执行后被释放掉，创建新对象（值方式返回）
{
	Person p;
	cout << &p << endl;
	return p;  //返回时，新创建（拷贝）一个对象
}				//先拷贝，后析构
void test03()
{
	Person p = func02();
	cout << &p << endl;
}


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


	system("pause");
	return 0;
}

 

 

四、构造函数的调用规则

1、默认情况下，c++编译器至少给一个类添加3个函数

1.默认构造函数（函数体为空）

2.默认析构函数（函数体为空）

3.默认拷贝构造函数，对属性进行值拷贝

2、构造函数调用规则：

1.用户提供了有参构造函数，c++不提供无参构造，但提供拷贝构造函数

2.用户提供了拷贝构造函数，c++不再提供 其他构造函数

//默认构造函数    1

//有参构造函数    2

//拷贝构造函数    3

五、深拷贝和浅拷贝

1、区别：

当类中成员属性存在在堆区开辟内存的情况

浅拷贝：直接套用等式，使得拷贝的两个对象公用堆区的那块内存（释放内存时，出问题）

深拷贝：解决浅拷贝问题，自己定义拷贝构造函数，重新在堆区开辟内存

系统的浅拷贝碰到成员中new开辟堆区时，出现问题。自己定义深拷贝解决问题
 Person(const Person& p)
  {
     m_Age = p.m_Age;
     //m_Height = p.m_Height;        //编译器默认实现代码，浅拷贝：堆区空间共用
     m_Height = new int(*p.m_Height);   //自己重新开辟内存，解决堆区空间共享，重复销毁问题
    }

//浅拷贝带来的问题：堆区内存重复释放    公用一块堆区
//利用深拷贝解决浅拷贝问题                      分别使用使用各自堆区

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

深拷贝：在堆区申请内存，进行拷贝操作

如果类中属性有在堆区开辟的，必须自己提供拷贝构造函数，防止浅拷贝带来的问题

————————————————

//堆区开辟内存代码

class Person
{
public:
    Person();
    Person(int age,int height)
    {
        m_Height = new int(height);    
    }
    ~Person();
public:
    int* m_Height;   //堆区开辟内存，指针接受 new int(height) 的地址
};

————————————————

#include<iostream>
using namespace std;

class Person
{
public:
	Person()
	{
		cout << "Person的默认构造函数" << endl;
	}
	Person(int age,int height)
	{
		m_Age = age;
		m_Height = new int(height);
		cout << "Person的有参构造函数" << endl;
	}
	//系统的浅拷贝碰到成员中new开辟堆区时，出现问题
	//自己定义深拷贝解决问题
	Person(const Person& p)
	{
		m_Age = p.m_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;
	}
public:
	int m_Age;
	int* m_Height = NULL;
};


//浅拷贝带来的问题：堆区内存重复释放	公用一块堆区
//利用深拷贝解决浅拷贝问题				分别使用使用各自堆区
void test01()
{
	Person p1(19,165);
	cout << "p1的年龄为：" << p1.m_Age << "  p1的身高为：" << *p1.m_Height << endl;

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


int main()
{
	test01();


	system("pause");
	return 0;
}

六、初始化列表

Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c) { }

Person() :m_A(10), m_B(20), m_C(20)  { }

七、类和对象作为类成员

对象成员

当其他类对象作为本类成员，先调用类中对象成员的构造函数，再调用本类的构造函数

静态成员

1、静态成员变量

（1）所有对象共享同一份数据

（2）在编译阶段，分配内存

（3）类内声明，类外初始化

2、静态成员函数

所以对象共享同一个函数

——————————————

class Person
{
public :
    static int m_A;
private:
    //静态成员变量也有访问权限
    static int m_B;
};

int Person::m_A = 10;
int Person::m_B = 20;

静态成员变量的两种访问方式

//1.通过对象
    Person p1;
    p1.m_A = 100;
    cout << "p1.m_A=" << p1.m_A << endl;

    Person p2;
    p2.m_A = 200;
    cout << "p1.m_A=" << p1.m_A << endl;    //共享同一份数据
    cout << "p2.m_A=" << p2.m_A << endl;

    //通过类名
    cout << Person::m_A << endl;

#include<iostream>
using namespace std;

class Person
{
public :
	static int m_A;
private:
	//静态成员变量也有访问权限
	static int m_B;
};

int Person::m_A = 10;
int Person::m_B = 20;

void test01()
{
	//静态成员变量的两种访问方式

	//1.通过对象
	Person p1;
	p1.m_A = 100;
	cout << "p1.m_A=" << p1.m_A << endl;

	Person p2;
	p2.m_A = 200;
	cout << "p1.m_A=" << p1.m_A << endl;	//共享同一份数据
	cout << "p2.m_A=" << p2.m_A << endl;

	//通过类名
	cout << Person::m_A << endl;
	//cout << Person::m_B << endl;  私有静态成员变量，无法访问
}

int main()
{
	test01();

	system("pause");
	return 0;
}

2.静态成员函数

所以对象共享同一个函数  //Person::func()

静态成员函数只能访问静态成员变量

1.通过对象访问
    Person p1;
    p1.func();

2.通过类名访问
    Person::func();   //它不属于对象

#include<iostream>
using namespace std;

class Person
{
public:
	static void func()
	{
		m_A = 300;
		//m_B = 200;  静态成员变量只能访问静态成员函数
		cout << "static void func()" << endl;
	}
public:
	static int m_A;
	int m_B;
private:
	static void func2()
	{
		cout << "static void func2()" << endl;
	}
};

int Person::m_A = 10;

void test01()
{
	//1.通过对象访问
	Person p1;
	//p1.func();

	//2.通过类名访问
	Person::func();   //它不属于对象
	//Person::func2();  //静态成员函数也有访问权限

}


int main()
{

	test01();


	system("pause");
	return 0;
}