09.多态与虚函数

目录介绍

• 9.1 多态概念
  • 9.1.1 多态基本概念
  • 9.1.2 多态分类
  • 9.1.3 多态案例一
• 9.2 多态和虚函数
  • 9.2.1 虚函数和抽象类
  • 9.2.2 虚函数VS纯虚函数
  • 9.2.3 虚函数注意事项
  • 9.2.4 多态案例二
  • 9.2.5 虚析构和纯虚析构
  • 9.2.6 多态案例三
  • 9.2.7 虚函数实现动态绑定
• 9.3 函数重载
  • 9.3.1 什么叫函数重载
• 9.4 运算符的重载
  • 9.4.1 加号运算符重载[-]
  • 9.4.2 左移运算符重载[-]
  • 9.4.3 递增运算符重载[-]
  • 9.4.4 赋值运算符重载[-]
  • 9.4.5 关系运算符重载[-]
  • 9.4.6 函数调用运算符重载[-]

9.1 多态概念

9.1.1 多态基本概念

面向对象程序设计语言有封装、继承和多态三种机制，这三种机制能够有效提高程序的可读性、可扩充性和可重用性。

“多态（polymorphism）”指的是同一名字的事物可以完成不同的功能。

多态可以分为编译时的多态和运行时的多态。

1. 前者主要是指函数的重载（包括运算符的重载）、对重载函数的调用，在编译时就能根据实参确定应该调用哪个函数，因此叫编译时的多态；
2. 后者则和继承、虚函数等概念有关。

class Animal {
public:
    void eat() {
        cout << "动物在吃东西" << endl;
    }
    //Speak函数就是虚函数
    //函数前面加上virtual关键字，变成虚函数，那么编译器在编译的时候就不能确定函数调用了。
    virtual void speak() {
        cout << "动物在说话" << endl;
    }
};

class Cat : public Animal {
public:
    void eat() {
        cout << "小猫吃鱼" << endl;
    }
    void speak() {
        cout << "小猫在说话" << endl;
    }
};

class Dog : public Animal {
public:
    void eat() {
        cout << "小狗吃屎" << endl;
    }
    void speak() {
        cout << "小狗在说话" << endl;
    }
};

//我们希望传入什么对象，那么就调用什么对象的函数
//如果函数地址在编译阶段就能确定，那么静态联编
//如果函数地址在运行阶段才能确定，就是动态联编
void DoSpeak(Animal & animal){
    animal.eat();
    animal.speak();
}

int main() {
    Cat cat;
    DoSpeak(cat);

    Dog dog;
    DoSpeak(dog);
    return 0;
}

总结：多态满足条件

• 有继承关系
• 子类重写父类中的虚函数

多态使用条件

父类指针或引用指向子类对象

重写：函数返回值类型 函数名 参数列表 完全一致称为重写

9.1.2 多态分类

多态分为两类

• 静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名
• 动态多态: 派生类和虚函数实现运行时多态

静态多态和动态多态区别：

• 静态多态的函数地址早绑定 - 编译阶段确定函数地址
• 动态多态的函数地址晚绑定 - 运行阶段确定函数地址

9.1.3 多态案例一-计算器类

案例描述：分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类

多态的优点：

• 代码组织结构清晰
• 可读性强
• 利于前期和后期的扩展以及维护

示例：普通写法

class Calculator {
public:
    int getResult(string oper) {
        if (oper == "+") {
            return num1 + num2;
        } else if (oper == "-") {
            return num1 - num2;
        } else if (oper == "*") {
            return num1 * num2;
        }
        //如果要提供新的运算，需要修改源码
        return 0;
    }
public:
    int num1;
    int num2;
};

void test01() {
    //普通实现测试
    Calculator c;
    c.num1 = 10;
    c.num2 = 10;
    cout << c.num1 << " + " << c.num2 << " = " << c.getResult("+") << endl;
    cout << c.num1 << " - " << c.num2 << " = " << c.getResult("-") << endl;
    cout << c.num1 << " * " << c.num2 << " = " << c.getResult("*") << endl;
}

示例：多态技术

//抽象计算器类
//多态优点：代码组织结构清晰，可读性强，利于前期和后期的扩展以及维护
class AbstractCalculator {
public :
    virtual int getResult() {
        return 0;
    }

    int num1;
    int num2;
};

//加法计算器
class AddCalculator : public AbstractCalculator {
public:
    int getResult() {
        return num1 + num2;
    }
};

