C++第05课 运算符重载

1.基本重载

+ 友元函数的方式实现重载
+ 类成员函数的方式实现重载

重载函数的基本语法: 重载函数的返回值类型 operator 要重载的运算符(参数){函数体;};

参数个数:

+ 友元重载 重载函数的参数个数等于运算符的操作数
+ 类成员函数重载，重载函数参数个数是等于运算符的操作数-1

 

class MM {
    //友元重载+
    friend MM operator+(MM obj1, MM obj2);
public:
    MM() {}
    MM(string name,int age):name(name),age(age){}
    //类的成员函数重载-
    MM operator-(MM obj);
    void print() {
        cout << name << "\t" << age << endl;
    }
protected:
    string name;
    int age;
};
MM operator+(MM obj1, MM obj2)
{
    return MM(obj1.name + obj2.name, obj1.age + obj2.age);
}
MM MM::operator-(MM obj)
{
    return MM(this->name, this->age - obj.age);
}

int main()
{
    MM mm("小可爱", 14);
    MM mm1("小宝贝", 18);
    MM obj = mm + mm1;    //等价于：MM obj=operator+(mm+mm1);
    obj.print();    //小可爱小宝贝    32
    MM obj1 = mm1 - mm;    //等价于：MM obj=mm1.operator-(mm);
    obj1.print();    //小宝贝  4
    //cout << obj << endl;
    return 0;
}

注意项:

　　1.习惯上，单目采用类的成员函数重载，双目采用友元方式重载

　　2.一般在重载运算符的时候，尽量不要违背本意(加法就是加法，不要把加法重载减法的效果)

　　3.有些运算符不能重载： ?: . :: # .* ->*

　　4.有些运算符必须采用类成员函数重载:() [] =

　　5.流重载必须采用友元重载

2.特殊重载

+ ++ -- 前置和后置的一个重载
+ 后置的++ 或者--  一定要加个int作为标记

class Num {
public:
    Num(int num=0) :num(num) {}
    void print()
    {
        cout << num << endl;
    }
    //前置++
    Num operator++();
    //后置++
    Num operator++(int);
protected:
    int num;
};
Num Num::operator++()
{
    return Num(this->num++);
}
Num Num::operator++(int)
{
    return Num(this->num++);
}

int main()
{
    Num a(1);
    Num b = a++;
    b.print();
    Num c = ++a;
    c.print();
    return 0;
}

+ 流运算符重载
+ 流对象: ostream : 输出流 cout就是ostream类的对象 istream：输入流， cin就是istream类的对象
+ 流重载 ，必须采用的引用的方式，必须采用友元的方式

class MM {
    //友元实现
    friend ostream& operator<<(ostream& out, MM& mm);
    friend istream& operator>>(istream& in,MM& mm);
public:
    MM() {}
    MM(string name, int age) :name(name), age(age) {}
    //类的成员函数实现
protected:
    string name;
    int age;
};
ostream& operator<<(ostream& out, MM& mm)
{
    out << mm.name << "\t" << mm.age;
    return out;
}
istream& operator>>(istream& in, MM& mm) {
    in >> mm.name >> mm.age;
    return in;
}
int main()
{
    MM mm;
    cin >> mm;                //cin:istream
    cout << mm << endl;        //cout:ostream
    return 0;
}

+ 后缀的重载(文本重载)

//后缀重载    文本重载
unsigned long long operator"" _h(unsigned long long num)
{
    return num * 60 * 60;
}
int main()
{
    int a = 1_h;
    cout << a << endl;    //3600
    return 0;
}

3.隐式转换

实现对象与其他类型的一个隐式转换

基本语法: operator 要转的类型() { return 返回相应类型的数据;};

//隐式转换
class GG {
public:
    GG() {}
    GG(string name, int age) :name(name), age(age) {}
    //基本语法: operator 要转的类型() { return  返回相应类型的数据;};
    operator int()
    {
        return this->age;
    }
protected:
    string name;
    int age;
};
int main()
{
    GG gg("小可爱", 19);
    int num = gg;    //自定义类型不存在赋值的直接隐式转换，需要自己写
    cout << num << endl;
    return 0;
}