C++类与对象基础(6)

最新推荐文章于 2024-07-21 11:20:00 发布

起床写代码啦！

最新推荐文章于 2024-07-21 11:20:00 发布

阅读量980

点赞数 30

分类专栏： C++ 文章标签： c++ 算法开发语言

本文链接：https://blog.csdn.net/2301_76836325/article/details/135461364

版权

C++ 专栏收录该内容

21 篇文章 2 订阅

订阅专栏

(注：本篇文章介绍部分内容时，需要用到上盘文章中日期类的代码，文章链接如下：C++类与对象基础(5)——日期类的实现-CSDN博客）

1. 运算符重载的相关补充：

1.1流运算符重载出现的问题：

1.2 针对上述问题的解决方法：

1.2.1 通过创建友元函数来实现对私有变量的访问：

1. 运算符重载的相关补充：

1.1流运算符重载出现的问题：

在对对象进行打印时，一般会在类中编写一个用于打印的成员函数用于打印，即：

void Date::Print()
{
	cout << _year << " " << _month << " " << _day << endl;
}

int main()
{
	Date d(2024, 1, 8);
	d.Print();

	return 0;
}

运行结果如下：

在针对C++系列的第一篇文章中，就提到了在C++中，输出变量的方法不光只有 $printf$ 函数，也可以使用流插入 $cout$ 。上面所展示的代码虽然用到了 $cout$ ，但是并不是直接调用，而是将 $cout$ 封装在一个类的成员函数中，进行调用的。如果针对上面的对象 $d$ ，直接利用 $cout$ 进行打印，即：

int main()
{
	cout << d;

	return 0;
}

运行代码，此时编译器会显示错误，即：

错误的原因在之前介绍运算符重载的时候提到过：对于自定义类型不能直接调用操作符，而是需要利用运算符重载。因此，为了实现自定义类型变量，即： $d$ ，在类中加入一个运算符重载，即：

（注:本篇文章所有的运算符重载都采用声明和定义分离的方式）

void Date::operator<<(ostream& out)
{
	out << _year << "年" << _month << "月" << _day << "日" << endl;
}

运行下方代码：

int main()
{
	Date d1(2024, 1, 8);
	cout << d1;
	return 0;
}

此时仍然显示运行错误，但是将上方代码更改为下面的形式：

int main()
{
	Date d1(2024, 1, 8);
	/*cout << d1;*/

	d1 << cout;
	return 0;
}

代码成功运行，结果如下：

这是因为，对于双操作数的运算符，第一个参数是左操作数，第二个参数是右操作数，之前的文章中多次提到，对于成员函数来说，通常会有一个隐藏的参数，即 $this$ 指针。所以，针对上面的运算符重载，其完整的参数应该为：

void Date::operator<<(Date* this, ostream& out)
{
	out << _year << "年" << _month << "月" << _day << "日" << endl;
}

所以，这就解释了为社么上面打印自定义类型 $d1$ 时， $cout<<d1$ 这种形式会造成编译错误，而 $d1<<cout$ 可以正常运行的原因。虽然将代码改为上述形式后，可以正常使用运算符 $cout$ ，但是，与平时利用 $cout$ 的使用习惯不符，改进的方法将在下一小节中进行介绍

1.2 针对上述问题的解决方法：

上面提到，造成问题的原因时因为成员函数会有一个隐藏的参数 $this$ ，为了避免此问题，可以将运算符重载的声明放在类之外，即作为一个全局函数，而非一个成员函数。对于全局函数，没有隐藏的参数 $this$ ，因此可以人为定义参数的顺序，即：

void operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
}

虽然解决了操作数的顺序问题，但是由于在运算符中，三个成员变量 _ $year$ , _ $month$ , _ $day$ 会受到访问限定符 $private$ 的影响。因此，还需要解决成员变量的访问问题。对于此问题的解决，文章给出一种方法：

1.2.1 通过创建友元函数来实现对私有变量的访问：

实现方法只需要在类中加上友元函数即可，即：

friend void operator<<(ostream& out, const Date& d);

