C++笔记（class24.1）运算符重载

欣赏司空图的《酒泉子》

买得杏花，十载归来方始坼。假山西畔药阑东，满枝红。

旋开旋落旋成空，白发多情人更惜。黄昏把酒祝东风，且从容。

目录

 运算符重载

非类的成员函数实现运算符重载 

 实现一个年龄比较的功能，使用重载运算符【operator<】

实现人的年龄和一个固定数字比较 

类内重载运算符 

---

 运算符重载

非类的成员函数实现运算符重载 

 实现一个年龄比较的功能，使用重载运算符【operator<】

本质上是实现了一个函数

利用类的非成员函数，实现运算符重载

bool operator<(Person& p1,Person& p2)
{
    if (p1.Age < p2.Age)std::cout << "p1小于p2";
    else{
        std::cout << "p2小于p1";
    }
    return true;
}

// class24.1.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
class Person
{
public:
    unsigned short Age;
    Person(unsigned short _Age) :Age{ _Age }{
    }
};

bool operator<(Person& p1,Person& p2){
    if (p1.Age < p2.Age)std::cout << "p1小于p2";
    else{
        std::cout << "p2小于p1";
    }
    return true;
}
int main(){
    Person user1(50);
    Person user2(30);
    if (user1 < user2);
}

上面的代码中，重载函数内无法访问类Person的私有成员变量，那么将函数

【bool operator<(Person& p1,Person& p2)】设置成友元，那么就可以在函数内访问私有成员变量

如下：

class Person
{
    friend bool operator<(Person& p1, Person& p2);
    unsigned short Age;
public:
    Person(unsigned short _Age) :Age{ _Age }{
    }
};

当我把重载运算符函数【operator<】内的形参设置成三个参数，编译器会自动报错

 因为【<】是一元运算符

实现人的年龄和一个固定数字比较 

class Person
{
    friend bool operator<(Person& p1, int age);
    friend bool operator<(Person& p1, Person& p2);
    unsigned short Age;
public:
    Person(unsigned short _Age) :Age{ _Age }{
    }
};

bool operator<(Person& p1, int age)
{
    if (p1.Age < age)std::cout << "p1小于age";
    else {
        std::cout << "age小于p1";
    }
    return true;
}

 注意：

类内重载运算符 

class Person
{
    friend bool operator<(Person& p1, int age);
    friend bool operator<(Person& p1, Person& p2);
    unsigned short Age;
public:
    Person(unsigned short _Age) :Age{ _Age }{
    }
    //类内重载运算符【operator>】
    bool operator>(Person& p1)
    {
        if (Age > p1.Age)
        {
            return true;
        }
    }

};

    if (user1>(user2))
    {
        std::cout << "user1大于user2" << std::endl;
    }

附代码： 

#include <iostream>

//using Non member functions of classes to realize operator overloading
//当遇到私有成员变量就无法使用了，必须要将其声明为友元，才可以去访问私有成员变量

class person
{
//public:
	//friend bool Smaller(person& psa, person& psb);
	//friend bool operator<(person& psa, person& psb);
	//friend bool operator<(person& psa, unsigned int num);
	unsigned short Age;

public:
	unsigned short GetAge() { return Age; }

	person(unsigned short _Age):Age{_Age}{}

	bool bigger(person& psa) {
		return this->GetAge() > psa.GetAge();
	}
	//这个函数放在类外就会报错：括号内参数少了
	//类的成员函数的运算符重载
	bool operator>(person& psa);//类内声明，类外实现


};
//类内声明类外实现
bool person::operator>(person& psa)
{
	return this->GetAge() > psa.GetAge();
}

//using the function to compare the age of two person
bool Smaller(person& psa, person& psb) {


	return psa.GetAge() < psb.GetAge();


}
//now we can use the operator overloading
//In effect,it is also a function
//最多是两个参数，由一元运算符和二元运算符决定的
//非类的成员函数实现运算符重载
bool operator<(person& psa, person& psb) 
{

	return psa.GetAge() < psb.GetAge();

}

//实现人和一个数字比较
bool operator<(person& psa, unsigned int num) {

	return psa.GetAge() < num;
}
//友元的一大缺点是破坏类的封装性；可以通过引入一个函数来解决这个问题，加入成员函数GetAge()


int main()
{
	person Man(20);

	person Woman(50);

	//using the Smaller function
	if (Smaller(Man,Woman)) 
	{
		std::cout << "success!!!" << std::endl;
	}


	//【Man<Woman】==【operator<(Man,Woman)】
	//using the operator< (Method 1)
	if (Man < Woman)
	{
		std::cout << "success" << std::endl;
	}

	//using the operator (Method 2)
	if (operator<(Man, Woman))
	{
		std::cout << "success" << std::endl;
	}

	if (Woman.operator>(Man))
	{
		std::cout << "Woman大于man!!!"<<std::endl;
	}


	system("pause");
	return 0;
}