类与对象（2）

to Keep

已于 2023-11-11 17:09:16 修改

阅读量171

点赞数 7

分类专栏： C++学习文章标签： c++ 开发语言 vscode 笔记

于 2023-11-11 09:38:06 首次发布

本文链接：https://blog.csdn.net/qq_57107826/article/details/134168616

版权

C++学习专栏收录该内容

11 篇文章 0 订阅

订阅专栏

✨前言✨

📘 博客主页：to Keep博客主页
🙆欢迎关注，👍点赞，📝留言评论
⏳首发时间：2023年11月11日
📨 博主码云地址：博主码云地址
📕参考书籍：《C++ Primer》《C++编程规范》
📢编程练习：牛客网+力扣网
由于博主目前也是处于一个学习的状态，如有讲的不对的地方，请一定联系我予以改正！！！

类中的六个默认成员函数
在这里插入图片描述

构造函数

构造函数的作用：在创建对象时，同时帮助我们给对象一个初始值，并不是给对象开辟空间

构造函数的定义如下：
1️⃣ 函数名与类名一样
2️⃣ 构造函数是不带返回值的
3️⃣ 构造函数支持重载
4️⃣ 对象进行实例化时，编译器会自动调用构造函数

让我们来看一看以下这段代码，来看一下如何使用构造函数：

class Date {
private:
	int _year;
	int _month;
	int _day;

public:
	Date() {
		_year = 2023;
		_month = 11;
		_day = 2;
	}
	Date(int year, int month, int day) {
		_year = year;
		_month = month;
		_day = day;
	}
	void print()
	{
		cout << _year << _month << _day << endl;
	}
};

int main()
{
	Date d1();//编译器会当做是函数的声明，是要去调用函数
	Date d2;//调用Date类的不带参数构造函数
	d2.print();

	Date d3(2024, 11, 2);//调用有参数的构造函数
	d3.print();
	return 0;
}

如果自己不写构造函数，编译器也是会生成默认不带参数的构造函数！默认的构造函数有什么作用呢，让我们来看下面这段代码来进一步的理解：

class people {
private:
	int _age;
	double _height;
	double _weight;

public:
	people() {
		_age = 1;
		_height = 1;
		_weight = 1;
	}

};
class Date {
private:
	int _year;
	int _month;
	int _day;

	people p;

public:

	void print()
	{
		cout << _year<<" " << _month<<" "<< _day << endl;
	}
};

int main()
{
	Date d1();//编译器会当做是函数的声明，是要去调用函数
	Date d2;//调用Date类的默认构造
	d2.print();
}

在这里插入图片描述
我们可以发现，在d2这个对象中_year等是一个随机值，对于people这个类型的变量p是可以进行初始化的！事实上，在C++中，int/char/指针…等，也就是对于哪些可以直接拿来用的类型我们称为内置类型，像利用union/struct/class等关键字定义的类型，我们称为自定义类型。对于内置类型，构造函数是不进行处理的，对于自定义类型，是会去调用这个类型的默认构造！

编译器默认生成的无参构造函数，用户自己写的不带参数的默认构造函数，以及全缺省的构造函数我们都称之为默认的构造函数，而且一旦我们自己显式的写了构造函数，编译器就不会在生成构造函数了！

在C++11中，打了一个补丁，可以针对内置成员变量给定一个缺省值！注意此时成员变量仍然是一个定义，并没有因为给定这个缺省值就初始化了一个空间！

析构函数

与构造函数功能相反，析构函数的作用就是对象销毁时，自动调用析构函数，从而完成对象中的资源清理工作！
语法格式如下：

1️⃣ 也是与类名相同的函数，函数名前面要加上~
2️⃣ 析构函数同样也是无参数也无返回值
3️⃣ 析构函数不能构成重载,一个类中只可以有一个析构函数，若用户显式写出，编译器就不在生成
4️⃣ 析构函数会在对象生命周期结束后，自动调用！
结合下列代码：

#include <iostream>
using namespace std;

class Date {
private:
	int _year;
	int _month;
	int _day;
public:
	Date()
	{
		_year = 2023;
		_month = 11;
		_day = 2;
	}
	//析构函数
	~Date()
	{
		cout << "Date()" << endl;
	}

	void print()
	{
		cout << _year << " " << _month << " " << _day << endl;
	}
};

class Stack {
	int* _x;
	int _top;
	int _capacity;
public:
	Stack(int capacity = 3) 
	{
		_x = (int*)malloc(sizeof(int) * capacity);
		if (_x == nullptr)
		{
			cout << "申请空间失败" << endl;
			return;
		}
		_capacity = capacity;
		_top = 0;
	}
	void print()
	{
		cout << _top << " " << _capacity << endl;
	}
	~Stack()
	{
		free(_x);
		_top = _capacity = 0;
		_x = nullptr;
	}
};
int main()
{
	Date d1;
	Stack st1;
	return 0;
}