（注:对于友元的相关知识将在下一篇文章中进行介绍，本文中只给出使用方法）

在加入了友元函数后，上述的运算符重载即可正常进行使用，即：

int main()
{
	Date d1(2024, 1, 8);
	cout << d1;
	return 0;
}

运行结果如下：

对于流提取，采用和流插入一样的实现方法，即：
创建运算符重载：

void operator>>(istream& in,Date& dd)
{
	in >> dd._year >> dd._month >> dd._day;
}

在类中加入友元函数：

friend void operator>>(istream& in, Date& dd);

测试流提取的功能：

int main()
{
	Date d1(2024, 1, 8);
	cin >> d1;
    cout << d1;
	return 0;
}

运行结果如下：

2. const成员函数：

2.1 const成员函数基本介绍：

文章在介绍刘运算符重载的时候举了一个例子，即创建一个对象，并且将其打印，即：

Date d1(2024, 1, 8);

在之前对于引用进行介绍的文章中，提到了常饮用这个概念，即在引用的前面加上 $const$ ，如果在上面给出的自定义类型 $d1$ 前加上 $const$ ，再对这个自定义类型进行打印，即：

int main()
{
	const Date d3(2024, 1, 9);
	d3.Print();
	return 0;
}

运行代码，此时编译器会显示错误。

具体错误原因与成员函数的隐藏变量 $this$ 以及权限变化有关。在常饮用那一节就提到过：权限平移或者缩小而不能放大，对于前面加了 $const$ 的自定义类型 $d3$ ，当 $d3$ 向函数 $Print$ 传递参数时，其参数类型为 $const \, Date*$ ,而函数 $Print$ 的 $this$ 的类型为 $Date* this$ ，因此，在传递参数的过程中，涉及了权限放大。对于此问题的解决方法需要在函数后面加上一个 $const$

