C++：重载函数的注意事项

---

1. 形参名字

#include <iostream>
using namespace std;
class A
{
public:
    //形参是i
    int f(int i)
    {
        cout << "int f(int i)" << endl;
        return 0;
    }

    //形参是n
    int f(int n)
    {
        cout << "int f(int n)" << endl;
        return 0;
    }

    //形参无名字
    int f(int)
    {
        cout << "int f(int)" << endl;
        return 0;
    }

    //形参无名字，类型Int只是int的别名
    typedef int Int;
    int f(Int)
    {
        cout << "int f(Int)" << endl;
        return 0;
    }
};

int main()
{
    A a;
    int i = 1;
    a.f(i);
    return 0;
}

1. 形参名字仅仅起帮助记忆的作用，它对形参列表的内容无影响。
2. 实例中4个函数都是等价的，在程序中只能使用1个，否则会出现函数重复声明的错误。

int f(int i)
int f(int n)
int f(int)
int f(Int)

2. 返回类型

#include <iostream>
using namespace std;
class A
{
public:
    //返回类型是int
    int f(int i)
    {
        cout << "int f(int i)" << endl;
        return 0;
    }

    //返回类型是const int
    const int f(int i)
    {
        cout << "const int f(int i)" << endl;
        return 0;
    }

    //返回类型是double
    double f(int i)
    {
        cout << "double f(int i)" << endl;
        return 0;
    }
};

int main()
{
    A a;
    int i = 1;
    const int ci = 2;
    double d = 3.14;
    a.f(i);
    a.f(ci);
    a.f(d);
    return 0;
}

1. 函数三要素：返回类型、函数名、形参类型。
2. 不允许两个函数除返回类型外其它所有要素都相同，即不能通过返回类型区分两个函数。
3. 实例中3个函数都是等价的，在程序中只能使用1个，否则会出现函数重复声明的错误。

int f(int i)
const int f(int i)
double f(int i)

3. 形参本身是const

#include <iostream>
using namespace std;
class A
{
public:
    //形参类型是int
    int f1(int i)
    {
        cout << "int f(int i)" << endl;
        return 0;
    }
    //形参类型是const int
    int f1(const int i)
    {
        cout << "int f(const int i)" << endl;
        return 0;
    }

    //形参类型是int *
    int f2(int *i)
    {
        cout << "int f(int *i)" << endl;
        return 0;
    }
    //形参类型是int *const
    int f2(int *const i)
    {
        cout << "int f(int *const i)" << endl;
        return 0;
    }
};

int main()
{
    A a;
    int i = 1;
    const int ci = 2;
    int *p1 = &i;
    int *const p2 = &i;
    a.f1(i);
    a.f1(ci);
    a.f2(p1);
    a.f2(p2);
    return 0;
}

1. 顶层const即本身是常量，底层const即指向的对象是常量。
2. 实参初始化形参时，形参的顶层const会被忽略，即无法通过判断形参是否是顶层const来区分函数。
3. 实例中，两个f1是没有区别，编程时只能任选一个，两个f2也是没有区别，只能任选一个。

int f1(int i)
int f1(const int i)
int f2(int *i)
int f2(int *const i)

4. 形参是指向const

#include <iostream>
using namespace std;
class A
{
public:
    //形参类型是int*
    int f(int *i)
    {
        cout << "int f(int *i)" << endl;
        return 0;
    }
    //形参类型是const int *
    int f(const int *i)
    {
        cout << "int f(const int *i)" << endl;
        return 0;
    }

    //形参类型是int &
    int f(int &i)
    {
        cout << "int f(int &i)" << endl;
        return 0;
    }
    //形参类型是const int &
    int f(const int &i)
    {
        cout << "int f(const int &i)" << endl;
        return 0;
    }
};

int main()
{
    A a;
    int i = 1;
    const int ci = 2;
    int *p1 = &i;
    const int *p2 = &i;
    a.f(p1); //p1指向int，所以重载int f(int *i)
    a.f(p2); //p2指向const int，所以重载int f(const int *i)
    a.f(i);  //i是int，所以重载int f(int &i)
    a.f(ci); //ci是const int，所以重载int f(const int &i)
    return 0;
}

1. 若形参是指向const的指针或引用，底层const不可忽略，即可通过判断实参是否指向const选择重载函数。
2. 若形参是指向const的指针或引用，函数可以接受常量或非常量的实参。若形参指向或引用的不是const，函数只能接受非常量的实参。
3. 实例中4个函数都是不同的，根据实参的不同决定重载对象的函数。

int f(int *i)
int f(const int *i)
int f(int &i)
int f(const int &i)

5. 常量成员函数

#include <iostream>
using namespace std;
class A
{
public:
    //普通成员函数
    int f1(int i)
    {
        cout << "int f1(int i)" << endl;
        return 0;
    }
    //常量成员函数
    int f2(int i) const
    {
        cout << "int f2(int i) const" << endl;
        return 0;
    }

    //普通成员函数
    int f3(int i)
    {
        cout << "int f3(int i)" << endl;
        return 0;
    }
    //常量成员函数
    int f3(int i) const
    {
        cout << "int f3(int i) const" << endl;
        return 0;
    }
};

int main()
{
    int i = 1;
    A a;
    const A ca;
    //类的对象不是常量时，可以调用常量或非常量的成员函数
    a.f1(i);
    a.f2(i);
    //类的对象是常量时，只能调用常量成员函数
    // ca.f1(i); //错误
    ca.f2(i);
    cout << "---------------------------" << endl;

    //重载函数
    a.f3(i);
    ca.f3(i);

    return 0;
}

1. 常量对象，及对它的引用和指针只能调用常量成员函数。可通过区分类的对象是否是常量决定重载函数。