第6章 函数

函数基础

局部静态对象（local static object）

在程序的执行路径第一次经过对象定义语句时初始化，并且直到程序终止才被销毁，在此期间即使对象所在的函数结束执行也不会对它有影响。

如果局部静态变量未被显式初始化，它将执行值初始化（内置类型的局部静态变量初始化为0）。

函数声明

函数声明也称作函数原型（function prototype）

函数声明没有函数体，用一个分号表示声明语句结束。

函数声明无须形参的名字（也可以写上形参的名字）。

int f(int n); //ok

int f(int); //ok

在头文件中进行函数声明

函数应该在头文件中声明，而在源文件中定义；

含有函数声明的头文件应该被包含到定义函数的源文件中。

参数传递

const形参和实参

当形参有顶层const时，传给它常量对象或非常量对象都是可以的。换句话说，形参的顶层const被忽略掉了。

void f(const int i) { /*f能读取i不能向i写值*/}

void f(int i) { /*可以向i写值*/}

以上两个函数定义似乎是有差异的，实际上若二者同时存在属于重复定义。因为顶层const被忽略掉了，传入这两个函数的参数可以完全一样。

补充：

int calc(char* a, char* b) { /**/ }

int calc(char* const a, char* const b) { /**/ }

以上函数属于重复定义，因为这里的const是顶层const，形参的顶层const被忽略了，两个函数的所有参数类型都是char*。

补充：

int calc(char* a, char* b) { /**/ }

int calc(const char* a, const char* b) { /**/ }

以上函数可以同时定义，因为这里的const是底层const。

以上函数在函数匹配时不会发生二义性调用，如果形参是指向常量的指针，调用后者；如果实参是指向非常量的指针，虽然调用二者均可行，编译器会调用前者以达到精确匹配。

扩展：

void f(...) const {...}

void f(...) {...}

它们被认为是两个不同的函数，因为此处的const是函数签名的一部分。

数组形参

回顾数组的两个性质：

　　不允许拷贝数组；

　　使用数组时（通常）会将其转换成指针。

尽管不能以值传递的方式传递整个数组，但是可以把形参写成类似数组的形式。

　　void print(const int*);

　　void print(const int[]);

　　void print(const in[10]); //这里的维度表示我们期望数组含有多少元素，实际不一定

以上三者完全等价，每个函数的唯一形参都是const int*类型。编译器处理对print函数的调用时，只检查传入的参数是否const int*类型。

例如：

　　int i = 0, a[2] = {0,1};

　　print(&i); //合法；&i的类型是int*

　　print(a); //合法；a转换成int*并指向a[0]

数组引用形参

形参也可以是数组的引用，引用形参绑定到对应的实参上，也就是绑定到数组上。

　　void print(int (&arr)[10]) {/**/}

但是，这一用法也无形中限制了print函数的可用性：我们只能将函数作用于大小为10的数组。

（通过函数模板，可以实现给引用类型的形参传递任意大小的数组，后面将会讨论）

PS：&arr两端的括号不能少

　　void print(int &arr[10]) //非法；试图将arr声明成“引用的数组”；但是不存在引用的数组，数组元素应该是对象

　　void print(int (&arr)[10]) //合法；arr是一个“含有10个整数的整型数组”的引用

传递多维数组

回顾：多维数组其实是数组的数组。将多维数组传递给函数，真正传递的是指向数组首元素的指针，而首元素本身就是一个数组，所以这个指针就是一个指向数组的指针。

数组第二维（以及后面的所有维度）的大小都是数组类型的一部分 ，不能省略。

　　void print(int (*matrix)[10], int rowSize) { /**/ }

　　//matrix是指向“含有10个整数的数组”的指针

PS：*matrix两端的括号必不可少

　　void print(int *matrix[10], int rowSize) { /**/ }

　　//合法（但不是我们所要的）；matrix是“10个指向整数的指针”构成的数组

另一种等价定义方式（以二维数组为例）：

　　void print(int matrix[][10], int rowSize) { /**/ }

　　//matrix的声明看起来是一个二维数组，实际上形参是一个指向“含有10个整数的数组”的指针（编译器会忽略掉第一个维度）。

main：处理命令行选项

　　int main(int argc, char *argv[]) { ... }

　　int main(int argc, char **argv) { ... } //上一条语句的等价写法；argv是一个指针，指向char*类型的对象

第二个形参是一个数组，它的元素是指向C风格字符串的指针；

第一个形参argc表示数组中字符串的数量；

当实参传给main函数之后，argv[0]指向程序的名字或一个空字符串（argv[0]的值由系统设定的，而非用户输入）；

从argv[1]开始，保存用户输入的可选实参；

