[关闭]
@taqikema 2018-01-02T04:13:19.000000Z 字数 6684 阅读 1138

第6章 函数

C++Primer 学习记录 函数相关

6.1 函数基础

  1. 一个函数包括以下部分：
    函数结构
  2. 函数在被调用时首先（隐式地）定义并初始化它的形参，其实这个过程就是一个值初始化的过程，所以之前对于 值初始化或 auto初始化的规则一样有效。这里要注意一点，即 C++并没有规定实参的求值顺序，编译器能以任意可行的顺序对实参求值。所以形如下式的表达式是错误的！
    int a = fun(i, ++i); // 错误：传递进来的实参不能对其它实参有副作用！
  3. 函数的返回类型不能是数组或函数类型，但可以是指向数组或函数的指针。
  4. 局部静态对象在程序执行路径第一次经过对象定义语句时初始化，直到程序终止才被销毁；如果局部静态变量没有显式的初始值，执行值初始化，内置类型被初始化为 0。
  5. 另外，为了确保同一函数在不同使用该函数的地方保持一致，并且将接口和实现分离开来，C++通常会将函数声明放到头文件(.h)，实现放到源文件(.cpp)中。这样，使用和修改函数接口都会很方便。
  6. C++支持分离式编译，对每个 源文件(.cpp)独立编译。这样如果我们修改了其中一个源文件，那么只需要重新编译那个改动了的文件。之后编译器会将对象文件(.obj)链接到一起，形成可执行文件(.exe)。整体过程如下
    分离式编译.png
    这样的话，如果在头文件中实现了某个函数，而该函数又被多个源文件使用，那么在编译时正常，而在链接时就会报错，某些函数多次重复定义。这是因为每个源文件都会对自己使用的函数进行编译，编译后的 .obj中已经包括了该函数的定义，而在后续多个 .obj文件链接时，才发现这个函数被多次定义了。解决办法就是在 .h文件中仅包含函数声明，函数实现放到 .cpp文件中去。

6.2 参数传递

  1. 形参初始化的机理与变量初始化一样。包括引用传递和值传递，其中指针参数也是值传递，进行的是指针的值的拷贝。拷贝之后，两个指针是不同的指针，只是它们都指向都一个对象。
  2. 使用引用传递可以避免拷贝，效率较高；另外，有些类型（IO操作）不支持拷贝，只能通过引用形参访问该类型的对象。
  3. C++中一个函数只能返回一个值，而当函数需要返回多个值时，可以通过引用和指针形参来完成。这样的话，输入参数在函数执行完毕后也会被改变，也就相当于是一个输出参数了。当然，还可以通过自定义一个数据类型或使用 tuple模板来返回多个值。
  4. 与变量初始化一样，参数初始化时，会忽略掉顶层 const。因此对下式传给它常量对象或者非常量对象都是可以的。
    int a = fcn(const int i); // fcn能够读取 i，但是不能修改 i的值
    另外，因为忽略掉顶层 const的缘故，顶层 const并不会引起函数重载，而是函数重定义！
  1. void fcn(const int i);
  2. void fcn(int i);  // 错误，函数重定义！

  1. 尽量使用常量引用，表示该函数不会改变该形参。因为将函数定义成普通引用有以下缺点：

    • 非常量引用只能接受非常量对象，不能把 const对象、字面值传递给这种形参。
    • 在含有常量引用形参的函数中，无法将常量引用传递给非常量引用的函数，从而限制了后者的适用范围。此时需要使用 const_cast来转换底层 const属性。
    • 给函数的调用者以误导，使用者可能会以为函数可以修改它的实参的值。

  2. 数组不允许拷贝，所以无法以值传递的形式传递数组参数；使用数组时通常会将其转换成指针，所以当为函数传递一个数组参数时，实际传递的是指向数组首元素的指针。数组的大小对函数的调用没有影响。

  1. // 尽管形式不同，但三个 print函数是等价的，每个形参都是 const int*类型
  2. void print(const int *);
  3. void print(const int[]);    // 此函数的意图是作用于一个数组
  4. void print(const int[10]);  // 这个维度表示我们期望的输入数组有多少个元素，实际并不一定！
  5. int i = 0, j[2] = {0, 1};
  6. print(&i);                  // 正确，即使参数只是一个单独的 int类型
  7. print(j);                   // 正确
  1. 对于数组引用形参，因为维度是数组类型的一部分，所以声明数组引用形参时必须指定数组的维度，也只能将函数应用于指定大小的数组。
  1. // 形参是数组的常量引用，维度是类型的一部分
  2. void print(const int (&arr) [10]);
  3. int i = 0, j[2] = {0, 1};
  4. print(&i);                  // 错误，实参不是含有 10个整数的数组
  5. print(j);                   // 错误，实参不是含有 10个整数的数组
  1. 使用 main函数处理命令行选项时，通常会写成下列两种形式：
  1. int main(int argc, char *argv[]) {...}
  2. int main(int argc, char **argv ) {...}

