跳至正文
View Categories

2 min read

主要内容 #

1. 为什么需要重载 #

示例程序：

int compare(int a, int b)
{
    return a>b ? a:b;
}
int main()
{
    int d(2),a(1),s(21),h(14),i(90),m(-5);
    cout << compare(a, b);

    cout << compare(1, 2.5);    // 【错误】 2.5 是 double 类型，不能传递给 b，这里会发生强制类型转化，导致小数部分丢失。
    cout << compare(1, 2, 3);   // 【错误】 compare 只接受 3 个参数，编译无法通过
    cout << compare(-5, true);  // 【错误】 参数类型不对
    cout << compare(-5, 'A');   // 【错误】 参数类型不对
    ...
}

思考：
如果，要接受上述的这种调用方式，那应该怎么办呢？
请看例子

int compare(int a, int b)
{
    return a>b ? a:b;
}
double compare(int a, double b)
{
    return a>b ? a:b;
}
double compare(double a, int b)
{
    return a>b ? a:b;
}
double compare(double a, double b)
{
    return a>b ? a:b;
}
int compare(int a, bool b)
{
    return a>b ? a:(int)b;
}
int compare(int a, char b)
{
    return a>b ? a:(int)b;
}
int main()
{
    int d(2),a(1),s(21),h(14),i(90),m(-5);
    cout << compare(a, b);

    cout << compare(1, 2.5);    // 
    cout << compare(1, 2, 3);   // 每一种函数就可以
    cout << compare(-5, true);  // 
    cout << compare(-5, 'A');   // 
    ...
}

我们来观察一下以上这些函数的函数签名

int    compare(int a,    int b)
double compare(int a,    double b)
double compare(double a, int b)
double compare(double a, double b)
int    compare(int a,    bool b)
int    compare(int a,    char b)

以上的这些函数，它们的函数名是相同。这种类型的函数定义方法，称为“函数的重载”。
重载的规则：

  • 重载，本质上是定义了一个新的函数
  • 重载，要么形参的类型不同，要么形参的数量不同。
  • 输出类型不同，不能重载

    • 为了更好的理解上述的规则，我们来做几个习题。

    2. 判断题 #

    1. 请问下面的两个函数是重载吗？

    int max_val(int a, int b)
{
    return a>b ? a:b;
}

int max_value(int a, int b)
{
   return a>b ? a:b;
}

    参考答案

    /*


no，名字不同
*/

    2. 请问下面的两个函数是重载吗？

    int max_val(int a, int b)
{
   return a>b ? a:b;
}

int max_val(int a, int b, double c)
{
   ……
}

    参考答案

    /*


yes
*/

    3. 请问下面的两个函数是重载吗？

    int max_val(int a, int b)
{
   return a>b ? a:b;
}

double max_val(int a, int b)
{
   ……
}

    参考答案

    /*


no，返回类型不同，不能作为重载函数
*/

    4. 请问下面的两个函数是重载吗？

    int max_val(int a, int b)
{
    return a>b ? a:b;
}

int max_val(int b, int a)
{
    ……
}

    参考答案

    /*


no，形参的名字不同，不能作为重载函数。只有类型不同才可以。它们的函数签名是相同的，都是：int max_val(int, int)
*/

    5. 请问下面的两个函数是重载吗？

    int max_val(int a, int b)
{
    return a>b ? a:b;
}

int max_val(char ch, int b, int a)
{
   ……
}

    参考答案

    /*


yes
*/

    6. 请问下面的两个函数是重载吗？

    int max_val(int a, int b)
{
    return a>b ? a:b;
}

int max_val(const int a, int b)
{
   ……
}

    参考答案

    /*


no, const 仅作为修饰符
*/

    7. 请问下面的两个函数是重载吗？

    int max_val(int a, int b)
{
   return a>b ? a:b;
}

int max_val(int* a, int b)
{
   ……
}

    参考答案

    /*

yes
*/

    8. 请问下面的两个函数是重载吗？

    int max_val(int a, int b)
{
   return a>b ? a:b;
}

int max_val(int a[], int b)
{
   ……
}

    参考答案

    /*

yes
*/

    9. 请问下面的两个函数是重载吗？

    int dashima(int a, int b, int res)
{
    // some code
}

int dashima(int a, int b, int& res)
{
    // some code
}

    参考答案

    /*


yes！但是要分情况讨论！！
*/

    请看例子：

    int dashima(int a, int b, int res)
{
    // some code
}
int dashima(int a, int b, int& res)
{
    // some code
}
int main()
{
    dashima(4, 5, 6);     // 调用 int dashima(int, int, int)

    const int da=5; 
    dashima(6, 5, da);    // 调用 int dashima(int, int, int)

    int shi;
    dashima(7, 5, shi);   // 【编译出错】存在两个可以匹配的函数 int dashima(int, int, int) 和 int dashima(int, int, int&)

    return 0;
}

    重要说明：

  • 函数中，变量的引用传递，包含了输出参数的含义
  • 所以，当需要输出变量时，使用引用类型的形参。此时，请务必避免去重载函数的值传递版本。

    • 也就是说，对于上述的情况，我们推荐这样写：

    /*
  去除这个版本的函数，不保留 值传递版本 的重载

int dashima(int a, int b, int res)
{
    // some code
}
*/

int dashima(int a, int b, int& res)
{
    // some code
}
int main()
{
    dashima(4, 5, 6);     // 调用 int dashima(int, int, int&)

    const int da=5; 
    dashima(6, 5, da);    // 调用 int dashima(int, int, int&)

    int shi;
    dashima(7, 5, shi);   // 【编译 OK】调用 int dashima(int, int, int&)

    return 0;
}

    习题 #

    课后练习

    What are your Feelings