21C++面向对象编程---2、对象初始化和清理

已于 2022-10-13 21:12:03 修改
阅读量144 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言 面向对象编程
于 2022-08-20 20:45:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45986997/article/details/126444111
版权

文章目录

9.4.2 对象初始化和清理
  • 在生活中我们买的电子产品都基本有出厂设置，在某一天我们不用时候也会删除一些自己信息数据保证安全
  • C++中的面向对象来源于生活，每一个对象也都会有初始化设置以及对象销毁前的数据清理的设置。
1、构造函数和解析函数

对象的初始化和清理也是两个非常重要的安全问题。

一个对象或者变量没有初始化，对其使用后果是未知的

同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题。

C++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。对象的初始化和清理工作是编译器强制要求我们做的事情，因此如果我们不提供构造和析构，编译器会提供编译器所提供的构造函数和析构函数是空实现。

  • 构造函数（初始化）：主要作用在于创建对象时为对象的成员属性赋值，构造函数是由编译器自动调用，无须手动调用。
  • 析构函数（清理）：主要作用在于对象销毁前系统自动调用，执行一些清理工作。

构造函数语法：类名(){}

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

析构函数语法：类名(){}

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

示例代码:

#include<iostream>
using namespace std;

//对象的初始化和清理

class Person
{
public:
	//1、构造函数 进行初始化操作
	//1.1 构造函数
	// 	   没有返回值  不用写void
	// 	   函数名  与类名相同
	// 	   构造函数可以有参数，可以发生重载
	// 	   创建对象的时候，构造函数会自动调用，而且只会调用一次
	//
	Person()
	{
		cout << "Person析构函数的调用" << endl;
	}

	//2、析构函数进行清理的操作
	//没有返回值，不写void
	//函数名和类名相同，在名称前加上~
	// 	   析构函数不可以有参数，不能发生重载
	// 	   对象在销毁前，会自动调用析构函数，而且只会调用一次
	//
	~Person()
	{
		cout << "Person的析构函数调用" << endl;
	}
};



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

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

int main()
{
	test01();

	//Person p;//析构函数在对象执行完后才会被销毁，当我们按下任意键时程序才结束

	system("pause");
	return 0;
}

运行结果：

在这里插入图片描述

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

两种分类方式：

  • 1、按参数分为：有参构造和无参构造
  • 2、按类型分为：普通构造和拷贝构造

3种调用方式：

  • 括号法
  • 显示法
  • 隐式转换法

示例：

#include<iostream>
using namespace std;

//析构函数的分类及调用
//分类

class Person
{

public:
	//构造函数
	//按参数进行分类		无参构造（默认构造）和有参构造

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

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

	}
	//按类型进行分类				普通构造和拷贝构造
	Person(const Person &p)  //加const防止传进来的数据被修改，通过应用方式传进来
	{
		//将传入的人身上的所有属性，拷贝到我身上
		age = p.age;
		cout << "Person拷贝构造函数的调用" <<p.age<< endl;

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

	//属性
public:
	int age;
};

//调用
void test02()
{
	//1、括号法
	//Person p1;//默认构造函数调用
	//Person p2(10);	//有参构造函数调用
	//Person p3(p2);//拷贝构造函数调用

	//注意事项
	// 	   调用默认构造函数的时候，不要加（）
	//结果显示没有创建对象，因为下面这行代码，编译器会认为是一个函数的声明，不会认为在创建对象
	//Person p1();//与void func(); 函数声明类似

	//cout << "p2的年龄为：" << p2.age << endl;
	//cout << "p3的年龄为：" << p3.age << endl;

	//2、显示法
	//Person p1;//默认构造函数调用
	//Person p2=Person(10);	//该调用方式有参构造函数调用
	//Person p3=Person(p2);//拷贝构造函数调用

	//Person(10);//匿名对象，当前行执行结束后，系统会立即回收匿名对象
	//cout << "aaaa" << endl;
	 
	// 注意事项2、
	// 不要利用拷贝构造函数，初始化匿名对象
	//编译器会默认认为 Person（p3）==Person p3  默认为对象的声明
	//Person(p3);


	//3、隐式转换法
	Person p4 = 10;//相当于写了  Person p4 = Person(10)  有参构造调用
	Person p5 = p4;//拷贝构造

}

