1.重载

重载允许创建多个名称相同，但输入不同的函数，这些函数的参数列表不同，可以通过给予不同输入变量调用对应的函数。

函数重载的关键是函数的参数列表。如果两个函数的参数数量和类型相同，同时参数的排列顺序也相同，那么就是同一个函数，不构成重载，它与f返回值和变量名都无关。

void print(const char* str, int width);    //重载1
void print(int i, int width);              //重载2
void print(double d, int width);           //重载3
void print(long l, int width);             //重载4
void print(const char* str);               //重载5

但是，注意以下情况，C++允许对函数末尾的参数，设置初始值，如果出现这种情况，会导致找不到真正的函数实体，报出多个重载函数与参数列表匹配。

void print(const char* str, int width = 0);
void print(const char* str);

2.operator关键字

C++中存在一种便携式的操作，可以将常用的操作符转化为函数，例如+-*/，通过函数的方式，让类的管理更加方便，具体实现方式为：operator符号

2.1.基本介绍

对于正常情况，一元运算符（具有一个输入）建议作为成员函数，二元运算符（具有二个输入）建议为友元函数。

:: ? . .* sizeof 这些操作符不能重载。

= () [] -> 这些操作符不能作为友元重载。

<< >> 这些操作符通常建议作为友元重载，否则无法实现流的连续调用。

2.2.= + - * / 重载

= + - * / 重载格式固定，都只能有一个参数，但类型和返回类型可以不确定。

class test {
public:
    test(int i = 0) :m_num(i) {};
    const test& operator+(int i) {
        m_num += i;
        return *this;
    }
    const test& operator+(const test& other) {    //可以使用不同输入
        m_num += other.m_num;
        return *this;
    }
    const test& operator-(int i) {
        m_num -= i;
        return *this;
    }
    const test& operator*(int i) {
        m_num *= i;
        return *this;
    }
    const test& operator/(int i) {
        m_num /= i;
        return *this;
    }
    const test& operator=(const test& other) {
        m_num = other.m_num;
        return *this;
    }
private:
    int m_num;
};
int main() {
    test t(1);
    t = t + 1;    // 1+1=2
    t = t - 3;    // 2-3=-1
    t = t * 4;  // -1*4=-4
    t = t / 2;  // -4/2=-2
    cout << t.getnum() << endl;
    return 0;
}

2.3.++ -- ! 重载

++和--操作符重载，如果存在参数，代表后++，如果没有参数，代表前++。

! 操作符无法加输入。

class test {
public:
    test(int i = 0) :m_num(i) {};
    const test& operator++() {    //前++
        ++m_num;
        return *this;
    }
    const test& operator++(int) {    //后++
        m_num++;
        return *this;
    }
    const test& operator--() {    //前--
        --m_num;
        return *this;
    }
    const test& operator--(int) {    //后+--
        m_num--;
        return *this;
    }
    bool operator!() {
        return true;
    }
private:
    int m_num;
};
int main() {
    test t(1);
    t++;
    ++t;
    t--;
    --t;
    !t;
    return 0;
}

2.4.() [] 重载

() [] 操作符可以增加任意输入，均可以实现重载。

class test {
public:
    test(int i = 0){
        for (int j = 0; j < 10; j++) {
            m_num[j] = i+j;
        }
    };
    int operator[](int i) {
        return m_num[i];
    }
    int operator()(int i) {
        return m_num[i];
    }
    int operator()(int i,int j) {
        return m_num[i]+ m_num[j];
    }
private:
    int m_num[10];
};
int main() {
    test t(0);
    cout << t[1] << endl;
    cout << t(5) << endl;
    cout << t(5,6) << endl;
    return 0;
}

2.5.<< >> 重载

<< >> 操作的目的是，直接调用当前类，来持续的往流上输入，或者持续的从流中输出，为了保证多个流运算符的连接使用，必须使用友元的方式进行重载，并将流作为返回值。

class test {
public:
    test(int i = 0) : m_num(i) {};
    friend ostream& operator<<(ostream& os, const test& t);
    friend istream& operator>>(istream& is, test& t);
private:
    int m_num;
};
ostream& operator<<(ostream& os, const test& t) {
    os << t.m_num;
    return os;
}
istream& operator>>(istream& is, test& t) {
    int i;
    cin >> i;
    t.m_num = i;
    return is;
}
int main() {
    test t1(10);
    test t2(2);
    cout << t1 << t2;
    cin >> t1 >> t2;
    return 0;
}

2.6.-> 指针重载

-> 不允许带输入，也可以不输出指针。

class base {
public:
    void print() {
        cout << "base" << endl;
    }
};

class test {
public:
    base* operator->() {
        return m_base;
    }
private:
    base* m_base;
};
int main() {
    test t1;
    t1->print();
    return 0;
}