析构函数类似于构造函数，对于内置类型，是不做处理的，对于自定义类型，是会去调用它的析构函数进行处理！对于我们之前所学的栈，一般就需要我们自己写析构函数，因为栈需要向系统申请资源开辟空间！这时我们需要利用析构函数，将这块资源进行清理，防止资源泄露！Date类可以使用默认的析构函数，Date类中全是内置类型，没有向系统申请空间！
图解如下：
在这里插入图片描述

拷贝构造

在C语言学习结构体中，我们知道，是可以传值传参的。在C++中，那么对于自定义类型进行传值传参会发生什么呢？

class Date {
private:
	int _year;
	int _month;
	int _day;
public:
	Date()
	{
		_year = 2023;
		_month = 11;
		_day = 2;
	}
	//析构函数
	~Date()
	{
		cout << "Date()" << endl;
	}

	void print()
	{
		cout << _year << " " << _month << " " << _day << endl;
	}
};

class Stack {
	int* _x;
	int _top;
	int _capacity;
public:
	Stack(int capacity = 3) 
	{
		_x = (int*)malloc(sizeof(int) * capacity);
		if (_x == nullptr)
		{
			cout << "申请空间失败" << endl;
			return;
		}
		_capacity = capacity;
		_top = 0;
	}
	~Stack()
	{
		free(_x);
		_top = _capacity = 0;
		_x = nullptr;
	}
};
void func(Date a)
{
	a.print();
}
void func1(Stack st1)
{
	
}
int main()
{
	Date x;
	func(x);

	Stack st;
	func1(st);
	return 0;
}

运行代码，我们可以发现会报错！这是为什么呢？这是因为在进行传值传参的过程中，我们进行的只是值拷贝（浅拷贝），而在清理对象资源的时候，会自动调用析构函数，而对于Stack这样的类，同一块空间是会被释放两次！
上述代码图解过程：
st和st1所指的空间被析构了两次
在C++中，为了解决上述问题，规定，自定义类型在传值传参必须先调用拷贝构造函数！

拷贝构造函数的特点：
1️⃣ 无参数无返回值，函数名与类名相同，与构造函数构成重载
2️⃣ 函数的参数只有一个，是类类型的引用，不可以使用传值方式

在这里需要特别说明一下为什么拷贝构造函数不可以使用传值方式！先假设拷贝构造是传值传参的，调用函数进行传值传参需要先调用拷贝构造，而拷贝构造又是传值传参，又需要接着调拷贝构造……就这样套娃下去，形成一个无限递归！
改进代码如下：

//拷贝构造
Stack(const Stack& t)
{
	_x = (int*)malloc(sizeof(int) * t._capacity);
	if (_x == nullptr)
	{
		perror("malloc fail");
	}
	_capacity = t._capacity;
	_top = t._top;
	memcpy(_x, t._x,sizeof(int)*t._capacity);
}

只需要在Stack类中重新写构造函数，实现对资源的拷贝，这样就不会存在对一块空间释放两次的问题！

其实对于Date这样的类，就算我们使用默认生成的拷贝构造，也是可以的，因为Date类中没有向系统申请资源！而对于Stack这样的类就必须我们自己实现，因为它向系统申请开辟了空间，我们需要拷贝这块空间的内容！同时，为了防止拷贝过程中，改变引用中的内容，我们通常会加上const修饰！

class myqueue
{
	Stack _pushs;
	Stack _pops;
	int _size;
};
int main()
{
	myqueue q1;
	myqueue q2(q1);
	return 0;
}

在上面的代码基础上，我们定义一个myqueue类，通过打断点按F11可以发现：拷贝构造对于自定义类型会去调用它的拷贝构造，对于内置类型会完成值拷贝！
学习了拷贝构造，我们可以来看以下这段代码，再来理解一下引用的用途：

Date test()
{
	Date x;
	x.print();
	return x;
}
int main()
{
	return 0;
}

你觉得返回的是x还是x拷贝的临时对象呢？实际上，x出了test函数就会销毁，所以只可以返回x的拷贝！如果我们写出如下的代码：

Date& test()
{
	static Date x;
	x.print();
	return x;
}
int main()
{
	return 0;
}

此时，由于x出了作用域还没有销毁！所以我们可以通过传引用返回！这样会减少拷贝对象的时间，是不是会大大提高效率呢？

赋值运算符重载

我们知道，内置类型的比较是可以直接用符号来进行比较的！C++为了增强代码的可读性引入了运算符重载的！运算符重载是具有特殊函数名的函数！

