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

淡淡的烟草味﹌ 2023-05-28 15:51 1阅读 0赞

--------------------

# 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;
    }

![运行错误][format_png_pic_center]

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;
    }

![报错提示][format_png_pic_center 1]

![运行错误][format_png_pic_center 2]

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;
    }

![运行错误][format_png_pic_center 3]

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;
    }

![运行结果][format_png_pic_center 4]

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;
    }

![运行结果][format_png_pic_center 5]

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

[format_png_pic_center]: /images/20230528/01c86a4e20dc4b088792d557593945a2.png
[format_png_pic_center 1]: /images/20230528/56b12dd1a39e4774899eee7823c43a4c.png
[format_png_pic_center 2]: /images/20230528/ffd79371532e40ffb6124b9c62e35d2c.png
[format_png_pic_center 3]: /images/20230528/d2b85371ec5a4a6dacd9663c032298ed.png
[format_png_pic_center 4]: /images/20230528/5da4354a15a34058bf3537af8e502c52.png
[format_png_pic_center 5]: /images/20230528/1c5864c57d2d439baa4679437d63cf03.png