C++学习笔记（十二）

已于 2023-12-18 15:38:47 修改
阅读量875 收藏 19
点赞数 19
分类专栏： C++ 文章标签： c++ 学习 笔记 算法 开发语言
于 2023-12-11 19:10:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zh20001109zh/article/details/134925233
版权

一、对象的初始化和清理

生活中我们买的电子产品都基本会有出厂设置，在某一天我们不用的时候也会删除一些自己信息数据保证安全

C++中的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置

1.1 构造函数和析构函数

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

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

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

C++利用了构造函数和析构函数解决了上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。

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

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

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

构造函数语法：

1. 构造函数，没有返回值也不写void

2. 函数名称与类名相同

3. 构造函数可以有参数，因此可以发生重载

4. 程序在调用对象时候会自动调用构造，无须手动调用，而且只会调用一次

析构函数语法：

1. 析构函数，没有返回值也不写void

2. 函数名称与类名相同，在名称前加上符号~

3. 析构函数不可以有参数，因此不可以发生重载

4. 程序在对象销毁前会自动调用析构，无须手动调用，而且只会调用一次

#include <iostream>

using namespace std;

class Person
{
public:
	// 构造函数
	Person()
	{
		cout << "构造函数已调用......" << endl;
	}
	// 析构函数
	~Person()
	{
		cout << "析构函数已调用......" << endl;
	}
};

void test()
{
	Person p;
}

int main(int argc, char* argv[])
{
	test();
	return 0;
}

1.2 构造函数的分类及调用

两种分类方式：

        按参数分为：有参构造和无参构造

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

三种调用方式：

        括号法

        显示法

        隐式转换法

#include <iostream>

using namespace std;

class Person
{
public:
	// 无参构造函数(普通构造函数)
	Person()
	{
		cout << "无参构造函数已调用......" << endl;
	}
	// 有参构造函数(普通构造函数)
	Person(int p_age)
	{
		age = p_age;
		cout << "有参构造函数已调用......" << endl;
		cout << "年龄:" << age << endl;
	}
	// 拷贝构造函数
	Person(const Person &p)
	{
		age = p.age;
		cout << "拷贝构造函数已调用......" << endl;
		cout << "拷贝的年龄为:" << age << endl;
	}

	// 析构函数
	~Person()
	{
		cout << "析构函数已调用......" << endl;
	}
	int  age;
};

void test1()
{
	// 1. 括号法
	// 调用无参构造函数
	Person p1;
	// 调用有参构造函数
	Person p2(23);
	// 调用拷贝构造函数
	Person p3(p2);
	// 注意事项
	// 调用默认构造函数的时候，不能加(),因为下面这行代码，编译器会认为是一个函数的声明，不会认为在创建对象
	// Person p1();
}

void test2()
{
	// 2. 显示法
	// 调用无参构造函数
	Person p1;
	// 调用有参构造函数
	Person p2 = Person(23);
	// 调用拷贝构造函数
	Person p3 = Person(p2);
	// Person(23);  匿名函数 特点：当前行执行结束后，系统会立即回收掉匿名函数
	// 注意事项
	// 不要利用拷贝构造函数初始化匿名对象，编译器会认为 Person(p6) ===== Person p6;对象声明
	// Person(p6)
}

void test3()
{
	// 3. 隐式转换法
	// 调用无参构造函数
	Person p1;
	// 调用有参构造函数
	Person p2 = 23;
	// 调用拷贝构造函数
	Person p3 = p1;
}

int main(int argc, char* argv[])
{
	test1();
	cout << "------------------------" << endl;
	test2();
	cout << "------------------------" << endl;
	test3();
	cout << "------------------------" << endl;
	return 0;
}

1.3 拷贝构造函数调用时机

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

1. 使用一个已经创建完毕的对象来初始化一个新对象

2. 值传递的方式给函数参数传值

3. 以值方式返回局部对象

#include <iostream>

using namespace std;

class Person
{
public:
	Person()
	{
		cout << "无参构造函数已调用......" << endl;
	}
	Person(int p_age)
	{
		age = p_age;
		cout << "有参构造函数已调用......" << endl;
		cout << "年龄:" << age << endl;
	}
	Person(const Person &p)
	{
		age = p.age;
		cout << "拷贝构造函数已调用......" << endl;
		cout << "拷贝的年龄为:" << age << endl;
	}
	~Person()
	{
		cout << "析构函数已调用......" << endl;
	}
	int  age;
};

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

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

}

void test2()
{
	// 创建一个无参构造函数
	Person p;
	// 实参传递给形参的时候会创建一个拷贝构造函数
	doWork(p);
}

// 3. 值方式返回局部对象
Person doWork2()
{
	// 创建一个无参构造函数
	Person p1;
	// 局部对象以值的方式返回时，会创建一个新的拷贝构造函数
	return p1;
}
void test3()
{
	Person P = doWork2();
}

