【C++】运算符重载 ③ ( 二元运算符重载 | 运算符重载步骤 | 全局函数 实现 运算符重载 | 成员函数 实现 运算符重载 | 友元函数 实现 运算符重载 )

文章目录

• 一、运算符重载步骤
• 二、友元函数实现运算符重载

一、运算符重载步骤

---

1、运算符重载步骤说明

运算符重载步骤 :

• 首先 , 写出函数名 , 函数名规则为 " operate " 后面跟上要重载的运算符 , 如 operate+ 是重载加号运算符 ;
• 然后 , 根据操作数 写出函数参数 , 参数一般都是 对象的引用 ;
  • 成员函数 : 参数是 1 1 1 个对象的常量引用 , 如 : operate+(const Student& s1)
  • 全局函数 : 参数是 2 2 2 个对象的引用 , 如 : operate+(Student& s1, Student& s2)
• 再后 , 根据业务完善返回值 , 返回值可以是 引用 / 指针 / 元素 , 如 : 返回值是元素 Student operate+(Student& s1, Student& s2)
• 最后 , 实现函数体 , 编写具体的运算符操作业务逻辑 ;

2、运算符重载类

下面以 Student 类为例 , 编写 成员函数 / 全局函数 实现 运算符重载 代码 ;

class Student
{
public:
	// 带参构造函数 , 为参数设置默认值
	Student(int age = 1, int height = 1)
	{
		this->age = age;
		this->height = height;
	};

public:
	// 打印类数据
	void print()
	{
		cout << "age = " << age << " , height = " << height << endl;
	};

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

3、全局函数 实现 运算符重载

使用 全局函数 实现 运算符重载 , 重载 + 运算符 ;

全局函数 实现 运算符重载 :

• 首先 , 写出函数名 , 函数名规则为 " operate " 后面跟上要重载的运算符 , 函数名是 operate+ ;

operate+

• 然后 , 根据操作数 写出函数参数 , 参数一般都是 对象的引用 ;
  • 成员函数 : 参数是 1 1 1 个对象的常量引用 , 如 : operate+(const Student& s1)
  • 全局函数 : 参数是 2 2 2 个对象的引用 , 如 : operate+(Student& s1, Student& s2)

operate+(Student& s1, Student& s2)

• 再后 , 根据业务完善返回值 , 返回值可以是 引用 / 指针 / 元素 , 如 : 返回值是元素 Student operate+(Student& s1, Student& s2)

Student operator+(Student& s1, Student& s2)

• 最后 , 实现函数体 , 编写具体的运算符操作业务逻辑 ;

// 使用 全局函数 实现 运算符重载 
// 重载 + 运算符
// 实现两个 Student 对象相加
Student operator+(Student& s1, Student& s2)
{
	Student student(s1.age + s2.age, s1.height + s2.height);
	return student;
};

4、成员函数 实现 运算符重载

使用 成员函数 实现 运算符重载 , 重载 - 运算符 ;

成员函数 实现 运算符重载 :

• 首先 , 写出函数名 , 函数名规则为 " operate " 后面跟上要重载的运算符 , 函数名是 operate- ;

operate-

• 然后 , 根据操作数 写出函数参数 , 参数一般都是 对象的引用 ;
  • 成员函数 : 参数是 1 1 1 个对象的常量引用 , 如 : operate+(const Student& s1)
  • 全局函数 : 参数是 2 2 2 个对象的引用 , 如 : operate+(Student& s1, Student& s2)

operator-(Student& s)

• 再后 , 根据业务完善返回值 , 返回值可以是 引用 / 指针 / 元素 ;

Student operator-(Student& s)

• 最后 , 实现函数体 , 编写具体的运算符操作业务逻辑 ;

public:
	// 使用 成员函数 实现 运算符重载 
	// 重载 - 运算符
	// 实现两个 Student 对象相加
	Student operator-(Student& s)
	{
		Student student(this->age - s.age, this->height - s.height);
		return student;
	};

5、完整代码示例

代码示例 :

#include "iostream"
using namespace std;

class Student
{

public:
	// 带参构造函数 , 为参数设置默认值
	Student(int age = 1, int height = 1)
	{
		this->age = age;
		this->height = height;
	};

public:
	// 打印类数据
	void print()
	{
		cout << "age = " << age << " , height = " << height << endl;
	};

public:
	// 使用 成员函数 实现 运算符重载 
	// 重载 - 运算符
	// 实现两个 Student 对象相加
	Student operator-(Student& s)
	{
		Student student(this->age - s.age, this->height - s.height);
		return student;
	};

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

// 使用 全局函数 实现 运算符重载 
// 重载 + 运算符
// 实现两个 Student 对象相加
Student operator+(Student& s1, Student& s2)
{
	Student student(s1.age + s2.age, s1.height + s2.height);
	return student;
};

int main() {
	// 自定义类型相加
	Student s1(10, 120), s2(18, 170);
	Student s3, s4, s5;

	s3 = s1 + s2;
	s3.print();

	s4 = s1 - s2;
	s4.print();

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

    return 0;
};

执行结果 :

age = 28 , height = 290
age = -8 , height = -50
请按任意键继续. . .

二、友元函数实现运算符重载

---

1、友元函数实现运算符重载

如果类中的成员都是私有成员 ,

在 运算符重载 中 , 需要访问 私有成员 进行计算 ,

在 成员函数 中 , 可以正常访问 私有成员 ,

但是 在 全局函数 中 , 就无法访问 私有成员 了 ;

此时就需要将 全局函数 声明为 类的 友元函数 , 这样才能再 该 全局函数 ( 友元函数 ) 中访问 私有成员 ;

类中的 成员变量 是 私有成员 ;

private:
	int age;		// 年龄
	int height;		// 身高

定义了 全局函数 , 该全局函数中访问了 类中的 私有成员 ,

// 使用 全局函数 实现 运算符重载 
// 重载 + 运算符
// 实现两个 Student 对象相加
Student operator+(Student& s1, Student& s2)
{
	Student student(s1.age + s2.age, s1.height + s2.height);
	return student;
};

需要将 全局函数 声明为 友元函数 , 此时 使用 全局函数 实现 运算符重载 正常执行 ;

private:
	friend Student operator+(Student& s1, Student& s2);

2、代码示例 - 友元函数实现运算符重载

代码示例 :

#include "iostream"
using namespace std;

class Student
{
public:
	// 带参构造函数 , 为参数设置默认值
	Student(int age = 1, int height = 1)
	{
		this->age = age;
		this->height = height;
	};

public:
	// 打印类数据
	void print()
	{
		cout << "age = " << age << " , height = " << height << endl;
	};

public:
	// 使用 成员函数 实现 运算符重载 
	// 重载 - 运算符
	// 实现两个 Student 对象相加
	Student operator-(Student& s)
	{
		Student student(this->age - s.age, this->height - s.height);
		return student;
	};

private:
	friend Student operator+(Student& s1, Student& s2);

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

// 使用 全局函数 实现 运算符重载 
// 重载 + 运算符
// 实现两个 Student 对象相加
Student operator+(Student& s1, Student& s2)
{
	Student student(s1.age + s2.age, s1.height + s2.height);
	return student;
};

int main() {
	// 自定义类型相加
	Student s1(10, 120), s2(18, 170);
	Student s3, s4, s5;

	s3 = s1 + s2;
	s3.print();

	s4 = s1 - s2;
	s4.print();

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

    return 0;
};

执行结果 :

age = 28 , height = 290
age = -8 , height = -50
请按任意键继续. . .