C++ day11 (二) 默认参数，函数重载

向右看齐 2023-07-12 03:50 11阅读 0赞

本文的内容都是C++在C基础上新增的内容

### 文章目录 ###

*  默认参数 （一个便捷工具）
 *   *  示例1 取字符串前几个字符（if和while一字之差，我竟写出一个有内存泄漏风险的漏洞）（尝试了一把优化）
 *  函数重载（即函数多态）
 *   *  特征标（函数的参数列表）使得可以函数重载
     *   *  要点1 类型和原型不匹配可以强制转换，但如果可转换的类型多于1个，则C++和编译器都表示拒绝
         *  要点2 类型引用和类型本身被编译器视为相同特征标（我们看起来不同的特征标，编译器可能看起来一样）
         *  要点3 有点麻烦的const参数
         *  要点4 引用参数的重载（类和STL中会频频使用）
         *  要点5 特征标和函数名相同，但返回类型不同，不叫重载且不被允许
     *  示例2 写一个跟示例1的left重载的函数，返回正整数的前几位
     *  编译器通过名称校正，根据参数列表对函数名进行加密，以辨识不同重载函数

# 默认参数 （一个便捷工具） #

默认参数是C++在C基础上新增的，不算什么重大的编程技术突破，但确实是一个很方便的工具，利用它可以帮我们在设计类时减少要定义的析构函数，方法，以及方法的重载数量。还有其他一些场景有了默认参数会很方便。

默认参数，顾名思义，就是函数调用时不写这个参数，函数也会认为我写了参数，值是默认值。现在回顾才发现其实matlab很多函数都有用默认参数啊。所以好的编程特性一定会在多种语言中同时存在，大家都会借鉴。

那么怎么设置默认参数呢? 通过在函数原型中写好默认参数的值就好了，而**函数定义和没有默认值时完全一样**。

但是！对于带参数列表的函数，必须从右到左添加默认值。即，要给一个参数赋默认值，则它右边的参数都得有默认值。

这是因为实参会被从左到右的依次赋给形参，不能跳过任何一个形参，如果你的默认参数不从右到左，则实参和形参的赋值将不匹配。

下面的例子可以看到，默认参数可以让你**用不同数目的参数调用同一个函数。**

int harpo(int n, int m = 4, int j = 5);//正确，harpo函数在调用时可以只输入一个参数，或者2个，或者3个
    int chico(int n, int m = 4, int j);//错误，chico(1, 2)将使得n=1,m=2，而j没有赋值，调用失败
    int groucho(int n =2, int m = 3, int j =4);//正确，可以输入0,1，2,3个参数

## 示例1 取字符串前几个字符（if和while一字之差，我竟写出一个有内存泄漏风险的漏洞）（尝试了一把优化） ##

我也可以叫做hole writter了。。。。

#include <iostream>
    char * left(const char *st, int n = 1);
    const int Arsize = 80;
    
    int main()
    { 
        using std::cin;
        using std::cout;
        using std::endl;
    
        char sample[Arsize];
        char * ps;
    
        cout << "Enter a string:\n";
        cin.get(sample, Arsize);
        ps = left(sample, 4);
        cout << ps << endl;
        delete [] ps;//没有方框则只释放第一个字符
    
        ps = left(sample);//默认参数
        cout << ps << endl;
        delete [] ps;
    
        return 0;
    }
    
    char * left(const char *st, int n)
    { 
        //首先处理错误输入，好习惯，输入负值就返回空指针
        if (n < 0)
            n = 0;
        char *ps = new char[n + 1];
        int i;
        for (i = 0; i < n && st[i]; ++i)//条件很棒，解决了n大于字符串长度的情况
        { 
            ps[i] = st[i];
        }
        while (i <= n)
            ps[i] = '\0';
    
        return ps;
    }

我要记录一个我的小聪明，一个错误的小聪明，即函数的末尾，我觉得没必要用while，直接把末尾第一个赋为空字符不就好了，字符串就结尾啦，我这么做了，程序确实可以正常运行，咩出问题，但是后面我突然发现，这里面有一个很大的漏洞，只是我的测试用例没出现这个问题罢了：这可能导致一部分内存泄漏！！！因为我分配的内存长度是n+1，但是如果n大于字符串长度，即最后i不等于n,而是小于n，则我只把ps\[i\]设置为空字符，却不管后面的，则回到主函数释放ps的时候，也不会释放ps\[i+1\]到ps\[n\]这段内存！！！！