函数名字：operator 后面接需要重载的运算符符号()

下面来展示一段代码：

class Date {
public:
	int _year;
	int _month;
	int _day;
public:
	Date()
	{
		_year = 2023;
		_month = 11;
		_day = 2;
	}
	void print()
	{
		cout << _year << " " << _month << " " << _day << endl;
	}
};


bool operator==(Date& x,Date& y)
{
	return x._year == y._year
		&& x._month == y._month
		&& x._day == y._day;
}

int main()
{
	Date d1;
	Date d2;

	cout << (d1==d2) << endl;
	return 0;
}

为了便于理解，我们暂时先将类的成员改为public，我们通过operator关键字重载==符号，这样我们就可以像内置类型一样，通过符号来判断是否相等! 在C++中，对于运算符重载，我们一般是放入类中处理，但是传参就要少一个了，因为有一个隐藏的this指针！具体代码可以参考下面：

	bool operator==( Date& y)
	{
		return _year == y._year
			&& _month == y._month
			&& _day == y._day;
	}

此外我们在介绍两个特殊的运算符重载：

	//前置++运算符重载
	Date& operator++()
	{
		*this += 1;
		return *this;
	}
	//后置++运算符重载
	Date operator++(int)
	{
		Date tmp(*this);
		*this += 1;
		return tmp;
	}

对于后置++运算符，我们通过给定一个整型来表示这是后置++（注意这个是语法规定）
编译器自己会根据我们所写的符号去调用相应的运算符重载函数（这个是需要我们自己写的）！编译器默认生成的成员函数是赋值运算符的重载，也就是说我们自己不写，也是会自动生成的！

	//赋值赋值运算符重载
	Date& operator=(const Date& y) //返回值的目的是为了进行连续赋值，引用可以提高返回的效率
	{
		//防止自己和自己赋值
		if (this != &y)
		{
			_year = y._year;
			_month = y._month;
			_day = y._day;
		}
		return *this;
	}

和拷贝构造的作用一样，对于内置类型会进行值拷贝（浅拷贝），自定义类型调用它的赋值重载运算符！但是对于Stack这样的类，向系统申请了额外资源的需要我们自己重写赋值重载实现深拷贝！
拷贝构造与赋值拷贝之间的区别
拷贝构造是针对还没有进行创建的对象，而赋值拷贝要求两边都是已经创建好了的对象进行赋值拷贝！代码如下：

int main()
{
	Date d1(2023,11,11);
	//下面都属于调用拷贝构造进行拷贝
	Date d2(d1);
	Date d3 = d2;
	//下面属于赋值拷贝
	d1 = d2;
	return 0;
}

对于运算符重载需要注意事项：
1️⃣ 对于内置类型运算符的含义不可以改变。例如：不能重载+符号，里面写成了-的含义了
2️⃣ 不可以通过连接其他符号创建新的操作符。例如：opertor@
3️⃣ 重载操作符必须要有一个类类型的参数
4️⃣ 作为类的成员函数重载时，其形参看起来比操作数数目少1，因为成员函数第一个参数是隐藏的this指针
5️⃣.* ::(域限定符) sizeof ?:(三目操作符) .这五个运算符是不可以运算符重载的！

const成员函数

被const修饰的成员函数被称为const成员函数！

	//大于重载
	bool operator>(Date& t)const //在函数参数后面加上const修饰
	{
		if (_year > t._year)
		{
			return true;
		}
		else if (_year == t._year && _month > t._month) {
			return true;
		}
		else if (_year == t._year && _month == t._month && _day == t._day)
		{
			return true;
		}
		return false;
	}

实际上const修饰的是隐藏的this指针，变成了const Date类型，表明在该成员函数中不能对类的任何成员修改！还需要注意的是当自定义类型的声明与定义分离时，我们如果要用const进行修饰，那么就要声明和定义一起加上！

当我们定义const对象和非const对象时，调用>重载运算符如图所示！这是为啥呢？原因就是d1是const Date类型对象，传入>重载运算符时第二个参数是Date*类型！可以理解为权限放大，这样是不允许的！权限只可以平移和缩小！

取地址操作符重载

最后两个默认的成员函数是取地址操作符的重载

	Date* operator&()
	{
		return this;
	}

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

一般这两个默认的成员函数不需要我们自己进行重载，直接拿来用就可以了！如果我们想要让别人获取指定的内容可以使用！

//让你只可以拿到地址为0x11223344的内容
Date* operator&()
{
	return (Date*)0x11223344;
}

const Date* operator&()const
{
	return (const Date*)0x11223344;
}

to Keep

关注

7
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
1
评论
类与对象（2）

类的六个默认成员函数
复制链接

扫一扫

专栏目录