//减法计算器
class SubCalculator : public AbstractCalculator {
public:
    int getResult() {
        return num1 - num2;
    }
};

//乘法计算器
class MulCalculator : public AbstractCalculator {
public:
    int getResult() {
        return num1 * num2;
    }
};

void test02() {
    //创建加法计算器
    AbstractCalculator *abc = new AddCalculator;
    abc->num1 = 10;
    abc->num2 = 10;
    cout << abc->num1 << " + " << abc->num2 << " = " << abc->getResult() << endl;
    delete abc;  //用完了记得销毁

    //创建减法计算器
    abc = new SubCalculator;
    abc->num1 = 10;
    abc->num2 = 10;
    cout << abc->num1 << " - " << abc->num2 << " = " << abc->getResult() << endl;
    delete abc;

    //创建乘法计算器
    abc = new MulCalculator;
    abc->num1 = 10;
    abc->num2 = 10;
    cout << abc->num1 << " * " << abc->num2 << " = " << abc->getResult() << endl;
    delete abc;
}

总结：C++开发提倡利用多态设计程序架构，因为多态优点很多

9.2 多态和虚函数

9.2.1 虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容。因此可以将虚函数改为纯虚函数

纯虚函数语法：virtual 返回值类型 函数名 （参数列表）= 0 ;，纯虚函数是通过在声明中使用 "= 0" 来指定的。

如果类中至少有一个函数被声明为纯虚函数，则这个类就是抽象类。

抽象类特点：

• 无法实例化对象
• 子类必须重写抽象类中的纯虚函数，否则也属于抽象类

示例：

class Base {
public:
    //纯虚函数
    //类中只要有一个纯虚函数就称为抽象类
    //抽象类无法实例化对象
    //子类必须重写父类中的纯虚函数，否则也属于抽象类
    virtual void func() = 0;

    //在基类中声明虚函数：在基类中将要被派生类重写的函数声明为虚函数。使用virtual关键字来标识虚函数。例如：
    virtual void foo() {
        cout << "基类虚函数的实现" << endl;
    }
};

class Son : public Base {
public:
    //下面这个报错
//    virtual void func(){
//        cout << "func调用" << endl;
//    };

    virtual void func() override{
        cout << "func调用" << endl;
    };

    //在派生类中重写虚函数：在派生类中重写基类的虚函数，使用相同的函数签名。使用override关键字来明确表示重写基类的虚函数。例如：
    void foo() override {
        cout << "派生类虚函数的实现" << endl;
    }
};

void test() {
    Base *base = NULL;
    //base = new Base; // 错误，抽象类无法实例化对象
    base = new Son;
    base->func();
    base->foo();
    //delete base;//记得销毁 //报错：delete called on 'Base' that is abstract but has non-virtual destructor
}

int main() {
    test();
    return 0;
}

由此可知：

1. 抽象类不能被用于实例化对象，它只能作为接口使用。如果试图实例化一个抽象类的对象，会导致编译错误。

9.2.2 虚函数VS纯虚函数

虚函数（Virtual Function）和纯虚函数（Pure Virtual Function）是面向对象编程中的重要概念，用于实现多态性和抽象类。

1. 虚函数是在基类中声明为虚拟的成员函数，它可以在派生类中被重写（覆盖）。通过使用虚函数，可以在运行时根据对象的实际类型来调用相应的函数实现，实现多态性。
2. 纯虚函数是在基类中声明为纯虚拟的成员函数，它没有函数体，只有函数声明，并且使用= 0来指示。纯虚函数在基类中没有默认实现，它的具体实现由派生类提供。纯虚函数用于定义抽象类，它不能被实例化，只能作为基类来派生其他类。

以下是虚函数和纯虚函数的示例：

class Base{
public:
    virtual void virtualFunction() {
        // 虚函数的默认实现
        std::cout << "Base virtual function" << std::endl;
    }
    virtual void pureVirtualFunction() = 0;
};

class Derived : public Base {
public:
    void virtualFunction() override {
        // 重写虚函数
        std::cout << "Derived virtual function" << std::endl;
    }
    void pureVirtualFunction() override {
        // 实现纯虚函数
        std::cout << "Derived pure virtual function" << std::endl;
    }
};

int main() {
    Derived derived;
    derived.pureVirtualFunction();
    derived.virtualFunction();
    //new 创建对象
    Derived *derived2 = new Derived();
    derived2->pureVirtualFunction();
    derived2->virtualFunction();
    return 0;
}