幸好发现了，这个问题是比较不容易发现的错误，而且多数情况下不会出错，但是确实又有使得内存泄漏而使得程序崩溃的可能，if和while一字之差，竟然可以惹出如此大祸，妙哉！

Enter a string:
    Victory belongs to those that believe in it the most, and believe in it the longest.
    Vict
    V

当我把第一次调用的参数设置为-4，则第一次调用的显示结果是啥也没有，毕竟是空指针嘛，就是空字符串

Enter a string:
    Victory belongs to those that believe in it the most, and believe in it the longest.
    
    V

或者把函数这么写，先把长度n求出来，后面就只管安心赋值，但是一样还是要判断n的正负哦。这样需要用cstring类的strlen函数，这会使得程序变长，降低运行速度，但是可以保证不会多分配内存。

char * left(const char *st, int n)
    { 
        int len = strlen(st);
        n = (n < len) ? n : len;
        if (n < 0)
            n = 0;
        char *ps = new char[n + 1];//这样分配的内存就不会多
    
        int i;
        for(i = 0; i < n; ++i)
            ps[i] = st[i];
        ps[n] = '\0';
    
        return ps;
    }

#include <cstring>

由于strlen函数可能使得程序的速度降低，所以我们可以自己用一个while来实现它，这又是一层优化

char * left(const char *st, int n)
    { 
        int len = 0;
        while (len < n && st[len])
            ++len;
    
        n = len;//n如果原来是负数，现在也是0了，所以这也处理了负的输入
        char *ps = new char[n + 1];//这样分配的内存就不会多
    
        int i;
        for(i = 0; i < n; ++i)
            ps[i] = st[i];
        ps[n] = '\0';
    
        return ps;
    }

# 函数重载（即函数多态） #

函数的多态，即多种形式呗。但是函数重载一词用的更多。重载的是**函数名**。函数重载说得就是让我们可以**使用多个同名函数**。

函数重载就像是多义词，一个词语有多种含义，具体什么含义要用上下文确定、比如root可以指助威，也可以指种植。不同的只是，函数重载时，同名的这些函数一般是做**相同的工作**。

## 特征标（函数的参数列表）使得可以函数重载 ##

既然函数名字相同，必定要用别的信息区分这些函数哇，靠设么呢，靠特征标， function signature，即参数列表。

特征标是函数重载的关键。函数名反而是无关紧要的。必须是参数数目和类型以及排列顺序都完全一样，才是相同的特征标。

举个例子,5个print函数的特征标不同

函数原型

void print(const char *, int);//#1
    void print(double, int);//#2
    void print(long, int);//#3
    void print(int, int);//#4
    void print(const char *);//#5

函数调用,编译器根据参数的类型判断使用哪一个原型

print("godess");//#5
    print(3.0, 4);//#2
    print("mm", 2);//#1
    print(4L, 2);//#3
    print(3, 4);//#4

但是!

### 要点1 类型和原型不匹配可以强制转换，但如果可转换的类型多于1个，则C++和编译器都表示拒绝 ###

下面的这个调用就要出错了，a是无符号int,不和任何原型匹配。无符号int本来可以转换为数值类型int或者double或者long，如果上面的原型中只有一个选择，那编译器就转了然后过了，但是偏偏提供了3种选择，编译器此时并没有什么校验表可以提供优先顺序，于是他只好谁都不选，报错

unsigned int a = 23;
    print(a, 3);

### 要点2 类型引用和类型本身被编译器视为相同特征标（我们看起来不同的特征标，编译器可能看起来一样） ###

要从编译器的角度思考。不要让编译器不知所措，否则他会报错

原型

double cube(double x);
    double cube(double &x);

调用

cube(x);//编译器蒙了，到底用谁，于是报错

### 要点3 有点麻烦的const参数 ###

其实不复杂，就是看能不能转换为可以匹配的原型罢了，总结而言：

