操作符重载

一.不能被重载的操作符

？： C++中无定义一个三目运算符的语法

.      安全性

*     安全性

：： 该操作符左边是一个类型名，不是一个表达式

二.<返回值类型> operator <运算符> (<形式参数表>)

1.重载一个一元操作符，其函数不需要任何参数

2.操作符重载，不改变优先级和结合性

3.重载不改变操作符的语法

4.一元重载仍是一元，二元重载仍是二元

#include <iostream>
using namespace std;

class Pair
{
public:
    Pair(int x, int y)
    {
        p1 = x; p2 = y;
    }
    
    bool operator==(const Pair &p)
    {
        return p1 == p.p1 && p2 == p.p2;
    }

private:
    int p1, p2;
};


int main()
{
    Pair s1(1, 2), s2(2, 3);
    cout << boolalpha << (s1 == s2) << endl;//false
    return 0;
}

#include <iostream>
using namespace std;

class Complex
{
public:
    Complex()
    {
        real = 0;
        imag = 0;
    }
    
    Complex(double r)
    {
        real = r;
        imag = 0;
    }

    Complex(double r, double i)
    {
        real = r;
        imag = i;
    }

    Complex operator+(const Complex &c) const
    {
        Complex s;
        s.real = real + c.real;
        s.imag = imag + c.imag;
        return s;
    }

    Complex operator-(const Complex &c)
    {
        Complex s;
        s.real = real - c.real;
        s.imag = imag - c.imag;
        return s;
    }

    double real, imag;
};


int main()
{
    Complex s1(1, 2), s2(2, 3);
    Complex s = s1 + s2;
    cout << s.real << " " << s.imag << endl;//3 5
    return 0;
}

三.用顶层函数进行操作符重载

1.以顶层函数进行操作符重载必须在它的参数表中包含一个类对象，new, new[], delete, delete[]除外。没有类对象，如：void operator%(float f1, float f2)//error，x % y不能区别%是内建操作符还是用户定义的。

2.对于成员函数重载二元操作符，只需要一个参数。对顶函数需要2个。

[], =, ()（函数调用操作符）, ->必须以类成员函数重载

void operator[](int i, Point &s);//error

因为9[x], 6.2 = x是不允许的

3.

Complex operator+(const Complex &c) const{......}

Complex a, b(4.3, -8.2);
a = b + 54.3;//ok，转型构造
a = 54.3 + b; //error,54.3.operator+(b)

Complex operator+(const Complex &c, const Complex &b) {......}

Complex a, b(4.3, -8.2);
a = b + 54.3;//ok
a = 54.3 + b; //ok

4.顶层：非对象操作数可出现在操作符左边

   类成员函数：第一个操作数必须是类对象

5.可把顶层函数设成类的friend

四.friend

类的friend函数可以访问私有成员和保护成员，但不是类的成员函数

建议仅在重载操作符时使用friend

1.friend函数可以是另一个类的成员函数

class Date;

class Time
{
public:
    void display(){}
};

class Date
{
    friend void Time::display();
};

2.友元类

class A{};

class B
{
    friend A;
};

#include <iostream>
using namespace std;

class CCar
{
private:
    int price;
    friend class CDriver;
};

class CDriver
{
public:
    CCar myCar;
    void ModifyCar()
    {
        myCar.price = 200;
    }
};

int main()
{
    return 0;
}

A是B的友元类，类B所有的成员可以被A访问

friend是单向的，friend不能传递，不能继承

#include <iostream>
using namespace std;

class  CCar;

class CDriver
{
public:
    void ModifyCar(CCar *pCar);
};

class CCar
{
public:
    CCar()
    {
        price = 100;
    }
    CCar(int i)
    {
        price = i;
    }
    friend int MostExpensiveCar(CCar cars[], int total);
    friend void CDriver::ModifyCar(CCar *pCar);
private:
    int price;
};

void CDriver::ModifyCar(CCar *pCar)
{
    pCar->price += 100;
}

int MostExpensiveCar(CCar cars[], int total)
{
    int tmpMax = -1;
    for (int i = 0; i < total; ++i)
    {
        if (cars[i].price > tmpMax)
        {
            tmpMax = cars[i].price;
        }
    }
    return tmpMax;
}

int main()
{
    CCar cars[100];
    CDriver d;
    
    d.ModifyCar(&cars[99]);

    cout << MostExpensiveCar(cars, 100) << endl;//200

    return 0;
}