【C++Primer笔记】第六章函数

亦凉 2022-10-29 03:11 174阅读 0赞

### 文章目录 ###

*   *  函数基础
     *  参数传递
     *   *  const形参和实参
         *  数组形参
         *  可变形参
     *  返回类型
     *   *  返回数组指针
     *  函数重载
     *   *  函数匹配
     *  特殊用途语言特性
     *   *  默认实参
         *  内联函数
         *  constexpr函数
         *  调试帮助
     *  函数指针

## 函数基础 ##

1.  **实参传给形参**的规则参见**用右值初始化左值**。因此，（举例）如果有一个形参为`int`，则必须传入一个能转换成`int`的实参（整型、浮点型）。
2.  在C++中，名字有作用域，对象有**生命周期**。一旦函数终止，形参就会被销毁。函数内部的变量也必须被初始化，否则就会被默认初始化为未定义的值。
3.  **局部静态对象**（`static`）直到程序终止才会被销毁。内置类型的局部静态变量可以被隐式地初始化为0。
4.  在函数的声明中可以省略形参的名字。但还是**建议把名字写上**，便于读者理解形参含义。**含有函数声明的头文件应该被包括到函数的源文件中。**

## 参数传递 ##

1.  每次调用函数都会重新创建形参，并用实参初始化形参。当形参是引用类型时，它对应的实参被**引用传递**；当实参的值被拷贝给形参时，实参被**值传递**。
2.      void reset(int *ip)
        {
        	*ip = 0; //改变了ip所指对象的值
        	ip = 0; //并不改变指针ip的值
        }
        reset(&i); //调用
        //如果形参是引用，调用时就只用写reset(i)
    
    **在C++中，建议使用引用类型的形参代替指针。**
3.  传引用参数的作用：
    
     *  **使用引用避免拷贝**。当某种类型不支持拷贝操作、或需要拷贝的对象可能非常大（如`string`类型）时，应使用引用形参。如果无需改变实参内容，应使用`const`。
     *  **使用引用形参返回额外信息**。有时函数需要多个返回值，引用形参为我们一次返回多个结果提供了有效的途径（你懂的）。

### const形参和实参 ###

> 形参的初始化方式和变量的初始化方式是一样的，回顾通用的初始化规则有助于理解本节知识。

1.  当用实参初始化形参时，会忽略掉顶层`const`（作用于对象本身的常量属性）。**所以给形参添加顶层`const`属性并不能构成函数重载**（因为传入这两个函数的实参可以完全一样：常量或非常量）。
2.  **可以使用非常量初始化底层`const`对象，但反之则不行（引用同理）。**
3.  一个普通的引用必须用**同类型**的对象初始化。不能把普通引用绑定到字面值上，不过常量引用可以（或者就一个`string`型）。
4.  我们为什么要**把函数不会改变的形参定义为常量引用**？除了提醒人们函数内不能改变形参，还有两个更为隐蔽的原因：
    
     *  不能把`const`对象、字面值或需要类型转换的对象传给普通引用形参：
        
            string::size_type find_char(string &s, char c,
            					string::size_type &occurs);
            find_char("Hello world!", 'o', ctr); //错误！
     *  如果其他函数正确地将其形参定义为常量引用，则（如find\_char函数）无法在此类函数中正常使用：
        
            bool is_sentence(const stirng &s)
            {
            	string::size_type ctr = 0;
            	return find_char(s, '.', ctr) == s.size()-1 && ctr == 1; //错误！
            }

### 数组形参 ###

1.      void print(const int *);
        void print(const int[]);
        void print(const int[10]);
    
    上述三个函数声明是等价的。编译器只检查传入的参数是否是`const int*`类型，而不关心数组的维度。**数组的大小对函数的调用没有影响！**
