C++类学习笔记（5）

什么是运算符重载

运算符重载（Operator overload）是对已有的运算符赋予多重含义，使同一个运算符作 用于不同类型的数据时做出不同的行为。

例如：学生类包括姓名，年龄，班级，成绩等，定义了两个学生变量，想比较它们的大 小，如何比较大小呢？

为“学生”类重载“>”符号，然后在这个方法里实现比较的意义：按年龄、按成绩或 按姓名首字母比较等。

运算符重载的意义

运算符重载的本质是函数重载，是实现多态的重要手段，为用户提供了一个直观的接口。 调用运算符操作自定义数据类型其实就是调用运算符函数。运算符重载使用同样的运算 符，可以操作不同的数据，增强了C++的可扩充性，使代码更加直观、易读，便于对对 象进行各种运算操作。

运算符重载的语法格式

重载的运算符是具有特殊名字的函数：它们的名字由关键字operator，后跟要重载的运 算符。

返回类型 operator 运算符（参数列表）

{

    函数体;

}

说明：运算符是要重载的运算符名（如+、－、*、/等），但必须是C++允许重载的运算 符 

简单例子

“+”运算符的重载

#include <iostream>
using namespace std;
 
class A
{
private:
	int x, y;
public:
	A(int x1 = 0, int y1 = 0)
	{
		x = x1;
		y = y1;
	}
	A operator+(const A& a)const//重载-运算符的实现
	{
		return A(x + a.x, y + a.y);//调用A类构造函数创建一个临时匿名对象作为函数返								回
	}
	void show()
	{
		cout << "x=" << x << "," << "y=" << y << endl;
	}
};
int main()
{
	A a1(1, 2);
	A a2(3, 4);
	A a;
	a = a1 + a2;
	a.show();
}

“+”运算符的重载

x=4,y=6 

const一般用在代码前面表示常量，只可读不可改，这里用在函数中表示常成员函数： 只读函数，只可读不可改数据成员的值。也就是时候const定义的函数里面的数据成员 的值不可改变

代码分析
在A类中重载了运算符+，该重载只对A类对象有效。

执行a=a1+a2;语句时，编译器检测到+号左边是一个A类对象（+号具有左结合性，所以 先检测左边），就会调用成员函数operator+()，也就是转换为下面的形式：

a=a1.operator+(a2);    //a1是要调用函数的对象，a2是函数的实参

可见：

重载运算符并没有改变其原来的功能，只是增加了对自定义数据类型的运算功能。

C++ 类中的 this 指针用法 

 

在 C++ 类中 , this 指针 是一个特殊的指针 , 由系统自动生成 , 不需要手动声明定义 , 在类中的每个 非静态成员函数 中 , 都可以调用 this 指针 ;

this 指针 是指向 调用对象 自身 的指针 , 也就是调用 该成员函数 的 实例对象 的 内存地址 ;

由于 this 指针只能在 非静态成员函数内部使用 , 因此 this 指针是类内部使用的指针 , 使用 this 可以访问 实例对象 中 的所有 公有 public / 保护 protected / 私有 private 成员 ;

                        

在 C++ 类中 , 定义了 成员变量 age 和 height , 在 构造函数 中进行初始化 , 可以使用 this-> age 访问 age 成员变量 , 使用 this->height 访问 height 成员变量 ;

在下面的代码中 , 参数名称也是 age 和 height , 与 成员变量名称重名了 , 使用 this 指针可以有效区分 函数参数 与 成员变量 重名的问题 ;

使用 代码 this->age = age; 为 age 变量赋值 , this->age 是成员变量 , age 是函数的参数 ;

class Student
{
public:
	// 带参构造函数
	Student(int age, int height)
	{
		this->age = age;
		this->height = height;
		cout << "执行 Student 的构造函数" << endl;
	}

	void print() {
		// this 指针隐式传递
		std::cout << "age: " << age << std::endl;
		// 通过指针 访问成员变量
		std::cout << "this->age: " << this->age << std::endl;
		// 先获取指针指向的数据 然后访问数据中的成员变量
		std::cout << "(*this).age: " << (*this).age << std::endl;
	}

public:
	int age;		// 年龄
	int height;		// 身高
};

#include "iostream"
using namespace std;

class Student
{
public:
	// 带参构造函数
	Student(int age, int height)
	{
		this->age = age;
		this->height = height;
		cout << "执行 Student 的构造函数" << endl;
	}

	~Student()
	{
		cout << "执行 Student 的析构函数" << endl;
	}

	void print() {
		// this 指针隐式传递
		std::cout << "age: " << age << std::endl;
		// 通过指针 访问成员变量
		std::cout << "this->age: " << this->age << std::endl;
		// 先获取指针指向的数据 然后访问数据中的成员变量
		std::cout << "(*this).age: " << (*this).age << std::endl;
	}

public:
	int age;		// 年龄
	int height;		// 身高
};

int main() {
	
	// 调用有参构造函数 创建 Student 实例对象
	Student s(18, 180);

	cout<< "s.age" << s.age << " , s.height" << s.height << endl;

	s.print();
	

    // 控制台暂停 , 按任意键继续向后执行
    system("pause");

    return 0;
}

 

详解this 

1.引入

#include<iostream>
using namespace std;
class Data
{
public:
	void Init(int year,int month,int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void print()
	{
		cout << _year << ":" << _month << ":" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
//创建Data的对象1
	Data d1;
	d1.Init(1999, 1, 1);
//创建Data的对象2
	Data d2;
	d2.Init(2023, 1, 1);
//调用print函数
	d1.print();
	d2.print();
	return 0;
}

 

2.分析

上面代码运行结果中，为什么两个对象调用同一个函数能打印出不同的日期呢？或者说同一个函数如何做到结果不同呢？
简单说是通过C++的一个关键字this来实现的。
上面代码着编译后，就成了如下：

#include<iostream>
using namespace std;
class Data
{
public:
	void Init(int year,int month,int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void print(Data* this)
	{
		cout << this->_year << ":" << this->_month << ":" << this->_day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
//创建Data的对象1
	Data d1;
	d1.Init(1999, 1, 1);
//创建Data的对象2
	Data d2;
	d2.Init(2023, 1, 1);
//调用print函数
	d1.print(&d1);
	d2.print(&d2);
	return 0;
}

 当不同对象调用print函数时，其实在底层是传了一个Data*类型的指针this。、

void print(Data* this)
	{
		cout << this->_year << ":" << this->_month << ":" << this->_day << endl;
	}

 > 如下图所示：
其实底层还是和C语言函数调用一样，也需要传参，只不过C++的编译器为我们默默做了这些事情，让我们用起来更方便。但是，不能显示的去写出this的相关实参和形参，需要注意的是在类中可以使用this->。

this本质是一个形参，哪个对象调用他，就指向哪个对象。 

 

 

参考链接：https://blog.csdn.net/shulianghan/article/details/133252002                    
参考链接：https://blog.csdn.net/qq_52905520/article/details/127178512