在上面两个表达式中，argv是一个数组，它的元素是指向 C风格字符串的指针，而 argv又可以看成是指向首元素的指针，因此 argv就是一个二级指针，所以也就有了第二个表达式的写法。
在使用 argv的实参时，可选的实参从 argv[1]开始；argv[0]保存的是程序的名字，而非用户输入。
9. 为了编写处理不同数量实参的函数，C++11新标准提供了两种方法：所有实参类型相同，使用 initializer_list；实参类型不同，使用可变参数模板，然后实例化即可。另外，对于与C函数交互的接口程序，省略符形参(...)。可变参数符号与其它特定参数一起出现时，必须在最右边。
10.initializer_list提供了对一系列相同类型元素的轻量级存储和访问的能力，值初始化后列表中的元素永远是常量值。在拷贝或赋值时，执行的也是“类指针拷贝”，原始列表和副本共享元素。

6.3 返回类型和 return语句

  1. 在含有 return语句的循环后面应该也有一条 return语句，对于该错误，编译器可能检测不到该错误（在我的 VS2015中，会警告，但不报错），则运行时该程序的行为将是未定义的！
  2. 返回一个值的方式和初始化一个变量完全一样：返回的值用于初始化调用点的一个临时量，该临时量就是函数调用的结果。
  1. int a = fcn(5);
  2. // 上式等价于
  3. int tmp = fcn(5);    // 在调用点定义并初始化一个临时量
  4. int a = tmp;         // 执行 int类型的拷贝构造函数
  1. 不要返回局部对象的引用或指针，因为函数完成后，内部的局部变量也会被释放掉。
  1. const string &manip()
  2. {
  3.     string ret;
  4.     // 以某种方式改变一下 ret
  5.     if (!ret.empty())
  6.         return ret;        // 错误：返回局部对象的引用
  7.     else
  8.         return "Empty";    // 错误：字符串字面值还是会被转换成一个临时 string对象
  9. }
  1. 调用一个返回引用的函数得到左值，其他返回类型得到右值。可以为返回类型是非常量引用的函数的结果赋值。
  1. char &get_val(string &str, string::size_type ix)
  2. {
  3.     return str[ix];
  4. }
  5. string s("value");
  6. get_val(s, 0) = 'V';  // 将 s改成 "Value"
  1. C++11新规定，可以返回花括号包围的值的列表，用此列表对表示函数返回的调用点的临时量进行初始化。列表为空，临时量执行值初始化。另外，如果返回类型是内置类型，则花括号列表最多包含一个值，且该值所占内存空间不应大于目标类型的空间（比如，double——>int就会报错）
  2. main函数，返回 0表示执行成功，返回其他值表示执行失败，其中非 0值的具体含义依机器而定。
  3. 数组不能被拷贝，所以函数不能返回数组，但是可以返回数组的指针或引用。形式如下
    int (*func(int i))[10] // func函数返回指向 10个 int组成的数组的指针
    可以按照由内到外的顺序来理解该声明的含义：
    • func(int i)表示一个函数，形参为 int类型。
    • (*func(int i))表示可以对函数调用的结果执行解引用操作，则函数的返回值是指针类型。
    • int (*func(int i))[10]表示该指针指向 10个 int组成的数组
      使用类型别名的话可以大大简化上述表达式，且其可读性也更好。
  1. using arrT = int[10];
  2. arrT* func(int i);