int main(int argc, char* argv[])
{
	test1();
	cout << "------------------------" << endl;
	test2();
	cout << "------------------------" << endl;
	test3();
	cout << "------------------------" << endl;
	return 0;
}

1.4 构造函数调用规则

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

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

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

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

构造函数调用规则如下：

        如果用户定义有参构造函数，C++不在提供默认无参构造，但是会提供默认拷贝构造

        如果用户定义拷贝构造函数，C++不会再提供其他构造函数

1.5 深拷贝和浅拷贝

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

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

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

#include <iostream>

using namespace std;

class Person
{
public:
	Person(int m_age)
	{
		age = m_age;
		cout << "有参构造函数已调用......" << endl;
	}
	~Person()
	{
		cout << "析构函数已调用......" << endl;
	}
	int age;
};

void test()
{
	Person p1(18);
	cout << "p1的年龄为:" << p1.age << endl;
	Person p2(p1);
	cout << "p2的年龄为:" << p2.age << endl;
}

int main(int argc, char* argv[])
{
	test();
	return 0;
}

利用系统提供的默认拷贝构造函数进行普通的数据拷贝不会报错

但是当手动开辟堆区数据并在析构函数中进行释放时会报错

原因：利用编译器提供的默认拷贝构造函数会做浅拷贝操作，会把p1的成员属性逐字节的拷贝到p2中，p1和p2的指针指向了堆区同一地址的内容，堆栈的数据先进后出，所以p2先进行析构，把指向的堆区内存的内容释放干净，然后p1析构时仍然会对堆区的内容进行释放，暴露出来浅拷贝的问题：堆区的内容重复释放。浅拷贝的问题要利用深拷贝进行解决，再堆区重新申请一块内容用来存放相同的数据，p2指向此内存。

使用系统提供的默认拷贝构造函数（报错）：

#include <iostream>

using namespace std;

class Person
{
public:
	Person(int m_age,int m_height)
	{
		age = m_age;
		height = new int(m_height);
		cout << "有参构造函数已调用......" << endl;
	}
	~Person()
	{
		// 由程序员手动开辟的堆区数据也需要程序员手动释放，在堆区数据销毁前释放
		// 堆区开辟的数据在析构函数执行完后销毁，所以应该析构函数内进行释放
		// 析构代码，将堆区开辟的数据做释放操作
		if (height != NULL)
		{
			delete height;
			height = NULL;
		}
		cout << "析构函数已调用......" << endl;
	}
	int age;
	int* height;
};

void test()
{
	Person p1(18,180);
	cout << "p1的年龄为:" << p1.age << endl;
	cout << "p1的身高为:" << *p1.height << endl;
	Person p2(p1);
	cout << "p2的年龄为:" << p2.age << endl;
	cout << "p2的身高为:" << *p2.height << endl;
}

int main(int argc, char* argv[])
{
	test();
	return 0;
}

使用自己实现的拷贝构造函数：

#include <iostream>

using namespace std;

class Person
{
public:
	Person(int m_age,int m_height)
	{
		age = m_age;
		height = new int(m_height);
		cout << "有参构造函数已调用......" << endl;
	}
	Person(const Person& p)
	{
		cout << "拷贝构造函数已调用......" << endl;
		age = p.age;
		// height = p.height; 编译器默认实现的就是这行代码 
		// 深拷贝操作
		height = new int(*p.height);
	}
	~Person()
	{
		// 由程序员手动开辟的堆区数据也需要程序员手动释放，在堆区数据销毁前释放
		// 堆区开辟的数据在析构函数执行完后销毁，所以应该析构函数内进行释放
		// 析构代码，将堆区开辟的数据做释放操作
		if (height != NULL)
		{
			delete height;
			height = NULL;
		}
		cout << "析构函数已调用......" << endl;
	}
	int age;
	int* height;
};

void test()
{
	Person p1(18,180);
	cout << "p1的年龄为:" << p1.age << endl;
	cout << "p1的身高为:" << *p1.height << endl;
	Person p2(p1);
	cout << "p2的年龄为:" << p2.age << endl;
	cout << "p2的身高为:" << *p2.height << endl;
}

int main(int argc, char* argv[])
{
	test();
	return 0;
}

总结：1. 浅拷贝：编译器提供的等号赋值操作        深拷贝：从堆区重新创建一块内容存放数据

           2. 析构代码的用处：将手动开辟的堆区数据进行释放操作

           3. 拷贝构造函数进行深拷贝可以避免堆区数据重复释放的问题

1.6 初始化列表

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

语法：构造函数():属性1(值1),属性2(值2)......{}

#include <iostream>
#include <string>