int main()
{
	test02();

	system("pause");
	return 0;
}

运行结果：
在这里插入图片描述

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

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

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

示例：

#include<iostream>
using namespace std;

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



class Person2
	{
	public:
		//无参构造函数
		Person2()
		{
			cout << "Person2()默认构造函数调用" << endl;
		}
		//有参构造函数
		Person2(int age)
		{
			m_age = age;
			cout << "Person2(int a)有参构造函数调用" << endl;

		}

		//拷贝构造函数
		Person2(const Person2& p)
		{
			m_age = p.m_age;
			cout << "Person2()拷贝构造函数调用" << endl;

		}

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

		int m_age;
};

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

	cout << "p2.m_age = " << p2.m_age << endl;
}


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

void doWork(Person2 p)
{

}

void test04()
{
	Person2 p;
	doWork(p);
}

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

Person2 doWork2()
{
	Person2  p1;
	cout << (int*)&p1 << endl;
	return  p1;   //根据p1拷贝一份作为返回值
}
void  test05()
{
	Person2 p2= doWork2();
	cout << (int*)&p2 << endl;

}


int main()
{
	//test03();

	//test04();

	test05();

	system("pause");
	return 0;
}

运行结果：

在这里插入图片描述

4、构造函数调用规则

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

  1. 默认构造函数（无参，函数体为空）
  2. 默认析构函数（无参，函数体为空）
  3. 默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

  • 如果用户定义有参构造函数，c++不再提供默认无参构造，但是会提供默认拷贝构造
  • 如果用户定义拷贝构造函数，c++不会再提供其他构造函数。

示例：

#include<iostream>
using namespace std;

//构造函数的调用规则
//1、构造函数的调用规则
// 默认构造（空实现）
// 析构函数（空实现）
// 拷贝构造（值拷贝）
// 
// 2、如果我们写了有参构造函数，编译器就不再提供默认构造，依然提供拷贝构造
//3、如果我们写了拷贝构造函数，编译器就不再提供普通的构造函数

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

	//Person3(int a)
	//{
	//	m_age = a;
	//	cout << "Person3的有参构造函数调用" << endl;
	//}

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

	}



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

	int m_age;

};

//void test1()
//{
//	Person3 p1;
//	p1.m_age = 18;
//
//	Person3 p2(p1);
//
//	cout << "p2.m_age = " << p2.m_age << endl;
//}

void test2()
{
	//Person3 p(22);
	Person3 p;

	//Person3 p2(p);

	//cout << "p2的年龄为：" << p2.m_age << endl;
}

int main()
{
	//test1();

	test2();

	system("pause");
	return 0;
}

运行结果：

在这里插入图片描述

5、深拷贝与浅拷贝

深浅拷贝是面试经典问题，也是常见的一个坑

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

示例代码：

#include<iostream>
using namespace std;

//深拷贝与浅拷贝
class  Person3
{
public:
	Person3()
	{
		cout << "Person3的默认构造函数调用" << endl;
	}

	Person3(int a,int height)
	{
		m_age = a;
		m_height = new int(height);

		cout << "Person3的有参构造函数调用" << endl;
	}

	//自己实现拷贝构造函数，解决编译器浅拷贝的带来的问题
	Person3(const Person3& p)
	{
		
		cout << "Person3的拷贝构造函数调用" << endl;
		m_age = p.m_age;
		//m_height = p.m_height;编译器默认实现就是这行代码---浅拷贝
		
		//深拷贝操作
		m_height = new int(*p.m_height);  //重新开辟一个空间来存放m_height
	}



	~Person3()
	{
		//析构代码，将堆区开辟数据做释放操作
		if (m_height !=NULL)
		{
			delete m_height;	//释放内存
			m_height = NULL;//置为null防止野指针出现
		}
		cout << "Person3的析构函数调用" << endl;
	}