C++11新标准中还可以使用尾置返回类型来简化上述函数声明。下式就可以很清楚地看到 func函数返回的是一个指针，且该指针指向了含有 10个整数的数组。
auto func(int i) -> int(*)[10];
另外，如果已经有返回值类型的数组存在，可以使用 decltype关键字声明返回类型。

  1. int arr[10] = {1,2};
  2. decltype(arr) *func(int i);

不过，需要注意，decltype的返回类型是数组类型，要想表示返回类型为指向数组的指针，必须加上一个 *符号。

6.4 函数重载

  1. 重载，几个函数名字相同但形参列表不同，在判断是否重载时，返回类型不予考虑。另外，因为在编译时会为函数在进行重命名，而在重命名时是只考虑函数名和形参的，所以不允许两个函数除了返回类型外其它所有的要素都相同。
  1. int func(int i);
  2. double func(int i);  // 错误，无法重载仅按返回类型重载的函数
  1. 顶层 const形参不构成重载，而底层 const形参是可以构成重载的。
  1. Record lookup(Account &);        // 实参为非常量对象时，优先调用此版本
  2. Record lookup(const Account &);  // 实参为常量对象时，只能调用此版本

对于第二个表达式，实参为常量/非常量对象，都是可以的。但是如果两种表达式都存在，且实参为非常量对象时，会优先调用第一个非常量版本。因为第一个表达式为精确匹配，而第二个表达式则需要将非常量类型转化为常量类型。
3. 在 C++语言中，名字查找发生在类型检查之前。在内层作用域中声明的名字将会隐藏外层作用域中的同名实体。

  1. string read();
  2. void print(const string &s);
  3. void main()
  4. {
  5.     bool read = false;
  6.     string s = read();  // 错误：read是一个 bool类型，而非函数
  7.     void print(int);
  8.     print("value");     // 错误：print(const string &s)被隐藏掉了
  9. }

6.5 特殊用途语言特性

  1. 默认实参，应尽量让有默认值的形参出现在参数列表的后面。
  2. 局部变量不能作为默认实参。
  1. // wd、def和 ht的声明必须出现在函数之外
  2. sz wd = 80;
  3. char def = ' ';
  4. sz ht();
  5. string screen(sz = ht(), sz = wd, char = def);
  6. string window = screen();  // 调用 screen(ht(), 80, ' ')

另外，用作函数默认实参的名字在函数声明所在的作用域内解析，及确定默认实参到底是用哪些名字，而这些名字的求值过程则发生在函数调用时。可以看下面这个例子。

  1. void f2()
  2. {
  3.     def = '*';          // 改变了默认实参的值
  4.     sz wd = 100;        // 隐藏了外层作用域的 wd，但是默认实参使用的
  5.                         // 是外层作用域中的 wd，所以对于函数调用没有影响！
  6.     window = screen();  // 调用 screen(ht(), 80, '*')
  7. }
  1. constexpr函数，当所有形参在编译期就已全部知道，其返回值也是常量表达式，即也是在编译期就已知的。而只要有一个形参在编译期是未知的，它就会表现为一个正常函数，在运行期计算它的值。这样做，可以大大扩展一个函数的适用范围，对于需要使用在编译期就能知道的常量表达式的场景（如数组大小的说明，整形模板参数（包括std::array对象的长度），枚举成员的值等），该函数也可以使用了。
  2. C++11中规定，函数的返回类型及所有形参都得是字面值类型，而且函数体中必须有且只有一条return语句（不过可以通过条件表达式 “?:”和迭代绕过这些限制）。更详细的内容见 Item 15: 只要有可能，就使用constexpr，这是《effective modern c++》Item 15的翻译，关于 constexpr，讲得非常透彻！
  3. 另外，内联函数和 constexpr函数可以在程序中多次定义，不过对于某个给定的内联函数或 constexpr函数，多个定义必须完全一致。基于这个原因，内联函数和 constexpr函数通常定义在头文件中。也因为它们可以多次定义，所以即使定义在头文件中，链接时也不会出现多次定义的错误，而普通函数这样做就会出错。
  4. assert预处理宏，assert(expr)，语义为保证表达式为真，如果表达式为假，assert输出信息并终止程序。这种技术一般用于调试代码，只在开发程序时使用。真正在发布程序时，需要屏蔽掉调试代码。这时可以使用 NDEBUG，定义了 NDEBUG后，assert什么也不做。

