C++中对象的初始化和清理

最新推荐文章于 2022-10-11 12:24:43 发布

你好，清子

最新推荐文章于 2022-10-11 12:24:43 发布

阅读量537

点赞数

文章标签： c++

本文链接：https://blog.csdn.net/weixin_45595932/article/details/124954450

版权

二、对象的初始化和清理

1、构造函数和析构函数

构造函数的作用是初始化（针对对象的成员属性），析构函数作用是清理。

语法实现：

构造函数：类名（）{ }

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

析构函数：~类名（）{ }

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

另外，对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供。编译器提供的构造函数和析构函数是空实现

举例：

class Person
{
public :
	//构造函数
	Person()
	{
		cout << "Person的构造函数调用" << endl;
	} 
	//析构函数
	~Person()
	{
		cout << "Person的析构函数调用" << endl;
	}
};
void test01()
{
	Person p;
} 
int main() {
	test01();
	system("pause");
	return 0;
}

2、构造函数的分类以及调用

1）两种分类方式

按参数分：有参构造和无参构造（无参构造又称为默认构造函数）
按类型分：普通构造和拷贝构造

2）三种调用方式

括号法
显示法
隐式转换法

举例：

#include<iostream>
using namespace std;


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;
	}
public:
	int age;
};
//2、构造函数的调用
//调用无参构造函数
void test01() {
	Person p; //调用无参构造函数
} 
//调用有参的构造函数
void test02() {
	//2.1 括号法，常用
	Person p1(10);
	//注意1：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明
	//Person p2();
	//2.2 显式法
	Person p2 = Person(10);
	Person p3 = Person(p2);
	//Person(10)单独写就是匿名对象 当前行结束之后，马上析构
	//2.3 隐式转换法
	Person p4 = 10; // Person p4 = Person(10);
	Person p5 = p4; // Person p5 = Person(p4);
	//注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明
	//Person p5(p4);
} 


int main() {
	test01();
	//test02();
	system("pause");
	return 0;
}

有以下几点需要注意：

拷贝构造函数,用const的原因是拷贝是不可以更改的，另外必须得用引用传递
调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明，Person p2()是错误的
不能利用拷贝构造函数初始化匿名对象编译器认为是对象声明，Person p5(p4)是错误的

3、拷贝构造函数调用的时机

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

使用一个已经创建完毕的对象来初始化一个新对象（复制克隆）
值传递的方式给函数参数传值（值传递也会用到拷贝构造）
以值方式返回局部对象

对于第一点很好理解，也是最常用的的方法，这里不做过多介绍。在第二点中，值传递的方式给函数参数传值，这里也能理解，相当于传递过去过程是先将该对象拷贝复制，再将这复制的值传递给函数参数，因此这里也调用了拷贝构造函数。

举例：

class Person{
public:
	Person() {
		cout << "无参构造函数!" << endl;
		mAge = 0;
	} 
	Person(int age) {
		cout << "有参构造函数!" << endl;
		mAge = age;
	} 
	Person(const Person& p) {
		cout << "拷贝构造函数!" << endl;
		mAge = p.mAge;
	} 
	//析构函数在释放内存之前调用
	~Person() {
		cout << "析构函数!" << endl;
	}
public:
	int mAge;
};




//1. 使用一个已经创建完毕的对象来初始化一个新对象
void test01() {
	Person man(100); //p对象已经创建完毕
	//Person newman(man); //调用拷贝构造函数
	Person newman2 = man; //拷贝构造
	//Person newman3;
	//newman3 = man; //不是调用拷贝构造函数，赋值操作
}

//2. 值传递的方式给函数参数传值
//相当于Person p1 = p;
void doWork(Person p1) {}
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;
}

第一种使用一个已经创建完毕的对象来初始化一个新对象的两种方式：

Person man(100);
Person newman(man); //方式一
Person newman2 = man; //方式二

第二种值传递的方式给函数参数传值：

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

第三种以值方式返回局部对象：

Person doWork2()
{
	Person p1;
	return p1;
}

void test03() {
	Person p = doWork2();
}

4、构造函数调用规则

如果用户不提供构造函数，系统会自动生成默认无参构造，默认拷贝构造。
如果用户提供有参构造函数，系统不会自动生成默认无参构造，会有默认拷贝构造。
用户提供拷贝构造函数，系统不再提供拷贝构造函数。

5、深拷贝和浅拷贝

浅拷贝：简单的复制拷贝操作

深拷贝：在堆区重新申请空间，进行拷贝操作

浅拷贝带来的问题：如果在堆区创建内存，调用浅拷贝构造函数，在释放这部分内存时，会有两次释放，故而发生报错，因此需要用深拷贝，在堆区重新申请一段空间也指向该数据。（重复释放堆区问题）

举例：