(注:如果函数的声明和定义分离，则在声明和定义后都需要加上 $const$ ）

//函数声明
void Print() const;
//函数定义
void Date::Print() const
{
	cout << "void Date::Print() const" << endl;
	cout << _year << " " << _month << " " << _day << endl;
}

运行结果如下：

上面提到，权限不能放大，但是可以缩小或者平移，因此，非 $const$ 类型的变量可以调用 $const$ 类型的函数，例如：

int main()
{
	Date d4(2222, 2, 22);
	d4.Print();

	return 0;
}

运行结果如下：

2.2 什么类型的函数需要加 $const$ ：

在日期类中，给了很多的关于运算符重载的例子，例如：

bool operator>(Date& d);

利用上述运算符对下面两个自定义类型变量进行比较，即：

int main()
{
	const Date d3(2024, 1, 9);
	d3.Print();
	Date d4(2222, 2, 22);
	d4.Print();

	bool ret1 = (d3 > d4);
	cout << ret1 << endl;

	return 0;
}

运行代码，此时编译器会报错。

错误原因依旧涉及权限放大的问题，通过两个自定义类型的传递参数的顺序可以发现， $d3$ 在传递参数时，也涉及了权限的放大，因此，也需要将上述函数进行更改，即：

bool operator>(Date& d)const;

bool Date::operator>(Date& d) const
{
	if (_year > d._year)
	{
		return true;
	}
	else if ((_year == d._year) && (_month > d._month))
	{
		return true;
	}
	else if ((_year == d._year) && (_month == d._month) && (_day > d._day))
	{
		return true;
	}
	else
	{
		return false;
	}
}

通过上面的两个例子可以看到， $const$ 类型的对象可以调用 $const$ 类型函数，非 $const$ 型的对象也可以调用 $const$ 类型函数。因此，对于能够定义成 $const$ 类型的成员函数，一般都需要加上 $const$

前面的例子中，不难发现，在函数声明后面加上 $const$ 的作用，主要是修饰 $*this$ ，因此，如果一个成员函数涉及到对象的更改，则不能用 $const$ 修饰。因此，对于日期类中的所有函数类型，可以加 $const$ 的如下：

	bool operator==(Date& d)const;
	bool operator!=(Date& d)const;
	bool operator>(Date& d)const;
	bool operator>=(Date& d)const;
	bool operator<=(Date& d)const;
	bool operator<(Date& d)const;
    Date operator+(int day)const;
    Date operator-(int day)const;

需要注意，文章上面给出的流插入、流提取这两个函数由于不是成员函数，故不能用 $const$ 修饰。

3.取地址及const取地址操作符重载：

在前面的部分，介绍了默认成员函数中的4个，本部分将给出剩余的两个，由于这两个默认成员函数的实用意义远小于构造、析构、拷贝构造、赋值重载，因此文章只给出这两个函数的格式以及简单的应用：

格式如下：

	//取地址操作符重载
	Date* operator&()
	{
        cout << "Date* operator&()" << endl;
		return this;
	}

	//const取地址操作符重载
	const Date* operator&() const
	{
        cout << "const Date* operator&() const" << endl;
		return this;
	}

需要注意的时，这两个函数不光类型不同，其参数类型也不同，对于 $const$ 取地址操作符重载,第一个 $const$ 用于修饰函数的返回值，第二个 $const$ 修饰的是 $*this$ 。所以二者的参数类型不同。

下面给出测试代码来对取地址操作符重载以及 $const$ 取地址操作符重载的调用进行演示：

const Date d3(2024, 1, 9);
	//d3.Print();
	Date d4(2222, 2, 22);
	//d4.Print();
	cout << &d3 << endl;
	cout << &d4 << endl;

运行结果如下：

不难发现，自定义类型 $d3$ 被 $const$ 修饰，因此优先调用 $const$ 取地址操作符重载，自定义类型 $d4$ 没有被 $const$ 修饰，优先调用取地址操作符重载。加入，在这两个函数中去掉一个，例如去掉取地址操作符重载，即：

//取地址操作符重载
	/*Date* operator&()
	{
		cout << "Date* operator&()" << endl;
		return this;
	}*/

	//const取地址操作符重载
	const Date* operator&() const
	{
		cout << "const Date* operator&() const" << endl;
		return this;
	}

再运行下面的代码：

const Date d3(2024, 1, 9);
	//d3.Print();
	Date d4(2222, 2, 22);
	//d4.Print();
	cout << &d3 << endl;
	cout << &d4 << endl;

运行结果为：

当两个函数都去掉后，即：

	//取地址操作符重载
	/*Date* operator&()
	{
		cout << "Date* operator&()" << endl;
		return this;
	}*/

	//const取地址操作符重载
	/*const Date* operator&() const
	{
		cout << "const Date* operator&() const" << endl;
		return this;
	}*/

再次运行下方代码：

cout << &d4 << endl;
	cout << &d3 << endl;

运行结果如下：

此时代码依旧正常运行。这是因为取地址操作符重载和 $const$ 取地址操作符重载是默认构造函数，他的性质与构造函数类似，当不人为编写上述两个重载时，编译器会自动生成，当认为编写两个重载时，编译器会去调用已经编写好的。

4. 勘误：

由于个人能力有限，书中难免出现汉字拼写错误、代码意义解释错误、内容逻辑以及理解错误等不同类型的错误。首先感谢各位大佬能花掉自己宝贵的时间阅读此文章，愿大佬们斧正，发现错误可以通过私信联系，本人不胜感激。

起床写代码啦！

关注

30
点赞
踩
13

收藏

觉得还不错? 一键收藏
打赏
0
评论
C++类与对象基础(6)

取地址操作符重载是默认构造函数，他的性质与构造函数类似，当不人为编写上述两个重载时，编译器会自动生成，当认为编写两个重载时，编译器会去调用已经编写好的。这是因为，对于双操作数的运算符，第一个参数是左操作数，第二个参数是右操作数，之前的文章中多次提到，对于成员函数来说，通常会有一个隐藏的参数，即。，为了避免此问题，可以将运算符重载的声明放在类之外，即作为一个全局函数，而非一个成员函数。需要注意的时，这两个函数不光类型不同，其参数类型也不同，对于。可以正常运行的原因。封装在一个类的成员函数中，进行调用的。
复制链接

扫一扫