最后一个指针之后的元素值保证为0（这也是由系统设定的）；

例如：

假定main函数位于可执行文件prog内，并且我们向程序传递了下面的选项：

　　prog -d -o ofile data0

则结果是：

　　argc = 5;

　　argv[0] = "prog";

　　argv[1] = "-d";

　　argv[2] = "-o";

　　argv[3] = "ofile";

　　argv[4] = "data0";

　　argv[5] = 0;

含有可变形参的函数

（1）initializer_list形参

适用情况：函数的实参数量未知，但是全部实参的类型都相同。

initializer_list是一种标准库类型，它定义在同名的头文件中；initializer_list是一种模板类型。

initializer_list对象中的元素永远是常量值。

如果要向initializer_list形参中传递一个值的序列，则必须把序列放在一对花括号内。

　　void f(initializer_list lst) { ... }

　　f({"string1", s2, s3}); //PS：s2和s3是string对象

initializer_list提供的操作：

　　initializer_list<T> lst;　　默认初始化；T类型元素的空列表

　　initializer_list<T> lst{a,b,c...};　　lst中的元素是对应初始值的副本，列表中的元素是const

　　lst2(lst)　　lst2 = lst　　拷贝构造、拷贝赋值；（实际上，不会拷贝列表中的元素，拷贝后，原始列表和副本共享元素）

　　lst.size()

　　lst.begin()

　　lst.end()

（2）省略符形参

省略符形参仅仅用于C和C++通用的类型。特别要注意：大多数类类型的对象在传递给省略符形参时都无法正确拷贝。

省略符形参只能出现在形参列表的最后一个位置。

　　void f(parm_list, ...); //此处的逗号是可选的

　　void f(...);

省略符形参对应的实参无需类型检查。

（3）函数模板：可变参数模板

这里先不讨论。

返回类型和return语句

对于有返回值的函数，如果函数体内不包含return语句，有的编译器可能会检测到这个错误，有的也许不会；

如果编译器没有发现这个错误，则运行时的行为是未定义的。（返回值不可预知）

不要返回局部对象的引用或指针

函数完成后。它所占用的存储空间也随之被释放掉。函数终止意味着局部变量的引用或指针将指向不再有效的内存区域。

注意：返回局部静态对象的引用或指针是安全的。

列表初始化返回值

C++11允许函数返回花括号包围的值的列表。

vector<string> f(string s)
{
　　if(s.empty())
　　　　return {}; //合法；返回一个空vector对象
　　else
　　　　return {"string1", "string2"}; //合法；返回列表初始化的vector对象
}

注意：如果函数是基本内置类型，也同样允许使用列表初始化返回值；但是，花括号包围的列表最多包含一个值，而且所占空间不应大于目标类型的空间。

int f() { return {} }; //合法；返回0

int f() { return {1} }; //合法

int f() { return {1.1} }; //非法；返回1；编译器给出warning（但程序还是能运行，并执行了隐式类型转换）

返回数组指针

（1）使用类型别名简化返回数组的指针或引用：

　　typedef int arrT[10]; //arrT是一个类型别名，它表示的类型是“含有10个整数的数组”

　　using arrT = int[10]; //上一条语句的等价写法

　　arrT* func(int i); //func返回一个“指向含有10个整数的数组”的指针

（2）如果不使用类型别名，则返回数组指针的函数形式如下：

　　Type (*function(parameter_list)) [dimension]

注：(*function(parameter_list))两端的括号必须存在，否则，函数的返回类型将是“元素是指针的数组”。

以具体例子来理解该声明的含义：

　　int (*func(int i)) [10];

可按以下顺序来理解：

　　func(int i) 表示调用函数时需要一个int类型的实参；

　　(*func(int i)) 意味着我们可以对函数的调用结果执行解引用操作（或者说：意味着函数的调用结果是一个某种类型的指针）；

　　(*func(int i)) [10] 表示解引用func的调用将得到一个大小是10的数组；

　　int (*func(int i)) [10] 表示数组中的元素是int类型

（3）使用尾置返回类型

C++支持尾置返回类型（trailing return type）。

任何函数都能使用尾置返回，但是尾置返回对于较复杂的函数返回类型最有效。

上例子：

　　auto func(int i) -> int (*) [10]; //func接受一个int类型的实参，返回一个指针，该指针指向含有10个整数的数组。

注：尾置返回类型跟在形参列表后，并以一个->符号开头；而在本应出现返回类型的地方放置一个auto。

（4）使用decltype

当我们知道函数返回的指针将指向哪个数组，就可以使用decltype关键字声明返回类型。

例如，下面的函数返回一个指针，该指针根据参数i的不同指向两个已知数组中的某一个。