虚函数和纯虚函数都可以通过指针或引用来实现运行时多态性，即在运行时根据对象的实际类型来调用相应的函数实现。

9.2.3 虚函数注意事项

9.2.4 多态案例二——制作饮品

案例描述：

制作饮品的大致流程为：煮水 - 冲泡 - 倒入杯中 - 加入辅料

利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作咖啡和茶叶

示例：

//抽象制作饮品
class AbstractDrinking {
public:
    //烧水
    virtual void Boil() = 0;
    //冲泡
    virtual void Brew() = 0;
    //倒入杯中
    virtual void PourInCup() = 0;
    //加入辅料
    virtual void PutSomething() = 0;
    //规定流程
    void MakeDrink() {
        Boil();
        Brew();
        PourInCup();
        PutSomething();
    }
};

//制作咖啡
class Coffee : public AbstractDrinking {
public:
    //烧水
    virtual void Boil() {
        cout << "煮农夫山泉!" << endl;
    }
    //冲泡
    virtual void Brew() {
        cout << "冲泡咖啡!" << endl;
    }
    //倒入杯中
    virtual void PourInCup() {
        cout << "将咖啡倒入杯中!" << endl;
    }
    //加入辅料
    virtual void PutSomething() {
        cout << "加入牛奶!" << endl;
    }
};

//制作茶水
class Tea : public AbstractDrinking {
public:
    //烧水
    virtual void Boil() {
        cout << "煮自来水!" << endl;
    }
    //冲泡
    virtual void Brew() {
        cout << "冲泡茶叶!" << endl;
    }
    //倒入杯中
    virtual void PourInCup() {
        cout << "将茶水倒入杯中!" << endl;
    }
    //加入辅料
    virtual void PutSomething() {
        cout << "加入枸杞!" << endl;
    }
};

//业务函数
void DoWork(AbstractDrinking *drink) {
    drink->MakeDrink();
    //delete drink; //报错， delete called on 'AbstractDrinking' that is abstract but has non-virtual destructor
}

void test() {
    DoWork(new Coffee);
    cout << "--------------" << endl;
    DoWork(new Tea);
}

int main() {
    test();
    return 0;
}

打印结果如下所示：

煮农夫山泉!
冲泡咖啡!
将咖啡倒入杯中!
加入牛奶!
--------------
煮自来水!
冲泡茶叶!
将茶水倒入杯中!
加入枸杞!

9.2.5 虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码

解决方式：将父类中的析构函数改为虚析构或者纯虚析构

虚析构和纯虚析构共性：

• 可以解决父类指针释放子类对象
• 都需要有具体的函数实现

虚析构和纯虚析构区别：

• 如果是纯虚析构，该类属于抽象类，无法实例化对象

虚析构语法：virtual ~类名(){}

纯虚析构语法： virtual ~类名() = 0;

类名::~类名(){}

示例：

class Animal {
public:
    Animal() {
        cout << "Animal 构造函数调用！" << endl;
    }

    //纯虚函数
    virtual void speak() = 0;

    //虚函数
    virtual void eat() {
        cout << "Animal 动物吃东西！" << endl;
    }

    //普通函数
    void play() {
        cout << "Animal 动物在玩！" << endl;
    }

    //析构函数加上virtual关键字，变成虚析构函数
    virtual ~Animal() {
        cout << "Animal虚析构函数调用！" << endl;
    }
};

class Cat : public Animal {
public:
    string name1;
    string *name2;
public:
    Cat(string name) {
        cout << "Cat 构造函数调用！" << endl;
        name1 = name;
        name2 = new string(name);
    }

    virtual void speak() {
        cout << name1 << "Cat1 在说话！" << endl;
        cout << *name2 << "Cat2 在说话！" << endl;
    }

    void eat() {
        cout << name1 << "Cat1 在吃东西！" << endl;
        cout << *name2 << "Cat2 在吃东西！" << endl;
    }

    //子类和父类方法名相同，且父类是普通方法。
    void play() {
        cout << name1 << "Cat1 在玩！" << endl;
        cout << *name2 << "Cat2 在玩！" << endl;
    }

    ~Cat() {
        cout << "Cat析构函数调用!" << endl;
        if (this->name2 != NULL) {
            delete name2;
            name2 = NULL;
        }
    }
};