using namespace std;

class Person
{
public:
	Person(string m_name,int m_age,int m_height):name(m_name),age(m_age),height(m_height)
	{
		cout << "构造函数已调用......"  << endl;
	}
	~Person()
	{
		cout << "析构函数已调用......" << endl;
	}
	void printInfo()
	{
		cout << "姓名:" << name << endl;
		cout << "年龄:" << age << endl;
		cout << "身高:" << height << endl;
	}
private:
	string name;
	int age;
	int height;
};
int main(int argc, char* argv[])
{
	Person p("张三", 23, 180);
	p.printInfo();
	return 0;
}

1.7 类对象作为类成员

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

构造的顺序是：先调用对象成员的构造，在调用本类的构造

析构的顺序与构造相反

#include <iostream>
#include <string>

using namespace std;

class Phone
{
public:
	Phone(string name):phone_name(name)
	{
		cout << "Phone类的构造函数已调用......" << endl;
	}
	~Phone()
	{
		cout << "Phone类的析构函数已调用......" << endl;
	}
	string phone_name;
};
class Person
{
public:
	// 隐式转换法:phone(phone_name) ======= Phone phone = phone_name
	Person(string name,string phone_name):person_name(name),phone(phone_name)
	{
		cout << "Person类的构造函数已调用......" << endl;
	}
	~Person()
	{
		cout << "Person类的析构函数已调用......" << endl;
	}
	string person_name;
	Phone phone;
};

void test()
{
	Person p("张三", "Iphone 15 pro max远峰蓝");
}

int main(int argc, char* argv[])
{
	test();
	return 0;
}

1.8 静态成员

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

静态成员分为：

        静态成员变量：1. 所有对象共享同一份数据

                                 2. 在编译阶段分配内存

                                 3. 类内声明，类外初始化

        静态成员函数：1. 所有对象共享同一个函数

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

静态成员变量：

#include <iostream>

using namespace std;

class Person
{
public:
	static int age;  // 静态成员变量

private:
	static int height;  // 静态成员变量 
};

// 类内声明,类外初始化
int Person::age = 23;
int Person::height = 180;

void test()
{
	// 所有对象共享同一份数据
	Person p1;
	cout << p1.age << endl;  // 23 
	Person p2;
	p2.age = 10;
	cout << p1.age << endl;  // 10
	
	// 静态成员变量两种访问方式
	// 1. 通过对象
	cout << p1.age << endl;
	// 2. 通过类名
	cout << Person::age << endl;

	// 静态成员变量也有访问权限
	// cout << p1.height << endl; p1.height不可访问
	// cout << Person::height << endl;  Person::height不可访问
}
int main(int argc, char* argv[])
{
	test();
	return 0;
}

静态成员函数：

#include <iostream>

using namespace std;

class Person
{
public:
	static void printInfo()
	{
		cout << "age:" << age << endl;  // 静态成员函数可以访问静态成员变量
		age = 100;
		cout << "age:" << age << endl;
		// cout << "height:" << height << endl;  报错，不可访问
		cout << "printInfo静态成员函数已调用......" << endl;
	}

	static int age;  // 静态成员变量
	int height;  // 非静态成员变量
private:
	static void writeInfo()
	{
		cout << "writeInfo静态成员函数已调用......" << endl;
	}
};

int Person::age = 23;

void test()
{	
	Person p1;
	// 静态成员函数两种访问方式
	// 1. 通过对象
	p1.printInfo();
	// 2. 通过类名
	Person::printInfo();

	// 静态成员函数也有访问权限
	// p1.writeInfo();  不可访问
	// Person::writeInfo();  不可访问
}
int main(int argc, char* argv[])
{
	test();
	return 0;
}

