Skip to main content

运算符重载

基本概念​

运算符重载，就是对已有运算符进行重新进行定义，赋予其另一种功能，以适合不同的数据类型。

语法：定义重载的运算符就像定义函数，只是该函数的名字是 operator@， 这里的 @ 就代表被重载的运算符。

思路：

1、弄懂运算符的运算对象的个数（个数决定了重载函数的个数）

2、识别运算符的运算对象，是类的对象，还是其他对象

  1. 类的对象：全局函数实现（不推荐）
  2. 成员函数实现（少一个参数, +或者-重载一般都用成员运算符）
  3. 其他：只能是全局函数实现

重载 << 运算符（全局函数实现）​

如果使用全局函数，重载运算符，必须将全局函数设置成友元

class Person
{
    friend ostream& operator<<(ostream& cout, Person& p);
private:
    int num;
    string name;
    float score;
public:
    Person(){}
    Person(int num, string name, float score):num(num), name(name), score(score){}
};

ostream& operator<<(ostream &out, Person &p)
{
    out << p.num << " " << p.name << " " << p.score << endl;
    return out;
}

int main()
{
    Person luck(100, "luck", 99.8f);
    Person bob(101, "bob", 99.8f);
    cout << luck << bob << endl;
}

重载 >> 运算符（全局函数实现）​

前面我们已经重载了 << 运算符，这里我们就重载 >> 运算符

istream& operator>>(istream &in, Person &p)
{
    in >> p.num >> p.name >> p.score;
    return in;
}

int main()
{
    Person luck;
    Person bob;
    cin >> luck >> bob;
}

重载 + 全局函数实现​

Person operator+(Person &p1, Person &p2)
{
    Person temp;
    temp.num = p1.num + p2.num;
    temp.name = p1.name + p2.name;
    temp.score = p1.score + p2.score;
    return temp;
}

重载 + 成员函数实现​

注意，下面的函数是在类内定义的：

Person operator+(Person &p)
{
    Person temp;
    temp.num = this->num + p.num;
    temp.name = this->name + p.name;
    temp.score = this->score + p.score;
    return temp;
}

重载 == 运算符 全局函数实现​

bool operator==(Person &p1, Person &p2)
{
    if (p1.num == p2.num && p1.name == p2.name && p1.score == p2.score)
    {
        return true;
    }
    return false;
}

重载 == 运算符 成员函数实现​

bool operator==(Person &p)
{
    if (this->num == p.num && this->name == p.name && this->score == p.score)
    {
        return true;
    }
    return false;
}

重载 ++/-- 运算符​

重载的++和--运算符让人有点不知所措，因为我们总是希望能根据它们提出的所在作用对象的前面还是后面来调用不同的函数。解决办法很简单，例如当编译器看到 ++a （前置++）, 它就调用 operator++(a)（后置++）,它就会去调用 operator++(a, int).

重载后置++​

Person operator++(int)
{
    // 保存原始数据
    Person temp = *this;
    // 操作数据
    this->num++;
    this->name += this->name;
    this->score++;
    return temp;
}

重载前置++​

Person& operator++()
{
    this->num++;
    this->name += this->name;
    this->score++;
    return *this;
}