int odd[] = {1,3,5};

int even[] = {2,4,6};

decltype(odd) *arrPtr(int i)

{

　　return (i%2) ? &odd : &even; //返回一个指向数组的指针

}

arrPtr返回一个“指向含有3个整数的数组”的指针。

注意：之前讨论过，decltype并不会把数组类型转换成对应的指针，所以decltype(odd)的结果表示的是数组；要想表示arrPtr返回的是指针，则还必须在函数声明时加一个*。

函数重载

函数重载：同一作用域内；函数名相同；形参列表不同。

不允许两个函数除了返回类型外其它所有要素都相同。

重载和const形参

顶层const不影响传入函数的对象；一个拥有顶层const的形参无法和另一个没有顶层const的形参区分开来。

　　Record lookup(Phone);

　　Record lookup(const Phone); //重复定义

如果形参是某种类型的指针或引用，则通过区分其指向的是常量对象还是非常量对象，可以实现函数重载；此时const是底层的。

　　Record lookup(Account&); //函数作用于Account的引用

　　Record lookup(const Account&); //新函数；作用于常量引用

　　Record lookup(Account*); //新函数；作用于指向Account的指针

　　Record lookup(const Account*); //新函数；作用于指向常量的指针

因为const不能转换成非常量，所以只能把const对象（或指向const的指针）传递给const形参；

因为非常量可以转换成const，所以以上4个函数都能作用于非常量对象（或指向非常量对象的指针）。（不过，编译器会优先选择非常量版本的函数）

特殊用途语言特性

默认实参

一旦某个形参被赋予了默认值，它后面的所有形参都必须指定默认值。

默认实参负责填补函数调用缺少的尾部实参。

用作默认实参的名字在函数声明所在的作用域内解析，而这些名字的求值过程发生在函数调用时。

 1 int i = 10; //A
 2 char c = '.'; //B
 3 
 4 void f(int sz = i, char ch = c)
 5 {
 6   cout<< sz << " " << ch <<endl;
 7 }
 8 
 9 int main()
10 {
11   c = '*'; //C
12   int i = 20; //D
13   f(); //使用默认实参
14   return 0;
15 }

输出结果是： 10 *

注解：调用f时，使用的i是函数声明所在的作用域内的那个i（A处）；使用的c的值是函数调用时c的最新值（B处的变量c，C处的最新值'*'）。

虽然我们意图声明一个局部变量i（D处）用于隐藏外层的i（A处），但是该局部变量与传递给f的默认实参没有任何联系。

内联函数和constexpr函数

内联函数：函数将在每个调用点上“内联地”展开，从而避免了函数调用的开销。（函数调用开销：包括保存和恢复寄存器、拷贝实参等。）

注：在函数的返回类型前加上inline关键字，以建议编译器将其做成内联函数，编译器可以忽略这个请求。

constexpr函数：能用于常量表达式的函数。

定义constexpr函数的约定：函数的返回类型及所有形参的类型都得是字面值类型（参见第2章Tips）；函数体中有且仅有一条return语句。

constexpr函数体内也可以包含其它语句，但这些语句应该在运行时不执行任何操作。（例如：空语句、类型别名、using声明等）

constexpr函数并不一定返回常量表达式（我们允许其返回值并非一个常量）：

　　注解：对func(arg)，当实参是常量表达式时，它的返回结果也是常量表达式，反之不然。

　　constexpr int f(int cnt) { return f2() * cnt; }

　　f(10); //10是字面值，是常量表达式，故返回值也是常量表达式

　　int i = 10;

　　f(i); //i是一个非常量表达式，则返回值是一个非常量表达式

PS：编译器会把对constexpr函数的调用替换成其结果值，为了能在编译过程中随时展开，constexpr函数被隐式地指定为内联函数。

PS：与其它函数不同，内联函数和constexpr函数可在程序中多次定义；不过，对某个给定的内联函数或constexpr函数来说，它的多个定义必须完全一致。

基于此原因，内联函数和constexpr函数通常定义在头文件中。

预处理时的调试：assert和NDEBUG

assert：是一种预处理宏，定义在cassert头文件中。

　　assert(expr);

assert以一个表达式作为它的条件，如果表达式为假，assert输出信息并终止程序，如果表达式为真，assert什么也不做。

NDEBUG预处理变量：assert的行为依赖于一个名为NDEBUG的预处理变量的状态。如果定义了NDEBUG，则assert什么也不做。

默认情况下没有定义NDEBUG，此时assert将执行运行时检查。（#define NEBUG则关闭调试状态）

函数指针

函数指针指向的是函数，而非对象。

函数指针指向某种特定类型。

