一. 重载

1. 函数重载

目的：实现一组相同函数名，不同参数列表的函数。格式：同名函数，参数列表不同。

//例：设计一个函数，可以返回2~4个变量的和
int Plus(int a, int b) {
    return a + b;
}
int Plus(int a, int b, int c) {
    return a + b + c;
}
int Plus(int a, int b, int c, int d) {
    return a + b + c + d;
}
int main() {
    cout << Plus(1, 2) << endl;
    cout << Plus(1, 2, 3) << endl;
    cout << Plus(1, 2, 3, 4) << endl;
}

2. 运算符重载

目的：自定义类型，系统不知道“+"">"等符号的意义。运算符重载可以教给系统运算符的意义。格式：[返回值类型] operator [运算符] (参数) {重载代码}; 这里实现一个复数类为例。这个操作叫：运算符重载为类的成员函数，在类内定义。

class Complex {  //实现一个复数类
public:
    int Re, Im;  //实部，虚部
    //双目运算符，有一个参数，就是运算符右边的数
    //如 a + b 参数就是b 而a默认是上面定义的Re, Im
    //返回值就是这个类的类型，毕竟加减完类型又不变对吧
    Complex operator + (Complex &b) {
        //假设结果为c
        Complex c;
        c.Re = Re + b.Re; 
        c.Im = Im + b.Im;
        return c;
    }
    Complex operator - (Complex &b) {
        Complex c;
        c.Re = Re - b.Re; 
        c.Im = Im - b.Im;
        return c;
    }
    // * / % += -= /= *= %= |= &= ^= 略，反正就这么个格式
    //[------------------------分割线-----------------------------]
    //比较大小类，唯一和加减类不同的地方是：返回值为bool。因为比较大小，要么真要么假
    bool operator < (Complex &b) { //复数的模比较大小
        double m1 = sqrt(Re * Re + Im * Im); 
        double m2 = sqrt(b.Re * b.Re + b.Im * b.Im);
        return m1 < m2; 
        /*return m1 < m2;  相当于：
        if(m1 < m2)
            return true;  //如果m1<m2，计算机就认为a<b成立
        else
            return false; //反之不成立
        */
    }
    bool operator > (Complex &b) { //复数的模比较大小
        double m1 = sqrt(Re * Re + Im * Im); 
        double m2 = sqrt(b.Re * b.Re + b.Im * b.Im);
        return m1 > m2;
    }
    // < > <= >= == !=都是这样，省略不写了 
    //[------------------------分割线-----------------------------]
    //前后置自增自减。可以认为都没有参数，但是后置运算需要(int)，记住吧
    Complex operator ++() {  //++前置运算符，假设为实部+1
        Complex c;
        c.Re = Re + 1;
        c.Im = Im;
        return c;
    }
    Complex operator ++(int) {  //++后置运算符，假设为实部+1
        Complex c;
        c.Re = Re + 1;
        c.Im = Im;
        return c;
    }
    //[------------------------分割线-----------------------------]
    //重载输入输出流，格式如下
    ostream &operator << (ostream &output) {  
        output << Re << " + " << Im << 'i'; 
        return output;
    }
    istream &operator >> (istream &input) {
        input >> Re >> Im;
        return input;
    }
};

若要求在类外重载，需要多写一个参数a，意义如上文所示。

class Complex {
public:
    int Re, Im;
}
Complex operator + (Complex &a, Complex &b) {  // +号重载，有两个参数
    Complex c;
    c.Im = a.Im + b.Im;
    c.Re = a.Re + b.Re;
    return c;
}
Complex operator ++ (Complex &a) { //前置++
    a.Re ++;
    return a;
}
Complex operator ++ (Complex &a, int) {  //后置++
    a.Re ++;
    return a;
}
ostream &operator << (ostream &output, Complex &b) {
    output << b.Re << " + " << b.Im << 'i';
    return output;
}
istream &operator >> (istream &input, Complex &b) {
    input >> b.Re >> b.Im;
    return input;
}
//其他运算符同理。

重载完之后，系统就知道如何使用运算符运算了。

二. 友元函数

[友元即friend]，可以访问private数据。在正常的函数前加friend修饰即可。

friend Complex operator + (Complex &b) {
    Complex c;
    c.Re = Re + b.Re;
    c.Im = Im + b.Im;
    return c;
}

这样，函数就可以访问类中的私有(private)数据。

三. 构造函数

定义一个类的变量时，自动执行的函数。此函数也可以重载，方式同上。格式：类名(参数表) {代码} 【析构函数】和构造函数相反，析构函数是类的变量内存被释放时，自动执行的函数。

class Complex {
public:
    int Re, Im;
    Complex() {
        Re = 0, Im = 0;
    }
    Complex(int a, int b) {  //构造函数也可以重载
        Re = a, Im = b;
    }
    ~Complex() {
        cout << "bye~";
    }
}
int main() {
    Complex a;
    Complex b(1, 2);
}

四. 进制

进制转换很简单，这里拿十进制转二进制举例子。令待转化的十进制数为x，转出v进制。这里转出二进制，所以v=2。不断对x取模，直到x=0.将每次得到的模数倒过来，就是x的二进制表示。

int bit[100], tot = -1;  //用数组记录每次得到的模数
int v = 2;
while(x > 0) {
    bit[++tot] = x % v;
    x /= v;
}
while(tot >= 0) {
    cout << bit[tot--];
}

这里默认x是10进制数。若输入的不是10进制，则可以按照如下程序转换成10进制。

string num;  cin >> num; //输入的数
int x = 0;
int v = 2; //输入数的进制
for(int i = 0; i < num.size(); i ++) {
    if(num[i] >= '0' && num[i] <= '9')
        x = x * v + num[i] - '0';
    else if(num[i] == 'A' || num[i] == 'a') {
        x = x * v + 10;
    }else if(num[i] == 'B' || num[])
}
//此时x就是10进制数。

提供一份任意进制转任意进制的模板代码。

#include <bits/stdc++.h>
using namespace std;
const char change[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};

int main() {
    //x进制转y进制模板   (2 <= x,y <= 16)
    cout << "请输入待转换数：" << endl;
    string input;  cin >> input; //输入的数
    cout << "请输入此数的进制：" << endl;
    int v;  cin >> v;
    
    int x = 0;
    for(int i = 0; i < input.size(); i ++) {
        if(input[i] >= '0' && input[i] <= '9'){
            x = x * v + input[i] - '0';
        }else if(input[i] == 'A' || input[i] == 'a') {
            x = x * v + 10;
        }else if(input[i] == 'B' || input[i] == 'b') {
            x = x * v + 11;
        }else if(input[i] == 'C' || input[i] == 'c') {
            x = x * v + 12;
        }else if(input[i] == 'D' || input[i] == 'd') {
            x = x * v + 13;
        }else if(input[i] == 'E' || input[i] == 'e') {
            x = x * v + 14;
        }else if(input[i] == 'F' || input[i] == 'f') {
            x = x * v + 15;
        }
    }
    //此时x为10进制数
    char output[1010];
    int tot = -1;  //用数组记录每次得到的模数

    cout << "请输入转出的进制：" << endl;
    cin >> v;
    while(x) {
        output[++tot] = change[x % v];
        x /= v;
    }

    cout << "结果为：" << endl;
    while(tot >= 0) {
        cout << output[tot--];
    }

    return 0;
}