C++：运算符重载

C++：运算符重载

一、+号运算符重载

#include <iostream>
#include <string>
using namespace std;

class Person
{
    friend Person operator+(const Person& p1, const Person& p2);
public:
    Person(){};
    Person(int var1, int var2): m_var01(var1), m_var02(var2){};
    
    // 运算符重载可实现函数重载
	Person operator+(const int& num)
	{
		Person tmp;
		tmp.var01 = this->var01 + num;
		tmp.var02 = this->var02 + num;
		return tmp;
	}

    void Show() const
	{
		cout<<"var01 = "<<this->var01<<endl;
		cout<<"var02 = "<<this->var02<<endl;
	}

private:
	int m_var01;
	int m_var02;
};

// 利用全局函数实现运算符重载
Person operator+(const Person& p1, const Person& p2)
{
	Person tmp;
	tmp.var01 = p1.var01 + p2.var01;
	tmp.var02 = p1.var02 + p2.var02;
	return tmp;
}

// 利用全局函数实现运算符重载
void test01()
{
	Person p1(10, 10);
	Person p2(20, 20);
	// 简化模式调用
	Person p3 = p1 + p2; // 本质模式调用 Person p3 = operator+(p1, p2);
	p3.Show();
}

// 运算符重载可同时发生函数重载
void test02()
{
	Person p1(10, 20);
    // 简化模式调用
	Person p2 = p1 + 20; // 本质模式调用 Person p2 = p1.operator+(20);
	p2.Show();
}

int main()
{
    test01();
    test02();
    return 0;
}

二、<<运算符重载

#include <iostream>
#include <string>
using namespace std;

//左移运算符(<<)须用全局函数实现
class Person
{
    friend ostream& operator<<(ostream& cout, const Person& p);
public:
    Person(){};
    Person(int ivar01, int ivar02): var01(ivar01), var02(ivar02){};

private:
    int var01;
    int var02;
};

ostream& operator<<(ostream& cout, const Person& p)
{
    cout<<"Person.var01 = "<<p.var01<<endl;
    cout<<"Person.var02 = "<<p.var02<<endl;
    return cout;
}

int main()
{
	Person p1(10, 20);
	Person p2(100, 200);
	cout<<p1<<p2<<endl;
    return 0;
}

二、++运算符重载(前置和后置)

#include <iostream>
#include <string>
using namespace std;

class UserInt
{
    friend ostream& operator<<(ostream& cout, const UserInt& num);
public:
    UserInt()
    {
        this->number = 0;
    }
    UserInt(int inumber): number(inumber){};

    // 前置++无须传参，后置++须一个占位符占位以表示其为后置++

    // 前置++返回值是引用。因此前置++效率高于后置++。
    UserInt& operator++()
    {
        ++this->number;
        return *this;
    }

    // 函数参数传入int占位符，系统自行判断为后置++。返回的是值。
    UserInt operator++(int)
    {
        UserInt tmp = *this;
        ++this->number;
        return tmp;
    }

private:
    int number;
};

ostream& operator<<(ostream& cout, const UserInt& num)
{
    cout<<num.number;
    return cout;
}

int main()
{
	UserInt num01;
	cout<<++num01<<endl;
	cout<<num01<<endl;
	UserInt num02 = 20;
	cout<<num02++<<endl;
	cout<<num02<<endl;
  return 0;
}