int main() {
    Animal *animal = new Cat("Tom");
    animal->speak();
    animal->eat();
    animal->play();
    //通过父类指针去释放，会导致子类对象可能清理不干净，造成内存泄漏
    //怎么解决？给基类增加一个虚析构函数
    //虚析构函数就是用来解决通过父类指针释放子类对象
    delete animal;
    return 0;
}

打印结果如下所示：

Animal 构造函数调用！
Cat 构造函数调用！
TomCat1 在说话！
TomCat2 在说话！
TomCat1 在吃东西！
TomCat2 在吃东西！
Animal 动物在玩！
Cat析构函数调用!
Animal虚析构函数调用！

总结：

1. 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象
2. 如果子类中没有堆区数据，可以不写为虚析构或纯虚析构
3. 拥有纯虚析构函数的类也属于抽象类

9.2.6 多态案例三-组装电脑

案例描述：

1. 电脑主要组成部件为 CPU（用于计算），显卡（用于显示），内存条（用于存储）
2. 将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如Intel厂商和Lenovo厂商
3. 创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口
4. 测试时组装三台不同的电脑进行工作

示例：

#include<iostream>
using namespace std;

//抽象CPU类
class CPU
{
public:
	//抽象的计算函数
	virtual void calculate() = 0;
};

//抽象显卡类
class VideoCard
{
public:
	//抽象的显示函数
	virtual void display() = 0;
};

//抽象内存条类
class Memory
{
public:
	//抽象的存储函数
	virtual void storage() = 0;
};

//电脑类
class Computer
{
public:
	Computer(CPU * cpu, VideoCard * vc, Memory * mem)
	{
		m_cpu = cpu;
		m_vc = vc;
		m_mem = mem;
	}

	//提供工作的函数
	void work()
	{
		//让零件工作起来，调用接口
		m_cpu->calculate();

		m_vc->display();

		m_mem->storage();
	}

	//提供析构函数 释放3个电脑零件
	~Computer()
	{

		//释放CPU零件
		if (m_cpu != NULL)
		{
			delete m_cpu;
			m_cpu = NULL;
		}

		//释放显卡零件
		if (m_vc != NULL)
		{
			delete m_vc;
			m_vc = NULL;
		}

		//释放内存条零件
		if (m_mem != NULL)
		{
			delete m_mem;
			m_mem = NULL;
		}
	}

private:

	CPU * m_cpu; //CPU的零件指针
	VideoCard * m_vc; //显卡零件指针
	Memory * m_mem; //内存条零件指针
};

//具体厂商
//Intel厂商
class IntelCPU :public CPU
{
public:
	virtual void calculate()
	{
		cout << "Intel的CPU开始计算了！" << endl;
	}
};

class IntelVideoCard :public VideoCard
{
public:
	virtual void display()
	{
		cout << "Intel的显卡开始显示了！" << endl;
	}
};

class IntelMemory :public Memory
{
public:
	virtual void storage()
	{
		cout << "Intel的内存条开始存储了！" << endl;
	}
};

//Lenovo厂商
class LenovoCPU :public CPU
{
public:
	virtual void calculate()
	{
		cout << "Lenovo的CPU开始计算了！" << endl;
	}
};

class LenovoVideoCard :public VideoCard
{
public:
	virtual void display()
	{
		cout << "Lenovo的显卡开始显示了！" << endl;
	}
};

class LenovoMemory :public Memory
{
public:
	virtual void storage()
	{
		cout << "Lenovo的内存条开始存储了！" << endl;
	}
};


void test01()
{
	//第一台电脑零件
	CPU * intelCpu = new IntelCPU;
	VideoCard * intelCard = new IntelVideoCard;
	Memory * intelMem = new IntelMemory;

	cout << "第一台电脑开始工作：" << endl;
	//创建第一台电脑
	Computer * computer1 = new Computer(intelCpu, intelCard, intelMem);
	computer1->work();
	delete computer1;

	cout << "-----------------------" << endl;
	cout << "第二台电脑开始工作：" << endl;
	//第二台电脑组装
	Computer * computer2 = new Computer(new LenovoCPU, new LenovoVideoCard, new LenovoMemory);;
	computer2->work();
	delete computer2;

	cout << "-----------------------" << endl;
	cout << "第三台电脑开始工作：" << endl;
	//第三台电脑组装
	Computer * computer3 = new Computer(new LenovoCPU, new IntelVideoCard, new LenovoMemory);;
	computer3->work();
	delete computer3;

}