*  1.原型中参数是const，则const参数当然可匹配该原型；
 *  2.原型中参数是const，而参数是非const，则如果还有一个重载函数提供了非const原型，自然要和这个非const原型匹配 ，如果没有这样的重载函数，则就会和这个const参数的原型匹配；
 *  3.原型中参数不是const，则const参数不可以匹配该原型，**毕竟不能把const赋给非const**，很好理解
 *  4.原型中参数不是const，则非const参数当然可匹配该原型；

比如，原型

void dribble(char *);
    void dribble(const char *);
    void dabble(char *);
    void drivel(const char *);

调用

dribble("m");//const char *
    char a[10] = "ok";
    dribble(a);//char *
    
    dabble(a);//char *
    dabble("b");//报错，没有匹配原型
    
    drivel("b");//const char *
    drivel(a);//由于没有char *版本，所以和const char * 原型匹配，不报错

### 要点4 引用参数的重载（类和STL中会频频使用） ###

这里也会涉及一点const，但是也很简单，反正就是能转换就行，不能转换就不行

引用参数的重载是很重要的，因为类和STL中频频使用引用参数的重载。

这时候我们把参数分为三种：可修改的左值（即常规变量），不可修改的左值（即const变量），右值（即常量）。其中前两个都是变量，但是由于涉及const必须单独讨论，所以分为三类了。编译器会先找最匹配的原型，如果没有，会看看有没有次之的可以转换的，比如对于常量值，如果没有double &&版本的原型就找有没有const double &，也没有就报错了

看下面的原型：

void staff(double &);//匹配可修改的左值
    void staff(const double &);//匹配不可修改的左值
    void staff(double &&);//匹配右值

调用

double a = 3.2;
    const double b = 2.3;
    staff(a);//double &
    staff(b);//const double &
    staff(a + b);//double &&,如果没有double &&的原型，则匹配const double &

### 要点5 特征标和函数名相同，但返回类型不同，不叫重载且不被允许 ###

抓住核心概念：是特征标使得函数重载可以实现，而不是函数类型。所以只要特征标一样，说啥都白搭，就是不叫重载。返回类型不重要，**返回类型是否不一样根本不影响是否重载。**

比如下面两个原型，他们是互斥的，编译器报错

long gronk(int , double);
    int gronk(int , double);

这也是函数重载

int cat(int);
    double cat(double);

## 示例2 写一个跟示例1的left重载的函数，返回正整数的前几位 ##

函数

unsigned int left(unsigned int num, unsigned int ct)
    { 
        //记住，进入函数先保证输入合法正确，不会对后面造成影响
        //我之前没处理两种0，造成运行时错误
        if (num == 0 || ct == 0)
            return 0;
    
        int temp = num;
        int digits = 1;
    
        while (temp /= 10)
            ++digits;//总位数
        if (digits > ct)
        { 
            ct = digits - ct;//要删除的位数
            temp = num;
            while (ct--)
                temp /= 10;
            return temp;
        }
        else
            return num;
    
    }

## 编译器通过名称校正，根据参数列表对函数名进行加密，以辨识不同重载函数 ##

前面说了编译器分清两个重载函数是依靠特征标，即参数列表，现在我们更加深入的分析具体是怎么做的，很底层的知识哦，有没有很激冻。

名称校正name mangling，或者名称修饰name decoration, 就是把函数头翻译为特殊的符号，好给编译器看，让他能看懂。  
比如：  
函数原型

long myFunctionFoo(int, float);

这是我们人类看得懂的形式，编译器不懂，所以编译器要翻译一下，或者说是编码吧，即把名称校正/修饰为

?myFunctionFoo@@YAXH

也就是说，long返回值类型被翻译为问号，用？标识，编译器一看到表示函数名的前面的字符是问号，就明白了返回值类型是long，然后看到函数名后面后一个@和 一个@YAXH,分别表示int和float参数类型，于是编译器就知道了形参的类型，数目，顺序。

当然啦，具体使用什么约定，不同编译器可能会不一样。

后来添加：

今天遇到一个错误，误打误撞发现了名称修饰！！这个函数名是myprint,原型是void myprint();

可以看到我的编译器把他修饰为了Z7myprintv，前面加了Z7，表示返回值类型是void，后面加了v，表示没有参数  
![在这里插入图片描述][20200311160319325.png]

[20200311160319325.png]: https://img-blog.csdnimg.cn/20200311160319325.png