class Person{
public:
	//无参（默认）构造函数
	Person() {
		cout << "无参构造函数!" << endl;
	} 
	//有参构造函数
	Person(int age ,int height) {
		cout << "有参构造函数!" << endl;
		m_age = age;
		m_height = new int(height);//在堆区开辟一段内存，将数据存入，输出其地址
	}
	//拷贝构造函数
	Person(const Person& p) {
		cout << "拷贝构造函数!" << endl;
		//如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题
		m_age = p.m_age;
		//m_height = p.m_height   //这样简单的赋值浅拷贝会报错
		m_height = new int(*p.m_height);//*p.m_height是180，这里重新开辟了一段内存
	} 
	//析构函数
	~Person() {
		cout << "析构函数!" << endl;
		if (m_height != NULL)
		{
			delete m_height;
		}
	}
public:
	int m_age;
	int* m_height;
};
void test01()
{
	Person p1(18, 180);
	Person p2(p1);
	cout << "p1的年龄： " << p1.m_age << " 身高： " << *p1.m_height << endl;
	cout << "p2的年龄： " << p2.m_age << " 身高： " << *p2.m_height << endl;
} 


int main() {
	test01();
	system("pause");
	return 0;
}

6、列表的初始化

传统方式的初始化需要在构造函数挨个对变量赋值，颇为复杂，这里有一个简单的列表初始化方式。

语法：

构造函数（）：属性1（值1），属性2（值2）...{}

构造函数（变量1，变量2，...）：属性1（变量1），属性2（变量2）...{}

举例：

class Person {
public:
	传统方式初始化
	//Person(int a, int b, int c) {
	// m_A = a;
	// m_B = b;
	// m_C = c;
	//}
	//初始化列表方式初始化
	Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c) {}
	void PrintPerson() {
		cout << "mA:" << m_A << endl;
		cout << "mB:" << m_B << endl;
		cout << "mC:" << m_C << endl;
	}
private:
	int m_A;
	int m_B;
	int m_C;
};
int main() {
	Person p(1, 2, 3);
	p.PrintPerson();
	system("pause");
	return 0;
}

7、类对象作为类成员（类的嵌套）

语法：

class A {};
class B
{
    A a；
};

B类中有对象A作为成员，A为对象成员。这就引出来另一个问题，A和B的构造和析构的顺序是如何的呢？

构造的顺序是：先调用对象成员的构造，再调用本类构造
析构的顺序是：与构造顺序相反，先调用本类析构，再调用对象成员的析构

举例：


class Phone
{ 
public :
	Phone(string name)
	{
		m_PhoneName = name;
		cout << "Phone构造" << endl;
	}
	~Phone()
	{
		cout << "Phone析构" << endl;
	} 
	string m_PhoneName;
};


class Person
{
public :
	//初始化列表可以告诉编译器调用哪一个构造函数
	Person(string name, string pName) : m_Name(name), m_Phone(pName)
	{
		cout << "Person构造" << endl;
	} 
	~Person()
	{
		cout << "Person析构" << endl;
	} 
	void playGame(){

		cout << m_Name << "使用" << m_Phone.m_PhoneName << "牌手机! " << endl;
	} 
	string m_Name;
	Phone m_Phone;
};


void test01()
{
	//当类中成员是其他类对象时，我们称该成员为 对象成员
	//构造的顺序是 ：先调用对象成员的构造，再调用本类构造
	//析构顺序与构造相反
	Person p("张三", "苹果X");
	p.playGame();
} 


int main() {
	test01();
	system("pause");
	return 0;
}

8、静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员
静态成员分为：静态成员变量和静态成员函数

1）静态成员变量

所有对象共享同一份数据（不是属于某一个对象，是类内所有对象共有）
在编译阶段分配内存
类内声明，类外初始化（举例：类内： static int m_A ; 类外 int Person::m_A =10;）
访问方式有两种，一种是通过对像访问(p1.m_A)，另外一种是通过类名访问(Person::m_A)

举例：


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

int Person::m_A = 10;
int Person::m_B = 10;
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;
	//2、通过类名
	cout << "m_A = " << Person::m_A << endl;
	//cout << "m_B = " << Person::m_B << endl; //私有权限访问不到
} 


int main() {
	test01();
	system("pause");
	return 0;
}

2）静态成员函数

所有对象共享同一个函数
静态成员函数只能访问静态成员变量

举例：

class Person
{ public :
	//静态成员函数特点：
	//1 程序共享一个函数//2 静态成员函数只能访问静态成员变量
	static void func()
	{
		cout << "func调用" << endl;
		m_A = 100;
		//m_B = 100; //错误，不可以访问非静态成员变量
	} 
	static int m_A; //静态成员变量，类内声明
	int m_B; //
private:
	//静态成员函数也是有访问权限的
	static void func2()
	{
		cout << "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;
}

注：本文内容是根据bilibili黑马程序员视频讲解总结。

https://www.bilibili.com/video/BV1et411b73Z?p=113

你好，清子

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C++中对象的初始化和清理

一、构造函数和析构函数构造函数的作用是初始化（针对对象的成员属性），析构函数作用是清理。语法实现：构造函数：类名（）{ }1. 没有返回值也不写void2. 函数名称与类名相同3. 构造函数可以有参数，因此可以发生重载4. 程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次析构函数：~类名（）{ }1.没有返回值也不写void2. 函数名称与类名相同,在名称前加上符号 ~3. 析构函数不可以有参数，因此不可以发生重载4. 程序在对象销毁前会自动调用析构，无须手动
复制链接

扫一扫