2.  确保数组不越界的三种技术：
    
     *  \*\*使用标记指定数组长度。\*\*适用于C风格字符串（在最后一个字符后面跟着一个空字符）。例如：循环条件为指针不为空。
     *  \*\*使用标准库规范。\*\*传递指向数组首元素和尾元素的指针：
        
            void print(const int *beg, const int *end)
            {
            	while (beg != end)
            		cout << *beg++ << endl; //经典写法
            }
            int j[2] = {0,1};
            print(begin(j), end(j)); //调用
     *  （回顾C程序的写法）**专门定义一个表示数组大小的形参。**
    
    > 当函数不需要对数组元素执行写操作时，数组形参应该是指向const的指针。
3.  数组引用作为形参时，因为维度是类型的一部分，所以必须写上。
    
        void print(int (&arr)[10]);
    
    这一用法限制了print函数的可用性：只能传递维度为10的数组。
4.  传递多维数组时，**数组第二维（以及后面所有维度）的大小都是数组类型的一部分，不能省略**。
    
        void print(int (*matrix)[10], int rowSize);
        void print(int matrix[][10], int rowSize);
        //matrix都是指向含有10个整数的数组的指针
5.  `main`函数是理解C++程序如何向函数传递数组的好例子：
    
        int main(int argc, char *argv[]) {...}
    
    argv\[0\]为空字符串或程序名字，非用户输入；最后一个指针之后的元素值保证为0（举例：argv\[5\] = 0; 此时argc等于5）。

### 可变形参 ###

1.  如果函数的实参数量未知，但全部实参的数量都相同，可以使用`initializer_list`类型的形参（定义在同名头文件中，常用于输出程序产生的错误信息）：
    
        void error_msg(initializer_list<string> i1)
        {
        	for (const auto &elem : i1) //用引用避免拷贝
        		cout << elem << endl;
        }
        //expected和actual是string对象
        if (expected != actual)
            error_msg({"functionX", expected, actual});
        //要有花括号来初始化initializer_list<string>
        else
            error_msg({"functionX", "okay"});
        /* i1.size()
         * i1.begin()
         * i1.end() */
2.  和`vector`不一样的是，`initializer_list`对象中的元素永远是常量，我们无法改变它们。
3.  省略符形参`...`因该仅仅用于C和C++通用的类型。而且，大多数类型的对象在传递给省略符形参时，都无法正确拷贝（所以基本不要用）。

## 返回类型 ##

1.  返回`void`的函数不要求非得有`return`语句，因为在这类函数的最后一行会隐式地执行`return`。当然，`void`函数如果想在中间位置提前退出，可以使用`return`。
2.  **对于有返回值的函数，在含有`return`语句的循环后面应该也有一条`return`语句，没有的话就是错误的；因为循环可能不被执行。**
3.  \*\*不要返回局部对象的引用或指针！！！\*\*要确保引用所引的是在函数之前就存在的对象。一旦函数完成，局部对象就会被释放。
4.  调用运算符的优先级和点、箭头运算符相同，且都满足左结合律。因此，形如下面的语句是合法的：
    
        auto sz = shorterString(s1, s2).size();
5.  **函数的返回类型决定函数调用是否为左值。我们能为返回类型是非常量引用**的函数的结果赋值。
6.  C++新标准允许列表初始化返回值：
    
        vector<string> process()
        {
        	...
        	return {"stage1", "prepared"};
        }
    
    如果函数返回内置类型，则花括号包围的列表最多包含一个值。
7.  如果控制到达了`main`函数的结尾且没有`return`语句，编译器将隐式地插入一条返回0的`return`语句。
8.  在递归调用中，**一定有某条路径是不包含递归调用的**；否则，函数将不断地调用它自身直到程序栈空间耗尽为止。`main`函数不能调用它自己喔。

### 返回数组指针 ###

1.  因为数组不能被拷贝，所以函数不能返回数组，但是函数能返回数组的指针或引用。最直接的方法是使用类型别名：
    
        typedef int arr[10];
        //using arr = int[10]; 等价声明
        arr* func(int i);
2.  要想不使用类型别名，必须加上返回类型的维度：
    
        int (*p)[10] = &arr; //arr是int[10]型
        int (*func(int i))[10];
        //(*func(int i))意味着我们可以对函数调用的结果解引用
        //(*func(int i))[10]表示解引用的结果是一个大小为10的数组
