黑马C++学习总结之对象的初始化和清理

已于 2022-11-01 18:31:30 修改
阅读量125 收藏 2
点赞数
文章标签： c++ 学习 开发语言
于 2022-11-01 13:57:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48615421/article/details/127631933
版权

目录

1.构造函数和析构函数

 2.构造函数的分类和调用

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

 4.构造函数调用规则

 5.深拷贝与浅拷贝

6.初始化列表

7.类对象作为类成员

8.静态成员

1.构造函数和析构函数

       对象的初始化和清理分别利用构造函数和析构函数来进行。如果我们不提供构造和析构函数，编译器会自己提供构造函数和析构函数。

       构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用，其主要特点如下：

  1. 没有返回值，不用写void
  2. 函数名与类名相同
  3. 构造函数可以有参数，可以发生重载
  4. 创建对象的时候，构造函数会自动调用，而且只调用一次

        析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作，其主要特点如下：

  1. 没有返回值，不用写void
  2. 函数名与类名相同，前面加~
  3. 析构函数不可以有参数，不可以发生重载
  4. 对象在销毁前，会自动调用析构函数，而且只调用一次。
#include<iostream>
using namespace std;
class Person
{
public:
	
	//构造函数
	Person()
	{
		cout<<"Person构造函数调用"<<endl;
	}
	
	//析构函数
	~Person()
	{
		cout<<"Person析构函数调用"<<endl;
	}

};

void test01()
{
	Person p1;//此对象在栈上的数据，test01执行完毕后就会释放这个对象
}

int main()
{
	test01();
	Person p2;
	//此对象在 main函数中执行到“systen(”pause“)“就停止了，不会被释放，所以不会进行析构函数的调用
	system("pause");
	return 0;
}

 2.构造函数的分类和调用

 分类：有参构造和无参构造、拷贝构造和普通构造。

 调用：括号法、显示法、隐式转换法。

#include<iostream>
using namespace std;

//构造函数的分类和调用

//分类
//普通构造和拷贝构造函数
//有参构造和无参构造函数


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);//拷贝构造函数调用
	//****调用默认构造函数的时候不要加小括号,"Person p1()"编译器会将这个默认为函数的声明
	
	//2、显示法
	Person p4;
	Person p5 = Person(10);//有参构造调用
	Person p6 = Person(p2);//拷贝构造函数调用
	
	
	Person(10);//不是放在 = 右边，单独使用的话叫匿名对象，相当于匿名有参构造，特点：当前行执行结束后，直接被注销掉
	cout<<"aaaaaa"<<endl;
	//****不要用拷贝构造函数初始化匿名对象，即Person(p3),编译器会默认为Person(p3)==Person p3,编译时会发生重定义错误。

	//隐式转换法
	Person p7 = 10;//相当于写了Person p7 = Person (10),有参构造函数
	Person p8 = p7;//拷贝构造函数
}

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

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

C++拷贝构造函数调用时机：

  1. 使用一个已经创建完毕的对象来初始化一个新对象
  2. 值传递的方式给函数参数传值
  3. 以值方式返回局部对象
#include<iostream>
using namespace std;
//拷贝构造函数调用时机1
//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<<"析构函数的调用"<<endl;
	}
	int m_Age;
};
//1、使用一个已经创建完毕的对象来初始化一个新对象
void test01()
{
	Person p1(20);
	Person p2(p1);
	cout<<"p2的年龄"<<p2.m_Age<<endl;
}

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

//3、值方式返回局部对象
Person doWork2()
{
	Person p1;//p1时局部对象，doWork2（）函数执行完后就会被释放。
	cout<<(int*)&p1<<endl;
	return p1;//局部变量，不是返回p1,重新创建一个新对象，拷贝p1的值。
}
void test03()
{
	Person p = doWork2();//p和p1不是同一个对象
	cout<<(int*)&p<<endl;
	//执行顺序：1、进行p1的创建，默认构造函数
	//2、打印p1的地址，
	//3、进行p的拷贝，拷贝构造函数；
	//4、p1释放，p1的析构函数
	//5、打印p的地址
	//6、p释放，p的析构函数。
}

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


	system("pause");
	return 0;
}

 4.构造函数调用规则

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

  1. 默认构造函数
  2. 默认析构函数
  3. 默认拷贝构造函数，对对象的属性进行值拷贝

调用规则如下：

  1. 如果用户定义有参构造函数，则编译器不再提供默认构造函数，但是会提供默认拷贝构造函数
  2. 如果用户定义拷贝构造函数，编译器不会提供其他构造函数
#include<iostream>
using namespace std;

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

void test01()
{
	Person p(18);
	p.m_Age = 18;
	Person p2(p);
	//如果注释掉默认构造函数和有参构造函数，只写了拷贝构造函数，编译器就不会提供默认构造函数和有参构造函数，此时编译就会发生错误
	cout <<"p2的年龄："<<p2.m_Age<<endl;
}