不懂编程的大学生
关注
  • 19
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c++学习笔记
GeekPlusA的博客
09-15 586
c++学习笔记
C++学习笔记
ftm_csdn的博客
04-16 4606
C++是C语言的超集。
黑马程序员C++学习笔记
weixin_46015291的博客
05-31 4711
C++基础入门 1 C++初识 1.1 第一个C++程序 编写一个C++程序总共分为4个步骤 创建项目 创建文件 编写代码 运行程序 1.1.1 创建项目 ​ Visual Studio是我们用来编写C++程序的主要工具，我们先将它打开 1.1.2 创建文件 右键源文件，选择添加->新建项 给C++文件起个名称，然后点击添加即可。 1.1.3 编写代码 #include<iostream> using namespace std; int main() { cout &
z3 C++学习笔记
T_T233333333的博客
03-06 3164
因为项目需要使用z3库来解决问题，所以自己学习了一下，结果发现网上教程比较少，而且大部分都是使用Python，而我本人是C++的忠实信徒，在知道C++也可以使用z3库以后我毫不犹豫地着手用C++使用z3，但是我很快发现，网上基本没有关于C++使用z3的教程（中文社区一点都没有），因此我记录一下我自己的学习过程希望能够帮助到其他学习的人。 教程链接 网上现有的有三个教程： 官方example.cpp文档：https://github.com/Z3Prover/z3/blob/master/examples.
UE C++学习笔记
weixin_44212242的博客
05-16 3118
UE C++入门级程序编制笔记，基础中的基础，了解UE C++的书写规范和一般要求，实现蓝图，C++混合开发。
C++ 学习笔记——十二、探讨 C++ 新标准
BeZer0的学习笔记
03-18 9833
解决这个问题的方法为不删除 tmp 变量，而是转移所有权，该操作称为移动语义（move semantics），这样避免了删除和拷贝原数据。可以定义两个构造函数，一个是常规拷贝构造函数，使用 const 左值引用作为参数，这个引用关联到左值实参，如语句 1 的 vstr；另一个是移动构造函数，使用右值引用作为参数，该引用关联到右值实参，如语句 2 种 allcaps 函数的返回值 tmp。C++ 11 扩大了用大括号括起的列表（初始化列表）的适用范围，使其可用于所有内置类型和用户定义的类型（即类对象）。
c++学习笔记1.1引用
Spalanzani的博客
03-16 1042
c++学习笔记1.1引用c++学习笔记1.1引用引用的概念：引用的声明：参考示例1：指针的引用 c++学习笔记1.1引用 引用的概念： 引用就是某一变量（目标）的一个别名，对引用操作与对变量直接操作完全一样。通俗来说就是该变量的一个外号，称呼不同其他完全一样。 引用的声明： 引用的声明方法如下： 类型标识符 &引用名=目标变量名; 假如有一个变量a，想要给他起一个外号b，我们可以这样声明: int a; //定义一个整型变量a int &b=a; //生命b是a的引用 上面语句声明了b是
C++学习笔记（二十四）：c++ this
qq_16701727的博客
01-05 985
【代码】C++学习笔记（二十四）：c++ this。
C++详细学习笔记（一）
热门推荐
好学的小李的博客
06-09 1万+
首先，本次学习主要参考的书籍是C++Primer Plus第六版，为了方便今后参阅，故写下该学习笔记。 C++是在C语言基础上开发的一种集面向对象编程、泛型编程和过程化编程于一体的编程语言，是C语言的超集。 一、预备知识 C++有三件法宝：1、继承了C语言高效、简洁、快速和可移植性的传统（C代表的过程性编程）；2、面向对象的特性带来了全新的编程方法，这种方法是为了应付复杂程......
明解C++学习笔记
Tanuki的博客
05-05 1310
这本书非常适合初学者学习
C++学习笔记本
05-14
C++学习笔记C++学习笔记C++学习笔记C++学习笔记C++学习笔记
C++学习笔记.pdf
08-12
C++学习笔记
c++学习笔记.pdf
07-12
c++学习笔记.pdf
C语言——函数指针与指针函数
qq_67319052的博客
05-19 627
函数指针与指针函数有什么区别？
C语言简要（四）
m0_74057302的博客
05-21 353
有没有好心师傅教教孩子逆向和pwn啊°꒰๑'ꀾ'๑꒱°
初识C语言——第二十一天
硬件菜鸟的成长之路
05-15 765
1.rand()函数是只能生成伪随机数，并且无返回值，使用前需调用srand()伪随机数生成器作为起点2.time（）函数是结构体函数，返回值是64为整数类型，可以通过time函数生成时间戳时间戳-函数调用的时间点和计算机的初始时间点之间的时间间隔3.void（）函数-无返回值类型函数4.while(1)-一直循环，直到break跳出。
Python教程：使用Python和PyQt编写进制转换器工具
最新发布
复现的博客
05-23 370
在现代计算中，进制转换是一项常见且重要的任务。为了简化这个过程，我们也可以利用Python和PyQt自己写一个直观且易于使用的进制转换器工具。这个工具将支持二进制、八进制、十进制和十六进制的相互转换，并提供良好的用户界面和交互体验。
c语言操作注意事项
dropLin的博客
05-20 216
如果取数据的缓存变量是结构体中的成员，比如。这样操作有可能会造成内存溢出，报硬件中断。主要是用于格式化获取字符串中的数据，来设置1个字节对齐，即不能设置为。这时的结构体类型定义不能加。
零基础c++学习笔记pdf
05-16
《零基础C语言学习笔记》pdf是一份非常好的学习材料。该pdf对C语言进行了系统的介绍，并且从最基础的内容开始进行讲解，适合于零基础的初学者学习。尤其是对于那些没有编程经验的人，该pdf提供了很多实用的示例和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不懂编程的大学生

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值