3.  C++新标准允许使用**尾置返回类型**（适用于返回类型较复杂的函数，如返回类型是数组的指针或引用）：
    
        //在本应出现返回类型的地方放一个auto
        auto func(int i) -> int(*)[10];
4.  如果我们知道函数返回的指针指向哪个数组，可以使用`decltype`声明返回类型：
    
        int odd[] = {1,3,5,7,9};
        int even[] = {0,2,4,6,8};
        decltype(odd) *func(int i)
        {
        	return (i%2) ? &odd : &even;
        } //decltype(odd)是数组类型而不是数组指针，因此还要加上*
    
    当数组被用作`decltype`关键字的参数，或者作为取地址符`&`、`sizzeof`等运算符的对象时，数组不会被隐式地转换成指针。

## 函数重载 ##

1.  仅有返回类型不同，不构成重载。`main`函数不能重载。
2.  如*const形参和实参*一节所说，顶层`const`不影响传入函数的对象，因此参数的顶层`const`属性不能构成重载。另一方面，**如果形参是某种类型的指针或引用，则通过区分其指向的是常量对象还是非常量对象可以实现重载。此时的`const`是底层的。**
    
        Record lookup(Phone*);
        Record lookup(Phone* const); //不构成重载
        
        Record lookup(Phone*);
        Record lookup(const Phone*); //构成重载
    
    我们只能把`const`对象或指向`const`的指针传给`const`形参。而当我们传递一个非常量对象时，编译器会优先使用非常量版本的函数。
3.  `const_cast`在函数重载中最有用：
    
        const string &shorertString(const string &s1,
                                  const string &s2)
        {
        	return s1.size()<s2.size() ? s1 : s2;
        } //常量版本函数（传入常量，返回常量）
        string &shorterString(string &s1, string &s2)
        {
            auto &r = shorterString(
                      const_cast<const string&>(s1),
            	      const_cast<const string&>(s2));
            return const_cast<string&>(r);
        } //非常量版本函数中，可以调用常量版本，精简代码
    
    `const`版本返回对`const string`的引用，但这个引用事实上绑定在了非常量实参上，因此我们可以再将其转换为一个普通的`string&`，这显然是安全的。
4.  \*\*在不同的作用域中无法重载函数名。\*\*通常来说，在局部作用域中声明函数不是一个好的选择。

### 函数匹配 ###

1.  候选函数：与被调用函数同名、其声明在调用点可见。可行函数：形参数量等于实参且类型相同（或能转换）。
2.  寻找最佳匹配：如果有一个函数，每个实参的匹配都不劣于其他可行函数需要的匹配，且至少有一个参数优于其他可行函数提供的匹配，则匹配成功；否则调用具有二义性，是错误的。
3.  所有类型转换的级别都一样。只有当调用提供`short`类型的值，才会选择`short`版本的函数（否则选用`int`版本）。

## 特殊用途语言特性 ##

### 默认实参 ###

1.  一旦某个形参被赋予了默认值，它后面的所有形参都必须有默认值。默认实参负责填补函数调用缺少的尾部实参。
2.  当设计含有默认实参的函数时，要合理设置形参顺序，**尽量让不怎么使用默认值的形参出现在前面，而让经常使用默认值的形参出现在后面。**
3.  通常，应该在函数声明中指定默认形参，并将该声明放在合适的默认形参中。函数的后续声明只能为之前没有默认值的形参添加默认实参。
4.  局部变量不能作为默认实参。除此之外，只要表达式的类型能转换成形参所需要的类型，该表达式就能作为默认形参：

int wd = 80;
    string screen(int sz = wd);
    void f2()
    {
    	wd = 100;
    } 
    //函数f2内改变了wd，所以对screen的调用会传递这个更新过的值

### 内联函数 ###

