C++类和对象（中）

最新推荐文章于 2024-05-20 23:52:50 发布
最新推荐文章于 2024-05-20 23:52:50 发布
阅读量224 收藏 2
点赞数 3
分类专栏： c++ 文章标签： c++ 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cccyi7/article/details/132134432
版权

⭐️ 往期相关文章

✨ 链接1：C++类和对象（上）
✨ 链接2：C++基础知识 （命名空间、输入输出、函数的缺省参数、函数重载）
✨ 链接3：C++基础知识 （引用）
✨ 链接4：C++基础知识（inline、auto、nullptr）

⭐️ 类和对象（下）

🌟 类的6个默认成员函数

如果一个类中什么成员都没有，简称空类。当类中什么都不写的时候，编译器会自动生成6个默认成员函数。

  • 初始化和清理
    • 构造函数： 主要完成类的初始化工作
    • 析构函数： 主要完成类的清理工作
  • 拷贝复制
    • 拷贝构造： 是使用同类对象以初始化的方式创建对象
    • 赋值重载： 把一个对象赋值给另一个对象
  • 取地址重载
    • 主要是普通对象和 const 对象取地址

🌟 构造函数

构造函数是一个特殊的成员函数，名字与类名相同，创建类的时候编译器会自动调用类的构造函数，来做类的初始化操作，在对象整个生命周期内只会调用一次。

构造函数的特征：

  • 函数名与类名相同
  • 无返回值
  • 对象实例化时编译器自动调用对应的构造函数
  • 构造函数可以重载
  • 如果类中没有显示定义构造函数，则编译器会自动生成一个无参的默认构造函数，一旦显示定义编译器将不在生成。

example1：

#include <iostream>
using namespace std;

class Date {
public:
	// 无参的构造函数
	Date() {
		cout << "Date()" << endl;
	}