	int m_age; //年龄
	int* m_height;//身高，将身高数据开辟到堆区

};

void test51()
{
	Person3 p1(22,180);
	cout << "p1.m_age = " << p1.m_age <<"p1.m_height = "<<*p1.m_height<< endl;

	Person3 p2(p1);
	cout << "p2.m_age = " << p2.m_age << "p2.m_height = " << *p2.m_height << endl;

}

int main()
{
	test51();

	system("pause");
	return 0;
}

运行结果：

在这里插入图片描述

中间过程重新的问题：

编译器报错未加载pdb文件：

在这里插入图片描述

1、报错原因分析：是因为m_height对应的内存空间被重复释放。

在这里插入图片描述

2、报错解决办法：利用深拷贝代替编译器的浅拷贝带领的问题。

在这里插入图片描述

6、初始化列表

作用：

C++提供了初始化列表语法，用来初始化属性。

**语法：**构造函数（）：属性1（值1），属性2（值2）…{}

示例：

#include<iostream>
using namespace std;

//初始化列表

class  Person
{
public:
	//传统方法
	//void set_value(int a, int b, int c)
	//{
	//	m_a = a;
	//	m_b = b;
	//	m_c = c;
	//}
	 
	// 	   初始化列表法
	//Person() :m_a(10), m_b(20), m_c(30)//这种方法，把值固定住了
	//{

	//}

	Person(int a, int b, int c) :m_a(a), m_b(b), m_c(c)
	{

	}


	int m_a;
	int m_b;
	int m_c;
};

void test61()
{
	//Person p;
	//p.set_value(10,20,30);
	//cout << "m_a = " << p.m_a << endl;
	//cout << "m_b = " << p.m_b << endl;
	//cout << "m_c = " << p.m_c << endl;

	Person p(30,20,10);
	cout << "m_a = " << p.m_a << endl;
	cout << "m_b = " << p.m_b << endl;
	cout << "m_c = " << p.m_c << endl;
}


int main()
{
	test61();

	system("pause");
	return 0;
}

运行结果：

在这里插入图片描述

7、类对象作为类成员

C++类中的成员可以是另一个类的对象，我们称该成员为对象成员。

例如：

class A{}
class B
{
	A a;
}

B类中有对象作为成员，A为对象成员

那么当创建B对象时，A与B的构造和析构的顺序是谁先谁后？

  • 结论：当其他类对象作为本类成员，构造时候先构造类对象，再构造本身;析构顺序与构造相反

示例：

#include<iostream>
using namespace std;

//类对象作为类成员

//手机类
class Phone
{
public:

	//手机品牌名称
	string m_Pname;  

	Phone(string name)
	{
		cout << "手机构造函数" << endl;
		m_Pname = name;
	}

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

class  Person7
{
public:
	//有参数构造函数
	//相当于Phone m_Phone = pName
	Person7(string name, string Pname) : m_name(name), m_phone(Pname)
	{
		cout << "Person7的有参构造函数调用" << endl;

	}
	//姓名
	string m_name;
	//手机类对象
	Phone m_phone;

	~Person7()
	{
		cout << "这是Person7析构函数的调用" << endl;

	}

};

//结论：当其他类对象作为本类成员，构造时候先构造类对象，再构造本身;析构顺序与构造相反
void test71()
{
	Person7 p("李四", "华为P40");
	cout << p.m_name << "使用:	" << p.m_phone.m_Pname << endl;
}


int main()
{
	test71();

	system("pause");
	return 0;
}

运行结果：

在这里插入图片描述

8、静态成员

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

静态成员分为：