void test02()
{
	Person p;//如果注释掉默认构造函数，则编译器不会提供默认构造函数，此时编译会发生错误
}


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

 5.深拷贝与浅拷贝

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

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

如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题：重复释放操作。

#include<iostream>
using namespace std;

class Person
{
	public:
	Person()
	{
		cout<<"默认构造函数的调用"<<endl;
	}
	Person(int age,int height)
	{
		cout<<"有参构造函数的调用"<<endl;
		m_Age = age;
		m_Height = new int(height);
		//堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符delete
		//new返回的是该数据类型的指针
	}
	//自己实现拷贝构造函数解决浅拷贝带来的问题
	Person(const Person &p)
	{
		cout<<"拷贝构造函数的调用"<<endl;
		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<<"析构函数的调用"<<endl;
	}
	int m_Age;	
	int *m_Height;
};

void test01()
{
	Person p1(18,160);
	cout<<"p1的年龄："<<p1.m_Age<<"身高为："<<*p1.m_Height<<endl;
	
	Person p2(p1);
	//如果使用编译器提供的拷贝构造函数，会做浅拷贝操作，
	//浅拷贝直接将堆区的指针地址和内容拷贝过来，进行析构的时候会发生堆区内存的重复释放，编译会发生错误
	cout<<"p2的年龄："<<p2.m_Age<<"身高为："<<*p2.m_Height<<endl;
}

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

6.初始化列表

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

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

#include<iostream>
using namespace std;

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)
	{
		
	}
	int m_A;
	int m_B;
	int m_C;
}; 

void test01()
{
	Person p(10,20,30);
	//首先10先传给a，a再传给m_A，m_B和m_C的初始化同理
	cout<<"m_A = "<<p.m_A<<endl;
	cout<<"m_B = "<<p.m_B<<endl;
	cout<<"m_C = "<<p.m_C<<endl;
}

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

7.类对象作为类成员

C++中，类的成员可以是另一个类的对象，成该类成员叫做对象成员。

#include<iostream>
using namespace std;
#include<string>

class Phone
{
	public:
	Phone(string pName)
	{
		m_pName = pName;
		cout<<"phone的构造函数调用"<<endl;
	}
	~Phone()
	{
		cout<<"phone的析构函数调用"<<endl;
	}
	string m_pName;
};
class Person
{
	public:
	//Phone m_phone = pName,隐式转换法
	Person(string name ,string pName):m_Name(name), m_Phone(pName)
	{
		cout<<"person的构造函数调用"<<endl;
	}
	~Person()
	{
		cout<<"Person的析构函数调用"<<endl;
	}
	string m_Name;
	Phone m_Phone;
};

void test01()
{
	Person p("zhangsan","苹果手机");
	cout<<p.m_Name<<"拿着"<<p.m_Phone.m_pName<<endl;
}
//*****当其他类对象作为本类成员时，构造时先构造其他类对象，再构造自身
//*****析构的时候先析构自身，再析构其他类对象。


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

8.静态成员

静态成员变量：

  1. 所有对象共享
  2. 在编译阶段分配内存，程序没有运行之前就已经分配内存了，分配在全局区
  3. 类内声明，类外初始化
#include<iostream>
using namespace std;

class Person
{
	public:
	
	static int m_A;//静态成员变量
	//所有对象共享
	//在编译阶段就分配内存
	//类内声明，类外初始化
	
	private:
	static int m_B;
	//*********静态成员变量也是有访问权限的,类外访问不到私有的静态成员变量
};
int Person::m_A = 100;

void test01()
{
	Person p1;
	cout<<p1.m_A<<endl;
	Person p2;
	p2.m_A = 200;
	cout<<p1.m_A<<endl;
}

void test02()
{
	//静态成员变量不属于某个对象，所有对象都可以用
	//因此静态成员变量有两种访问方式
	//1、通过对象进行访问
	Person p;
	cout<<p.m_A<<endl;
	//2、通过类名进行访问
	cout<<Person::m_A<<endl;
}

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

静态成员函数：

  1. 所有对象共享一个函数
  2. 静态成员函数只能访问静态成员变量
#include<iostream>
using namespace std;

class Person
{
	public:
	static void func()//静态成员函数
	{
		m_A = 100;//静态成员函数可以访问静态成员变量
		/*m_B = 200*///不能调用非静态成员变量,因为其无法区分这是哪个对象的变量m_B。
		cout<<"static void func的调用"<<endl;
		cout<<m_A<<endl;
	}

	static int m_A;
	int m_B;
	
	private:
	static void func1()//私有静态成员函数也是有访问权限的，类外不能访问
	{
		cout<<"static void func1的调用"<<endl;
	}
};

int Person::m_A = 0;

void test01()
{
	//1、通过对象访问
	Person p;
	p.func();
	//2、通过类名访问
	Person::func();
}
int main()
{
	test01();
	
	system("pause");
	return 0;
	
}

 

 