6.6 函数匹配

  1. 函数匹配的过程：
    1. 确定候选函数：与被调用函数同名，且在调用点可见。
    2. 确定可行函数：参数数量相同，参数类型相同或能转换。
    3. 寻找最佳匹配。为了确定最佳匹配，将实参类型转换划分成几个等级，由上到下优先级逐渐降低。
      1. 精确匹配，包括以下情况：
        • 实参类型和形参类型相同。
        • 实参从数组或函数类型转换成指针。
        • 添加或删除顶层 const属性。
      2. 需要进行 const转换（const_cast）。
      3. 需要进行类型提升(short--->int)。
      4. 需要进行算术类型(int-->double)或指针转换。
      5. 需要进行类类型转换。
    4. 编译器依次检查每个实参以确定哪个函数是最佳匹配，如果有且只有一个函数满足下列条件，则匹配成功；否则，编译器将报二义性错误。
      • 该函数每个实参的匹配都不劣于其他可行函数。
      • 至少已有一个实参的匹配优先于其他可行函数。

6.7 函数指针

  1. 函数指针，指向某种特定函数类型。而函数类型由返回类型和形参类型共同决定，与函数名无关。例如：
    bool compare(int i, int j);
    其函数类型是 bool(int, int)。则该函数类型的指针可声明为
    bool (*pf)(int i, int j);
    但是此时只是声明了一个该类型的函数指针变量，并没有进行初始化！还需要使用函数名或函数指针进行初始化。而把函数名当做一个值使用时，函数可以自动转换成指针。
    pf = compare; 等价于 pf = &compare;
    此外，在使用函数指针调用函数时，无须提前解引用指针。
    bool b1 = pf(1, 2); 等价于 bool b2 = (*pf)(1, 2);
  2. 不能定义函数类型的形参，但形参可以是指向函数的指针。与 void print(const int[10])类似，函数看起来是函数（数组）类型，但实际上却是当成指针使用。所以下面两个表达式都是可以的。
  1. void useBigger(int i, int j, bool compare(int i, int j)); // 形参是函数类型，但会自动地转换成相应的函数指针
  2. void useBigger(int i, int j, bool (*pf)(int i, int j));   // 显式地将形参定义成函数指针

注意，对于上面两个表达式，在其之前是否已经声明了 compare和 pf，不会对其产生任何影响。因为作为形参， compare或 pf只是形参的名字，与之前已经声明的同名名字没有关系。另外，作为形参表达式，整体的意义是一个类型。所以使用类型别名可以简化代码，增强可读性。

  1. // Func和 Func2是函数类型
  2. typedef bool Func(int i, int j);
  3. typedef decltype(compare) Func2;
  4. // FuncP和 FuncP2是函数指针类型
  5. typedef bool (*FuncP)(int i, int j);
  6. typedef decltype(compare) *FuncP2;
  7. // useBigger的等价声明
  8. void useBigger(int i, int j, Func);    // 形参是函数类型，但会自动地转换成相应的函数指针
  9. void useBigger(int i, int j, FuncP2);
  1. 返回函数指针。不能返回一个函数，但可以返回函数指针。与返回数组指针一样，也还是这四种返回方式。
    • 直接声明。 int (*f1(int)) (int*, int);
    • 类型别名。 using PE = int(*)(int*, int); PE f1(int);
    • 尾置返回。 auto f1(int) ->int(*)(int*, int);
    • decltype。 int f(int*, int); decltype(f) *f1(int);
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注