函数的类型由它的返回类型和形参类型共同决定，而与函数名无关。

例如函数：

　　bool compare(const string &, const string &);

该函数的类型是：

　　bool (const string &, const string &)

要想声明一个指向该函数的指针，只需要用指针替换函数名：

　　bool (*pf)(const string &, const string &); //注意：指针未初始化

　　//pf指向一个函数，该函数的参数是两个const string的引用，该函数的返回值是bool类型

可以这样理解指针pf的声明语句：

pf前面有个*，说明pf是指针；

右侧是形参列表（参数是两个const string的引用），表示pf指向的是函数；

再观察左侧，发现函数的返回类型是bool；

综上，pf是一个指向函数的指针，该函数的参数是两个const string的引用，该函数数的返回值是bool类型。

PS：*pf两端的括号必不可少。假若不写这对括号：

　　bool *pf(const string &, const string &); //声明一个名为pf的函数，该函数返回bool*

使用函数指针

当我们把函数名作为一个值使用时，该函数自动地转换成指针。

　　pf = compare; //pf指向名为compare的函数

　　pf = &compare; //与上一条语句等价：取地址符是可选的

扩展：对数组名，没有取地址符的写法。

例如：

　　int a[] = {1,2};

　　int *p = a; //ok

　　int *p = &a; //非法

　　int *p = &a[0]; //ok

允许直接使用指向函数的指针调用该函数，无须解引用指针。

　　bool b1 = pf("hi", "bye"); //ok

　　bool b2 = (*pf)("hi", "bye"); //ok

　　bool b3 = compare("hi", "bye"); //ok

　　//以上三者等价

指向不同函数类型的指针不存在转换规则。

　　int sumLength(const string &, const string &);

　　bool cstringCompare(const char*, const char*);

　　pf = sumLength; //错误；返回类型不匹配

　　pf = cstringCompare; //错误；形参类型不匹配

　　pf = compare; //ok

　　pf = 0; //ok；表示指针没有指向任何一个函数

函数指针形参

和数组类似，虽然不能定义函数类型的形参，但是形参可以是指向函数的指针。此时，形参看起来是函数类型，实际上却是当成指针使用。

　　void useBigger(const string &s1, const string &s2, bool pf(const string &, cosnt string &));

　　//第三个形参是函数类型，它会自动地转换成指向函数的指针

　　void useBigger(const string &s1, const string &s2, bool (*pf)(const string &, cosnt string &));

　　//等价的声明；显式地将形参定义成指向函数的指针

可以直接把函数作为形参使用，此时它会自动转换成指针：

　　useBigger(s1, s2, compare);

使用类型别名和decltype简化使用了函数指针的代码

　　//Func和Func2是某种函数类型

　　typedef bool Func(const string &, const string &);

　　typedef decltype(compare) Func2; //等价的类型

　　//FuncP和FuncP2是指向函数的指针

　　typedef bool (*FuncP)(const string &, const string &);

　　typedef decltype(compare) *FuncP2; //等价的类型

注：与decltype使用数组类似，decltype使用函数也不会将函数转换成指针。因为decltype返回函数类型，所以再加上一个*才能得到指向函数的指针。

此时前述useBigger可声明如下：

　　void useBigger(const string &s1, const string &s2, Func); //或Func2；编译器会自动地将Func表示的函数类型转换成指针

　　void useBigger(const string &s1, const string &s2, FuncP); //或FuncP2

返回指向函数的指针

和数组类似，虽然不能返回一个函数，但是可以返回指向函数类型的指针。

（1）使用类型别名：

　　using F = int(int*, int); //F是函数类型，不是指针

　　using PF = int (*) (int*, int); //PF是指针类型

注意：和函数类型的形参不同，返回类型不会自动地转换成指针，必须显式地将返回类型指定为指针。

　　PF f1(int); //正确；PF是指向函数的指针，f1返回指向函数的指针

　　F f1(int); //错误；F是函数类型，f1不能返回一个函数

　　F *f1(int); //正确；显式地指定返回类型是指向函数的指针

（2）使用一般的方法直接声明：

　　int (*f1(int)) (int*, int);

注解：由内向外，看到f1有形参列表，所以f1是个函数；

f1前面有*，所以f1返回一个指针；

观察右边发现，指针的类型本身也包含形参列表，因此指针指向函数，再看最左边，知道该函数的返回类型是int。

综上，f1是一个形参类型为一个int，返回类型为“指向int(int*, int)类型的函数的指针”的函数。

或者说，f1是一个形参类型为一个int，返回类型为“int (*) (int*, int)”的函数。

（3）使用尾置返回类型：

　　auto f1(int) -> int (*) (int*, int);

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有