  • 1、静态成员变量
  1. 所有对象共享同一份数据
  2. 在编译阶段分配内存
  3. 类内声明，类外初始化
  • 2、静态成员函数
  1. 所有对象成员共享一个函数
  2. 静态成员函数只能访问静态成员变量

**示例1：**静态成员变量

#include<iostream>
using namespace std;

//静态成员变量
class Person
{
public:
	//1 所有对象都共享同一份数据
	//2 编译阶段就分配内存
	//3 类内声明，类外初始化操作
	static  int m_A;

private:
	static  int m_B;
};

int Person:: m_A = 10;		//指明m_A为Person作用域下的变量
int Person::m_B = 100;

void test81()
{
	Person p;
	cout << p.m_A << endl;

	Person p2;
	p2.m_A = 12;
	cout << p.m_A << endl;

}

void test82()
{
	//静态成员变量  不属于 某个对象上，所有对象都共享同一份数据

	//1、通过对象进行访问
	/*Person p;
	cout << p.m_A << endl;*/

	//2、通过类名进行访问
	cout << Person::m_A << endl;  //类名称：：
	//cout << Person::m_B << endl;  //类外不能访问私有静态成员变量

}

int main()
{
	//test81();
	test82();


	system("pause");
	return 0;
}

运行结果：

在这里插入图片描述

**示例2：**静态成员函数

#include<iostream>
using namespace std;

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

class  Person
{

public:
	//静态成员函数
	static  void func()
	{
		m_C = 100;		//静态成员变量可以访问静态成员变量
		//m_D = 12;			//静态成员函数不可以访问非静态成员变量，无法区分到底是哪个对象的m_D
		cout << "static void func()的调用" << endl;
		cout << "m_C = " << m_C << endl;
	}