9.2.7 虚函数实现动态绑定

通过利用虚函数实现动态绑定，可以在运行时根据对象的实际类型来调用相应的函数，实现多态的效果。

这提供了更灵活和可扩展的代码结构，使得程序能够适应不同类型的对象并执行相应的操作。

class Shape {
public:
    virtual void draw() {
        // 基类虚函数的默认实现
        cout << "Drawing a shape." << endl;
    }
};

class Circle : public Shape {
public:
    void draw() override {
        // 派生类虚函数的实现
        cout << "Drawing a circle." << endl;
    }
};

class Rectangle : public Shape {
public:
    void draw() override {
        // 派生类虚函数的实现
        cout << "Drawing a rectangle." << endl;
    }
};

int main() {
    Shape *shape;
    Circle circle;
    Rectangle rectangle;

    //示例中，基类Shape中的draw()函数被声明为虚函数。派生类Circle和Rectangle分别重写了基类的虚函数。
    //由于draw()函数是虚函数，因此在运行时会根据实际对象的类型来动态绑定，选择调用相应的派生类的函数实现。

    // 动态绑定，调用Circle类的draw()函数
    shape = &circle;
    shape->draw();

    // 动态绑定，调用Rectangle类的draw()函数
    shape = &rectangle;
    shape->draw();
    return 0;
}

9.3 函数重载

9.3.1 什么叫函数重载

C++ 允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。

在同一个作用域内，可以声明几个功能类似的同名函数，但是这些同名函数的形式参数（指参数的个数、类型或者顺序）必须不同。

注意：您不能仅通过返回类型的不同来重载函数。

class printData {
public:
    void print(int i) {
        cout << "整数为: " << i << endl;
    }

    void print(double f) {
        cout << "浮点数为: " << f << endl;
    }

    void print(char c[]) {
        cout << "字符串为: " << c << endl;
    }
};

void test() {
    printData pd;
    // 输出整数
    pd.print(5);
    // 输出浮点数
    pd.print(500.263);
    // 输出字符串
    char c[] = "Hello C++";
    pd.print(c);
}

int main() {
    test();
    return 0;
}

来看一下打印结果，如下所示：

整数为: 5
浮点数为: 500.263
字符串为: Hello C++

9.4 运算符的重载

运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型

9.4.1 加号运算符重载

作用：实现两个自定义数据类型相加的运算

class Person {
public:
	Person() {};
	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}
	//成员函数实现 + 号运算符重载
	Person operator+(const Person& p) {
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;
	}


public:
	int m_A;
	int m_B;
};

//全局函数实现 + 号运算符重载
//Person operator+(const Person& p1, const Person& p2) {
//	Person temp(0, 0);
//	temp.m_A = p1.m_A + p2.m_A;
//	temp.m_B = p1.m_B + p2.m_B;
//	return temp;
//}

//运算符重载 可以发生函数重载 
Person operator+(const Person& p2, int val)  
{
	Person temp;
	temp.m_A = p2.m_A + val;
	temp.m_B = p2.m_B + val;
	return temp;
}

void test() {

	Person p1(10, 10);
	Person p2(20, 20);

	//成员函数方式
	Person p3 = p2 + p1;  //相当于 p2.operaor+(p1)
	cout << "mA:" << p3.m_A << " mB:" << p3.m_B << endl;


	Person p4 = p3 + 10; //相当于 operator+(p3,10)
	cout << "mA:" << p4.m_A << " mB:" << p4.m_B << endl;

}

int main() {

	test();

	system("pause");

	return 0;
}

总结1：对于内置的数据类型的表达式的的运算符是不可能改变的

总结2：不要滥用运算符重载

9.4.2 左移运算符重载

作用：可以输出自定义数据类型

class Person {
	friend ostream& operator<<(ostream& out, Person& p);

public:

	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}

	//成员函数 实现不了  p << cout 不是我们想要的效果
	//void operator<<(Person& p){
	//}

private:
	int m_A;
	int m_B;
};

//全局函数实现左移重载
//ostream对象只能有一个
ostream& operator<<(ostream& out, Person& p) {
	out << "a:" << p.m_A << " b:" << p.m_B;
	return out;
}

void test() {

	Person p1(10, 20);

	cout << p1 << "hello world" << endl; //链式编程
}

int main() {

	test();

	system("pause");

	return 0;
}