恋心&幻梦
关注
C++黑马程序员学习资料
08-05
C++黑马程序员学习资料，附赠《InterviewGuide第四版By阿秀》、《LeetCode刷题手册》、《背包问题九讲》、《算法图解》pdf版本，三个基础课程文档手册及三个实验项目，由简到繁分别为《通讯录管理系统》、《职工管理...
黑马程序员C++学习资料
12-22
总的来说，"黑马程序员C++学习资料"为初学者提供了一条清晰的学习路径，通过系统的学习和不断的实践，可以帮助学习者快速掌握C++的基础知识，为进一步深入学习和应用C++打下坚实的基础。无论是对想要进入IT行业的...
黑马程序员C++学习笔记
05-08
哔站课程详细笔记，此处更新到STL持续更新
（黑马c++） 个人学习笔记
11-03
"黑马C++学习笔记" 本笔记涵盖了C++编程语言的基础知识点，包括变量、数据类型、运算符、控制结构等。 1. 变量和数据类型 ---------------- ### 1.1 第一个程序输出hello world * 使用`cout`语句输出hello world...
大话C++：第15篇 友元
whccf的博客
10-09 947
友元（Friend）是C++中的一个特殊概念，它允许一个类或函数访问另一个类的私有和保护成员。友元可以是一个函数，也可以是一个类。
数组综合应用（下标计数）C++
hjxxlsx的博客
10-08 966
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
C++文档数据保存与解析
一个大佬的博客
10-12 283
【代码】C++文档数据保存与解析。
【C++力扣】917.仅仅反转字母|387.字符串中第一个唯一字符|415.字符串相加
白乐天_ξ( ✿＞◡❛)的博客
10-06 668
本文写的是力扣三道题的解答：917、387、415题，都是与string字符串有关的！
C++ | Leetcode C++题解之第463题岛屿的周长
Ddddddd_158的博客
10-08 545
C++ | Leetcode C++题解之第463题岛屿的周长
贪心算法c++
hjxxlsx的博客
10-07 2718
贪心选择性质活动安排问题问题描述选择。
【C语言】关于指针各项细节以及与其他知识点关联
酷酷的伟的博客
10-08 1424
通过对指针及其相关知识点的全面总结，我们可以看到，指针在C语言中的地位举足轻重，不仅用于操作变量和数组，还涉及内存管理、函数调用、文件操作等多个方面。尽管指针强大，但其复杂性也要求开发者深入理解每一个概念，注意细节，避免常见错误。
C++的STL标准模版库容器--list类
2401_82376751的博客
10-06 1040
较为详细得讲述容器list类的各项功能与实现
【STL】stack模拟实现
gaogo
10-07 235
用deque实现stack的模拟实现
每日OJ题_牛客_重排字符串_贪心_C++_Java
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
10-06 346
每日OJ题_牛客_重排字符串_贪心_C++_Java（力扣有⼀道《距离相等的条形码》和这道题差不多）
c++：模板
weixin_67645591的博客
10-12 637
class 类模板名// 类内成员定义// 动态顺序表// 注意：Vector不是具体的类，是编译器根据被实例化的类型生成具体类的模具public:, _size(0){}// 使用析构函数演示：在类中声明，在类外定义。~Vector();// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表需要区分一下类模板的实例化部分，什么是类型，什么是类名。蟹蟹观看！关注！评论！一键三连！
80.【C语言】数据结构之时间复杂度
最新发布
2401_85828611的博客
10-12 683
参见63.【C语言】再议结构体(上)也可以理解为数据在内存中的存储形式(管理数据)比如说写通讯录可以用静态数组,动态数组和链表形式存储简单的定义:一系列的计算步骤，用来将输入数据转化成输出结果若次数为常数,时间复杂度为若次数为N的表达式1.取最高阶的式子(去常数) 2.去掉最高阶式子前的系数若存在最好,最坏情况,取最坏的情况作为时间复杂度。
【C语言】深入理解指针（二）（中）
hefaxiang的博客
10-12 265
本篇博客将讲解以下知识：1、使用指针访问数组2、冒泡排序3、二级指针。
C++（运算符重载）
2301_77143270的博客
10-08 766
类实现了数据的隐藏与封装，类的数据成员一般定义为私有成员，仅能通过类的成员函数才能读写。成员函数运算符重载与友元函数运算符重载的最大区别是：友元函数运算符重载的第一个参数，在成员函数中使用this指针代替，即使用成员函数重载的运算符相比友元函数的参数少一个。例如，类B的某个成员函数称为了类A的友元成员函数，这样类B的该成员函数就可以访问类A的所有成员了。赋值运算符：=、+=、-=、*=、/=、%=、&=、|=、^=、<<=、>>=如果类C是类B的友元类，类B是类A的友元类，类C不一定是类A的友元类。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值