	static	int m_C;		//静态成员变量
	int m_D;  //非静态成员变量

private:
	static void func2()
	{
		cout << "static void func2()的调用" << endl;

	}
};

int Person:: m_C = 10;  //静态成员变量类内声明，类外初始化

void test91()
{
	//两种访问方式
	//1、通过对象访问
	//Person p;
	//p.func();

	//2、通过类名访问
	cout << "m_C = " <<Person::m_C<<endl;
	Person::func();

	//Person::func2();//类外访问不到私有静态成员函数
}

int main()
{
	test91();

	system("pause");
	return 0;
}

运行结果：

在这里插入图片描述

在这里插入图片描述
上一篇：20C++面向对象编程----1、类的封装

下一篇：22C++面向对象编程----3、对象模型和this指针

GUET_一路向前
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++类和对象---对象的初始化和清理
m0_50046535的博客
04-14 477
1、构造函数和析构函数 对象的初始化和清理是非常重要的安全问题 c++利用了构造函数和析构函数解决上述问题，这个函数编译器自动调用。如果程序员没有提供构造和析构函数，编译器会提供默认的构造和析构函数，都是空实现。 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用 析构函数：主要作用在于对象销毁前系统自行调用，执行一些清理工作 构造函数语法：类名（）{} 构造函数，没有返回值也不写void 函数名称和类名相同 构造函数可以有参数，因此可以发送重载 程
c++对象的初始化和清理
qq_32328985的博客
03-09 721
文章目录构造函数和析构函数构造函数的分类和调用 构造函数和析构函数 对象的初始化和清理是两个非常重要的安全问题： 一个对象或者变量没有初始状态，对其使用后果是未知的； 使用完应该对象或变量，没有及时清理，也会造成一定的安全问题。 c++可以利用构造函数和析构函数解决上述问题。在两个函数会被编译器自动调用。对象的初始化和清理工作是编译器强制要做的，当我们不提供构造函数和析构函数时，编译器会提供空...
C#创建、销毁对象和继承
01-03
内容提要 • 使用构造方法 • 初始化数据 • 对象和内存 • 资源管理 派生类 • 实现方法 • Sealed类 • 使用接口 • 使用抽象类
4.2 对象的初始化和清理
shidian1的博客
05-17 445
生活中我们买的电子产品都基本会有出厂设置，在某一天我们不用的时候也会删除一些自己信息数据保证安全。 C++中的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置。 4.2.1构造函数和析构函数 对象的初始化和清理也是两个非常重要的安全问题 一个对象或者变量没有初始状态，对其使用后果是未知 同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题 c++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作是编译器强制要我
C#资源释放方法与原理总结
weixin_42546773的博客
03-21 7387
.Net类型分为两大类，一个就是值类型，另一个就是引用类型。 值类型分配在栈上，并不需要GC回收；引用类型分配在堆上，因此它的内存释放和回收需要通过GC来完成。GC的全称为“Garbage Collector”,就是垃圾回收器。 一个引用类型对象所占用的内存需要被GC回收，需要先成为垃圾。那么.Net如何判定一个引用类型对象是垃圾呢，.Net的判断很简单，只要判定此对象或者其包含的子对象没有任何引用是有效的，那么系统就认为它是垃圾。 下图是《C#图解教程中》对GC回收的图解 C#中资源分为两种 【托管资源
C# 03对象的构造和销毁
码猩的博客
04-29 809
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。提示：以下是本篇文章正文内容，下面案例可供参考以上就是今天要讲的内容，本文简单介绍了C#对象的构造的使用，本人也是初学者，可以相互探讨，想相互学习。
GW21C-MAXIn
03-22
GW21C-MAXIn.pdf 介绍了关于GW21C-MAXIn的详细说明，提供工控机的技术资料的下载。
兰利东方CPS-21C恒压供水控制器短信模块
03-21
兰利东方CPS-21C恒压供水控制器短信模块.pdf 介绍了关于兰利东方CPS-21C恒压供水控制器短信模块的详细说明，提供变频器的技术资料的下载。
6-2.Oracle+21c新特性解析.pdf
03-18
6-2.Oracle+21c新特性解析
Oracle Database 21c (oracle-database-ee-21c-1.0-1.ol8.part1.rar)
10-17
Oracle Database 21c 是最新的版本； 21.3 - 企业版（也包括标准版 2） 适用于Linux x86-64位系统。oracle-database-ee-21c-1.0-1.ol8文件分割成 三个 压缩包，必须集齐 三个 文件后才能一起解压一起使用： Oracle ...
兰利东方CPS-21C恒压供水控制器短信模块使用说明书
03-20
介绍了关于兰利东方CPS-21C恒压供水控制器短信模块使用说明书的详细说明，提供运动控制器的技术资料的下载。
C#可删除对象（学习）
lyopenly的博客
12-01 3072
我的第一篇关于技术的博客。以后会一直坚持的。 记录下学到的东西，不然时间长的会忘记。。。 可删除的对象：         创建了对象后，一般来说.net运行程序执行垃圾回收进行清理，这时该实例才被彻底删除。但是在不再使用某个对象后，该资源还是会长时间被对象占用。因此我们不应依赖析构函数来释放对象实例使用的资源。 可使用IDisposable接口，支持IDisposable接口的对象必须实现
为何new出的对象数组必须要用delete[]删除，而普通数组delete和delete[]都一样
u010278318的专栏
04-25 1424
1.在释放堆栈中c++基本数据（包括int，char.....结构体等）的存储空间时，不管是否是数组用delete都不会有错！而且能正常释放所有内存，不会导致内存泄露！  //程序A struct text_data_t { int i; }; int _tmain(int argc, _TCHAR* argv[]) { text_data_t
创建对象，删除对象
weixin_51235620的博客
05-06 526
有两种方法创建对象： 方法一： ClassName object(param); 1 这样就声明了一个ClassName类型的object对象，C++会为它分配足够的存放对象所有成员的存储空间。 注意：为节省存储空间，C++创建对象时仅分配用于保存数据成员的空间，而类中定义的成员函数则被分配到存储空间中的一个公用区域，由该类的所有对象共享。 1 例如，我定义了一个这样的类： class Rec { public: Rec(int width,int height); ~Rec(); //methods in
小欧吃苹果-OPPO 2024届校招正式批笔试题-数据开发（C卷）
最新发布
sigd的博客
07-16 498
小欧吃苹果，拓扑排序处理贪心问题。
oracle21c 监听ORA-12514
09-14
在Oracle 21c中，ORA-12514错误表示...总结：要解决Oracle 21c中的ORA-12514错误，你可以检查监听器是否启动和配置正确，尝试重启监听器和数据库实例，以及检查防火墙和网络配置。希望这些步骤可以帮助你解决问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值