总结：重载左移运算符配合友元可以实现输出自定义数据类型

9.4.3 递增运算符重载

作用： 通过重载递增运算符，实现自己的整型数据

class MyInteger {

	friend ostream& operator<<(ostream& out, MyInteger myint);

public:
	MyInteger() {
		m_Num = 0;
	}
	//前置++
	MyInteger& operator++() {
		//先++
		m_Num++;
		//再返回
		return *this;
	}

	//后置++
	MyInteger operator++(int) {
		//先返回
		MyInteger temp = *this; //记录当前本身的值，然后让本身的值加1，但是返回的是以前的值，达到先返回后++；
		m_Num++;
		return temp;
	}

private:
	int m_Num;
};


ostream& operator<<(ostream& out, MyInteger myint) {
	out << myint.m_Num;
	return out;
}


//前置++ 先++ 再返回
void test01() {
	MyInteger myInt;
	cout << ++myInt << endl;
	cout << myInt << endl;
}

//后置++ 先返回 再++
void test02() {

	MyInteger myInt;
	cout << myInt++ << endl;
	cout << myInt << endl;
}

int main() {

	test01();
	//test02();

	system("pause");

	return 0;
}

总结： 前置递增返回引用，后置递增返回值

9.4.4 赋值运算符重载

c++编译器至少给一个类添加4个函数

1. 默认构造函数(无参，函数体为空)
2. 默认析构函数(无参，函数体为空)
3. 默认拷贝构造函数，对属性进行值拷贝
4. 赋值运算符 operator=, 对属性进行值拷贝

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题

示例：

class Person
{
public:

	Person(int age)
	{
		//将年龄数据开辟到堆区
		m_Age = new int(age);
	}

	//重载赋值运算符 
	Person& operator=(Person &p)
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
		//编译器提供的代码是浅拷贝
		//m_Age = p.m_Age;

		//提供深拷贝 解决浅拷贝的问题
		m_Age = new int(*p.m_Age);

		//返回自身
		return *this;
	}


	~Person()
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
	}

	//年龄的指针
	int *m_Age;

};


void test01()
{
	Person p1(18);

	Person p2(20);

	Person p3(30);

	p3 = p2 = p1; //赋值操作

	cout << "p1的年龄为：" << *p1.m_Age << endl;

	cout << "p2的年龄为：" << *p2.m_Age << endl;

	cout << "p3的年龄为：" << *p3.m_Age << endl;
}

int main() {

	test01();

	//int a = 10;
	//int b = 20;
	//int c = 30;

	//c = b = a;
	//cout << "a = " << a << endl;
	//cout << "b = " << b << endl;
	//cout << "c = " << c << endl;

	system("pause");

	return 0;
}

9.4.5 关系运算符重载

**作用：**重载关系运算符，可以让两个自定义类型对象进行对比操作

示例：

class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	};

	bool operator==(Person & p)
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	bool operator!=(Person & p)
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
		{
			return false;
		}
		else
		{
			return true;
		}
	}

	string m_Name;
	int m_Age;
};

void test01()
{
	//int a = 0;
	//int b = 0;

	Person a("孙悟空", 18);
	Person b("孙悟空", 18);

	if (a == b)
	{
		cout << "a和b相等" << endl;
	}
	else
	{
		cout << "a和b不相等" << endl;
	}

	if (a != b)
	{
		cout << "a和b不相等" << endl;
	}
	else
	{
		cout << "a和b相等" << endl;
	}
}


int main() {

	test01();

	system("pause");

	return 0;
}

9.4.6 函数调用运算符重载

• 函数调用运算符 () 也可以重载
• 由于重载后使用的方式非常像函数的调用，因此称为仿函数
• 仿函数没有固定写法，非常灵活

示例：

class MyPrint
{
public:
	void operator()(string text)
	{
		cout << text << endl;
	}

};
void test01()
{
	//重载的（）操作符 也称为仿函数
	MyPrint myFunc;
	myFunc("hello world");
}


class MyAdd
{
public:
	int operator()(int v1, int v2)
	{
		return v1 + v2;
	}
};

void test02()
{
	MyAdd add;
	int ret = add(10, 10);
	cout << "ret = " << ret << endl;

	//匿名对象调用  
	cout << "MyAdd()(100,100) = " << MyAdd()(100, 100) << endl;
}

int main() {

	test01();
	test02();

	system("pause");

	return 0;
}