1.  把规模较小的操作定义成函数，有利于确保行为的统一、便于修改、能够被重复利用。
2.  内联函数（在返回类型前加上`inline`）能够在调用点上内联地展开，避免函数调用的开销。
3.  内联机制用于优化规模较小、流程直接、频繁调用的函数（往往不支持递归）。**内联函数通常定义在头文件中。**

### constexpr函数 ###

1.  `constexpr`函数（被隐式地指定为内联函数）是指能用于常量表达式的函数：
    
        constexpr int new_sz() {return 42;}
        constexpr int foo = new_sz;
    
    规定：函数的返回值类型、所有的形参类型必须是字面值类型；函数体中只有一条`return`语句。
2.  允许`constexpr`函数的返回值并非一个常量。
    
        constexpr size_t scale(size_t cnt)
        {
        	return new_sz() * cnt;
        } //如果arg是常量表达式，scale(arg)也是常量表达式
        int arr[scale(2)]; //正确：scale(2)是常量表达式
        int i = 2;
        int arr[scale(i)]; //错误：scale(i)不是常量表达式

### 调试帮助 ###

1.  `assert`是一种**预处理宏**。定义在`cassert`头文件中，无需为其提供`using`声明。
    
        assert(expr);
        //如果表达式为假（即0），assert输出信息并终止程序运行
        //如果表达式为真，assert什么也不做
    
    **`assert`宏常用于检查“不能发生”的条件。**
2.  如果在`main.c`文件的一开始写`#define NDEBUG`，可以关闭调试状态；此时`assert`将不执行运行时检查。此外，`NDEBUG`也可用于编写自己的调试代码：
    
        void print()
        {
        #ifdef NDEBUG
        	cerr << __func__ << endl;
        #endif
        }
    
    `__func__`是编译器定义的一个局部静态变量，用于存放函数的名字。除此之外，预处理器还定义了4个对程序调试很有帮助的名字：
    
     *  `__FILE__`存放文件名的字符串字面值
     *  `__LINE__`存放当前行号的整形字面值
     *  `__TIME__`存放文件编译时间的字符串字面值
     *  `__DATE__`存放文件编译日期的字符串字面值
    
        if (word.size() < threshold)
        	cerr << "Error:" << __FILE__
        	     << "in function " << __func__
        	     << "at line " << __LINE__ << endl
        	     << "Compiled on " << __DATE__
        	     << "at " << __TIME__ << endl;

## 函数指针 ##

1.  函数指针指向的是函数而非对象。函数指针指向某种特定类型。**函数的类型由它的返回类型和形参的类型共同决定，与函数名无关。**
    
        bool (*pf)（const string &, const string &);
        //声明函数指针，只需要将原本函数名的地方换成指针
2.  **当我们把函数名当一个值使用时，该函数自动地转换为指针。此外，我们还能直接使用指向函数的指针调用函数，而无需解引用。**
    
        pf = lengthCompare;
        bool b3 = pf("hello", "goodbye");
    
    在指向不同函数类型的指针之间，不能互相转换。不过，我们还是能为函数指针赋`nullptr`。
3.  当我们使用重载函数时，编译器通过函数指针类型判断选用哪个函数（如：初始化函数指针时）。
4.  形参可以是指向函数的指针。虽然看起来是函数类型，实际上却当成指针使用。
    
        //直接写
        void useBigger(const string &s1, const string &s2,
        			   bool pf(const string &, 
        			           const string &));
        //使用类型别名
        type bool Func(const string &, const string &);
        void useBigger(const string &s1, const string &s2,
        			   Func);
5.  和数组类似，虽然不能返回一个函数，但是能返回指向函数的指针。最简单的办法依旧是使用类型别名：
    
        using func = int(int *, int); //func是函数类型
        using pfunc = int(*)(int *, int); //pfunc是指针类型
        func *f1(int);
        pfunc f1(int);
        decltype(sumLength) *getFcn(const string &);
        //sumaLength是一个函数的名字
    
    和函数形参不一样，函数返回值不会自动转换为指针,我们**需要显式地将返回类型定为指针**。当然，还可以使用尾置返回类型的方式。