	// 带参的构造函数
	Date(int year , int month , int day) {
		cout << "Date(int year , int month , int day)" << endl;
		this->_year = year;
		this->_month = month;
		this->_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main() {

	Date d1; // 调用无参的构造函数
	Date d2(2023 , 8 , 6);	// 调用带参的构造函数

	return 0;
}

example2：

class Date {
//public:
//	Date(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
private:
	int _year;
	int _month;
	int _day;
};

int main() {

	Date d1; // 调用编译器自动生成的默认构造函数

	return 0;
}

ps： 如果当创建类的时候没有合适的默认构造函数会报错。

在C++中把类型分为内置类型和自定义类型，内置类型就是语言本身自带的类型，如：int、double、char等等。自定义类型就是 class、struct、union等等。默认构造函数并不会对内置类型进行处理，比如用日期类来举例：_year、_month、_day 依然是随机值，但是默认的构造函数会对自定义类型的成员处理并调用它们的默认构造函数。

example3：

class Time
{
public:
	Time()
	{
		cout << "Time()" << endl;
		_hour = 0;
		_minute = 0;
		_second = 0;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
private:
	// 基本类型(内置类型)
	int _year;
	int _month;
	int _day;
	// 自定义类型
	Time _t;
};
int main()
{
	Date d;
	return 0;
}

在这里插入图片描述
这是C++当中比较不好理解的一个点，因为默认的构造函数只会处理自定义类型而不会处理内置类型，所以在C++11中，针对内置类型成员不初识化的缺陷给出了解决方案。内置类型成员变量在类中声明时可以给默认值。

example4：

class Date {
private:
	 int _year = 1970;
	 int _month = 1;
	 int _day = 1;
};

ps： 这里的 = 并不是初始化值的意思，而是声明。这样当调用构造函数的时候如果在构造函数中初始化则会使用构造函数的初始化的结果，若没有则使用当前的默认值。总结一句话就是这样的操作也可以为内置类型初始化了。

默认构造函数的含义： 无参的构造函数 和 全缺省的构造函数 还有 没写编译器自动生成的构造函数 都称为默认构造函数，并且默认构造函数只能有一个。

🌟 析构函数

析构函数与构造函数的功能相反，析构函数不是完成对象本身的销毁，这些是由生命周期结束时编译器做的。而在对象销毁时会自动调用析构函数，完成对象当中资源的清理工作。 比如类中的成员有动态开辟的内存，当类销毁时使用析构函数释放内存还给操作系统。

析构函数的特征：

  • 析构函数名是在类名前加上 ~
  • 无参数无返回值类型
  • 一个类只能有一个析构函数，若没有定义，系统会自动生成默认的析构函数。析构函数不能重载
  • 当对象生命周期结束时，编译器会自动调用析构函数。

example5：

#include <iostream>
using namespace std;

class Date {
public:
	// 无参的构造函数
	Date () {
		cout << "Date" << endl;
	}
	// 析构函数
	~Date() {
		cout << "~Date()" << endl;
	}
private:
	int _year = 2023;
	int _month = 8;
	int _day = 6;
};
int main()
{
	Date d;

	return 0;
}

在这里插入图片描述
编译器自动生成的析构函数会做什么事情呢？
构造函数和析构函数都是只对自定义类型处理。内置类型的成员，销毁时不需要资源的清理，最后系统直接回收即可。对于自定义类型，当前类的默认析构函数会调用这个自定义类型的析构函数来销毁。

🌟 构造函数和析构函数的顺序

example6：

#include <iostream>
using namespace std;

class Test {
public:
	Test(int order) {
		_order = order;
		cout << _order << " Date" << endl;
	}
	~Test() {
		cout << _order <<  " ~Date()" << endl;
	}
private:
	int _order;
};

Test t1(1);
/*
	构造顺序：1 2 3 4 5
	析构顺序：3 2 5 4 1
*/
int main() {

	Test t2(2);
	Test t3(3);

	static Test t4(4);
	static Test t5(5);

	return 0;
}

在这里插入图片描述

ps： 构造函数的顺序比较简单，因为在对象实例化时就会调用构造函数完成初始化。所以是从上往下依次构造。而析构函数在是对象的生命周期结束的时候调用，这里可以用栈来理解，先创建的就先压栈，所以析构的时候是先析构栈顶的对象，所以这里是创建的早就析构的晚，创建的晚就析构的早，而 static 在静态区中所以当出了 main 函数作用域中，局部对象优先被析构，其次是 static 对象再是全局对象（栈帧和栈里面的对象都要符合后进先出，也就是后定义先析构）。

🌟 拷贝构造函数

拷贝构造的含义是：使用已经存在的类对象创建新对象时编译器会自动调用类的拷贝构造。

拷贝构造函数的特征：

  • 拷贝构造函数是构造函数的一个重载形式
  • 拷贝构造函数的参数只有一个且必须是当前类的类对象的引用，使用传值方式编译器会直接报错，因为这样会引发无穷的递归调用。
    • ps： 因为如果是传值调用，那么当前类对象会拷贝一份给形参，这里又会调用形参的拷贝构造函数。而拷贝构造函数又要先传参，传参就调用拷贝构造，所以就引发了无穷的递归调用。

example7：

#include <iostream>
using namespace std;

class Date {
public:
    Date(int year = 1, int month = 1, int day = 1) {
        _year = year;
        _month = month;
        _day = day;
    }

    // 最好使用 const 修饰
    Date(const Date& d) {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
private:
    int _year;
    int _month;
    int _day;
};

int main() {

    Date d1;
    // 拷贝构造
    Date d2(d1);
    // 拷贝构造
    Date d3 = d2;

    return 0;
}
  • 若未显示定义，编译器会自动生成默认的拷贝构造函数。默认的拷贝构造函数按内存的字节完成拷贝，这种拷贝叫做浅拷贝。默认拷贝函数会对内置类型和自定义类型都会处理，内置类型是按字节方式直接拷贝的，自定义类型是调用其拷贝构造函数完成拷贝的。
    • ps： 当成员中有指向动态开辟内存的指针，如果使用浅拷贝，那么两个指针将会指向同一块内存空间，当修改其中一个指针里的数据时，另一个指针里数据也会被影响。当对象声明周期结束用析构函数的时候，会造成 free 两次的情况导致运行崩溃。

拷贝构造函数的调用场景：

  • 使用已存在对象创建新对象
  • 当用对象当作函数实参传递（实参赋值给形参）
  • 函数返回值为类类型对象（函数栈帧销毁会使用临时变量来存放返回值，所以这里造成一次拷贝构造）

🌟 运算符重载

运算符重载是为了让一些自定义类型也可以使用运算符，有较强的可读性。
语法：返回值 operator操作符(参数列表)
特性：

  • 不能使用不存在的操作符
  • 重载操作符必须有一个类类型参数
  • 不能改变操作符的含义
  • 作为类成员函数重载的时候，形参看起来比操作数少1，因为成员函数中第一个参数为隐藏的 this
  • .* 、::、sizeof、?: 、. 以上操作符不能重载

ps： 前置++和后置++运算符重载区分方法，带一个形参 int 的为后置++。前置++和后置++是运算符重载，而这两个运算符重载函数又构成了函数重载。

  • 前置++ type operator++();
  • 后置++ type operator++(int);

🌟 赋值运算符重载

将一个对象赋值给另一个对象时，就需要赋值重载。

  • 参数：const Type& 传递引用可以减少拷贝构造提升效率
  • 返回值：Type& 返回引用也可以减少拷贝构造的次数，而且有返回值可以支持连续赋值

example8：

#include <iostream>
using namespace std;

class Date1 {
public:
	// 构造函数
	Date1(int year = 2023 , int month = 8 , int day = 12) {
		_year = year;
		_month = month;
		_day = day;
	}

	// 赋值拷贝
	Date1& operator=(const Date1& d) {
		// 若当前两个对象地址不同则赋值
		if (this != &d) {
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}

		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main() {

	Date1 d1;
	Date1 d2(2024 , 8 , 12);
	
	// 赋值重载
	d1 = d2;

	return 0;
}

ps： 赋值运算符只能重载成类的成员函数不能重载成全局函数，因为赋值运算符如果不显示实现，编译器会生成一个默认的，如果在类外实现一个全局的运算符重载，就会和编译器默认生成的赋值重载冲突。
若用户没有显示定义，编译器会生成一个默认的赋值运算符重载，是以浅拷贝的方式拷贝。内置类型是直接按照逐字节的拷贝方式，而自定义类型会调用对应类的赋值运算符的重载完成赋值。

🌟 const

将 const 修饰的成员函数叫做 const 成员函数，const 修饰类成员函数，实际是修饰该成员函数的 this 指针，意思是 this 指向的内容不能被修改。

example9：

class Date {
public:
	Date(int year, int month, int day) {
		_year = year;
		_month = month;
		_day = day;
	}
	void Print() const {
		cout << "year:" << _year << endl;
		cout << "month:" << _month << endl;
		cout << "day:" << _day << endl << endl;
	}
private:
	int _year; 
	int _month; 
	int _day; 
};

int main() {

	Date d1(2022, 1, 13);
	d1.Print();
	const Date d2(2022, 1, 13);
	d2.Print();

	return 0;
}

ps： 由于 d2 是 const 修饰的对象，当 d2.Print() 实际上是 d2.Print(&d2)，第一个参数会有一个隐含的 this 指针，而this 指针的类型是 Date * const this，所以一个 const 的地址传给非 const 修饰的指针时，这是权限的放大所以会 error，解决办法是在成员函数后加上 const 修饰。这里实际上是 const Date * const this 。

🌟 取地址及const取地址操作符重载

example10：

class Date {
public:
	Date* operator&() {
		return this;
	}
	const Date* operator&()const {
		return this;
	}
};

ps： 这两个运算符重载函数构成函数重载，这两个函数都要存在才可以，因为如果没有 const 修饰的取地址重载，虽然普通对象和 const 对象都可以接收，但是当返回的时候就有问题了，如果接收返回值的是普通对象，那你返回一个 const 的地址这里造成了权限的放大 error，所以这里针对 const 和非 const 要采取两种不同的方式。
但是这两个函数一般情况不用自己定义，编译器会自动生成。

cccyi7
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
c++ 类和对象总结
01-20
类（class）：就是对象的类型，代表了某一批对象的共同特性和特征。类是对象的抽象，而对象是类的具体实例。 2.1 类的引入 在C语言中我们定义一个结构体是这样定义的： struct Student { int _age; char* _...
C++类和对象.ppt
11-13
C++类和对象.ppt
C++ 类和对象基础篇
08-25
类是创建对象的模板，一个类可以创建多个对象，每个对象都是类类型的一个变量；创建对象的过程也叫类的实例化。每个对象都是类的一个具体实例（Instance），拥有类的成员变量和成员函数
C++类和对象，思维导图
04-24
C++类和对象，会跟着文章更新而更新
C语言.动态内存管理
Joseit的博客
05-16 587
栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS(操作系统)回收。分配方式类似于链表。数据段（静态区）：（static）存放全局变量、静态数据。程序结束后由系统释放。
c语言操作注意事项
dropLin的博客
05-20 111
如果取数据的缓存变量是结构体中的成员，比如。这样操作有可能会造成内存溢出，报硬件中断。主要是用于格式化获取字符串中的数据，来设置1个字节对齐，即不能设置为。这时的结构体类型定义不能加。
C/C++免杀--原生态(GG)
最新发布
金灰的博客
05-20 174
看个热闹吧... metasploit payload运行原理浅析(sockedi调用约定是什么) lib/msf/core/payload/windows/reverse_tcp.rb: metasploit-framework/lib/msf/core/payload/windows/reverse_tcp.rb at master · rapid7/metasploit-framework · GitHub 原生态: MSF: #include <Windows
C语言之函数指针（持续更新）
qq_47607743的博客
05-20 252
C语言指针
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 895
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
C语言如何在链表中的指定位置插⼊结点？
PAP
05-15 261
C语言如何在链表中的指定位置插⼊结点？
【C语言深度解剖】(14)：结构体内存对齐（详细配图讲解）
更新C/C++，数据结构与算法，计算机视觉，深度学习，目标检测
05-20 411
一篇文章带你学会结构体的内存对齐！！超多精美配图！
c++04STL部分复习
2301_80434259的博客
05-13 183
c++基础回复
C语言星号带括号的情形
bcbobo21cn的专栏
05-11 81
C语言星号，当星号右侧是一个指针变量，星号和指针变量可看作一个整体，表示的是指针变量所指的内容；
STL--set和multiset集合
m0_75266675的博客
05-20 634
STL--set和multiset集合
C++ 复习 -- 构造和析构
mx_jun的博客
05-14 889
类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。构造的是什么呢？构造成员变量的初始化值，内存空间等构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。
c++ STL 之排序——sort、partial sort、stable sort、merge 详解
zhhg0123的博客
05-16 566
为什么一个讲 sort 的文章还要有一个篇章就叫 sort 呢？难道还有不叫 sort 的排序吗？yes！sort 其实并不完全是用的是快速排序排集合了堆排序和插入排序。sort 会根据不同的数量级别以及不同情况，能自动选用合适的排序方法。一般快速排序一旦分段后的数据量小于某个阀值，为避免递归调用带来过大的额外负荷，便会改用插入排序。而如果递归层次过深，有出现最坏情况的倾向，还会改用堆排序。所以无论元素初始时为何种状态，sort()的平均排序复杂度为均为，具有不错的的性能。
C--贪吃蛇
wangshishiwang的博客
05-16 2047
贪吃蛇小游戏是一个有趣的小游戏,也让我学到了很多,希望大家多多支持!!!
C语言 8 函数递归
xn2005的博客
05-13 1029
1.递归是什么？递归是学习C语⾔函数绕不开的⼀个话题，那什么是递归呢？递归其实是⼀种解决问题的⽅法，在C语⾔中，递归就是函数⾃⼰调⽤⾃⼰。上述就是⼀个简单的递归程序，只不过上⾯的递归只是为了演⽰递归的基本形式，不是为了解决问题，代码最终也会陷⼊死递归，导致栈溢出（Stack overflow）。1.1递归的思想：把⼀个⼤型复杂问题层层转化为⼀个与原问题相似，但规模较⼩的⼦问题来求解；直到⼦问题不能再被拆分，递归就结束了。所以递归的思考⽅式就是把⼤事化⼩的过程。
C/C++常用错误 or 规范注意
xuexiwd的博客
05-20 84
之前做过关于python报错集（未来如果出现一些有意义的错误还是会继续更新的），今天记录一下C/C++的一些常见错误（可能其实不算error，只是根据规范，尽量提升代码质量）
c++类和对象
05-29
C++中，类是一种用户自定义的数据类型，它封装了数据和操作数据的函数。对象是类的一个实例，可以使用类中定义的函数来访问和修改对象的数据。...希望这个简单的示例可以帮助你更好地理解C++中的类和对象。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值