C++Primer——第六章(函数)

• 值传递：指实参的值是通过拷贝传递给形参。（函数对形参做的所有操作 都不会影响实参的值）
• 引用传递：形参是引用类型，引用形参是它对应的实参的别名；引用形参直接绑定实参对象，而非对象的副本。（对引用形参的操作 可改变实参的值）

// 尽管形式不同，但这三个print函数是"等价的" （形参都是const int* 类型）
void fun(int*);
void fun(int[]);
void fun(int[5]);      // 5表示我们"期望"数组含有5个元素，实际不一定（5是给人看的，不是必须指定的）

//形参是数组的引用，此时维度是类型的一部分 （编译器不会把数组实参转换为指针，而是传递数组本身，引用形参绑定到实参数组上;  并且编译器检查实参维度的大小与形参维度的大小是否匹配 )
void fun1(int (&a)[5]);       // 维度的长度需指定(数组名可要可不要)

int main() {
    int i = 0;
    int a[2] = { 0,1 };
    int b[5] = { 0,1,2,3,4 };

    fun(&i);	  // 正确: &i的类型是int*
    fun(a);	      // 正确: a转换成int*并指向a[0]（这里可看出传递一维数组，并不需数组大小相同）

    fun1(&i);     // 错误:实参不是含有5个整數的数组  
    fun1(a);      // 错误:实参不是含有5个整数的数组 
    fun1(b);      // 正确:实参是含有5个整数的数组
}

无返回值函数：

有返回值函数：

• 主函数main的返回值：如果结尾没有return，编译器将隐式地插入一条返回0的return语句。返回0代表执行成功。
• 值的返回：返回的值用于 初始化调用点的一个临时量，该临时量就是 函数调用的结果。
• 引用返回左值：函数的返回类型 决定函数调用是否是左值。调用一个返回引用的函数得到左值；其他返回类型得到右值。
• 列表初始化返回值：函数可以返回花括号包围的值的列表。（C++11）

vectorfun() {
	return { 1,2,3 };
}
string fun1() {
	return { 'a','b','c' };
}

int main() {
	vectorvec = fun();        // vec={1,2,3}
	string str = fun1();      // str="abc"
}

• 不要返回局部对象的引用或指针。（当函数结束时局部对象占用的空间也就随之释放掉了，所以return语句指向了不再可用的内存空间）
• return语句的返回值的类型必须和函数的返回类型相同，或者能够隐式地转换成函数的返回类型。

int* fun() {     int a = 1;     return &a;
}

int& fun1() {     int a = 1;     int& t = a;     return t;
}

int fun2() {     double a = 3.14;     return a;
}

int main() {     int* p = fun();      // 错误:*p=1374389535  (函数内局部变量a被释放，p指向一个不可用的空间)     int& b = fun1();     // 错误:b=1374389535   (同理，b引用的对象a被释放掉了)     int c = fun2();      // 正确:c=3 (double可转换为int)     std::cout << *p << " " << b << " " << c; 
}

返回数组指针：

typedef int arrT[10];     // arrT 是一个类型别名，它表示的类型是含有10个整数的数组
using arrT = int[10];     // arrT 的等价声明

arrT* fun();              // fun()返回一个 指向含有10个整数的数组 的指针

int arr[10];

int(*p)[10] = &arr;     // p是一个指向 含有10个整数的数组 的指针
int(*fun())[10];        // fun()函数返回一个 指向含有10个整数的数组 的指针（对照上面一句比较理解）

auto fun()->int(*)[10];      // auto 开头, 形参列表之后是->，紧接着就是函数返回类型(即指向 含有10个整数的数组 的指针)

int arr[10];

decltype(a) *fun();      // 返回一个指向 含有10个整数的数组 的指针（因为是返回的是指针，别忘了(*)！decltype返回一个 含有10个整数的数组类型，所以还要加上(*)）

//重载
int fun(int a);          
int fun(double a);         // 正确: 参数类型不同
int fun(int a, int b);     // 正确: 参数个数不同
float fun(int a);          // 错误: 和第一个函数相比，只有返回值类型不同，不构成重载

//重载和const形参
int fun(const int a);   
int fun(int a);            // 错误: 和上面函数相比，没有const的形参和有 顶层const 的形参无法区分，不构成重载
int fun(const int* a);
int fun(int* a);           // 正确: 和上面函数相比，没有const的形参和有 底层const 的形参可以区分

//重载和作用域
string read();
void print(const string&);
void print(double);         // 重载print函数

void fooBar(int ival) {
	bool read = false;      // 新作用域:隐藏了外层的read（一旦在当前作用域中找到了所需的名字，编译器就会忽略掉外层作用域中的同名实体）
	string s = read();      // 错误: read 是一个布尔值，而非函数

	void print(int);        // 新作用城:隐藏了外层的print（一旦在当前作用域中找到了所需的名字，编译器就会忽略掉外层作用域中的同名实体）
	print("Value: ");       // 错误: print(const string &)被隐藏掉了
	print(ival);            // 正确:当前print(int)可见
	print(3.14);            // 正确:但是print(double)被隐藏掉了，调用的是print(int)。（因为double可以隐式转为int类型，所以可以调用）
}

6.5 特殊用途语言类型

void fun(int a = 1, int b = 2, string c = "c") {     std::cout << a << " " << b << " " << c << std::endl; 
} 

int main() { 
    fun();             // 正确: a=1，b=2，c="c"（abc都为默认值） 
    fun(4);            // 正确: a=4，b=2，c="c"（bc为默认值） 
    fun(4, 4);         // 正确: a=4，b=4，c="c"（c为默认值） 
    fun(4, 4, "d");    // 正确: a=4，b=4，c="d" 

    fun("d");          // 错误: 只能省略尾部的实参（实参必须按形参顺序从左到右给，因此可以省略尾部的实参） 
}

int i = 1, j = 2;
double k = 3;

void fun(int a = i, int b = j, int c = k) {     // 注：(1)局部变量不能作为默认实参!(比如fun定义在main后面，前面的声明在main里面，这时绝对不能用main中定义的局部变量来作为默认实参的初始值）     std::cout << a << " " << b << " " << c << std::endl; 
}

int main() { 
    fun();         // a=1，b=2，c=3 

    i = 10;        // 改变默认实参的值（a=10） 
    int j = 10;    // 内层定义的j 隐藏了外层定义的j，但是没有改变外层定义的的j，也就没有改变默认值（这个两个j定义作用域不同，属于俩个不同的变量） 
    fun();         // a=10，b=2，c=3 
}

内联函数和constexpr函数：

• 内联函数：函数返回类型前 加上关键字inline。
• 普通函数的优点：行为同一，重复利用，易于维护。
• 普通函数的缺点：调用函数 比求解等价表达式要慢得多。
• inline函数既有普通函数的优点，又没有函数调用开销的缺点。（可以避免函数调用的开销，可以让编译器在编译时内联地展开该函数）

• constexpr函数：指能用于常量表达式的函数。（函数的返回类型及所有形参类型 都要是 字面值类型，而且函数体中 必须有且只有一条 retrun语句）

constexpr int fun() {
	return 2;
}
constexpr int m = fun();       // 执行该初始化任务时，编译器把对constexpr函数的调用 替换成其结果值。为了能在编译过程中随时展开，constexpr函数被"隐式地指定为内联函数"。


constexpr int fun1(int a) {    // 如果a是常量表达式则，则fun1(a)也是常量表达式
    return fun() * a;
}   

int main() {
	int arr[fun()];       // 正确：fun()是常量表达式
	
	int i = 1;
	int arr1[fun1(i)];    // 错误：i不是常量表达式，所以fun1(i)返回值 不是常量表达式，（constexpr函数不一定返回常量表达式）
}

• const并不能代表“常量”，它仅仅是对变量的一个修饰，告诉编译器这个变量只能被初始化，且不能被”直接修改“。而且这个变量的值，可以在运行时也可以在编译时指定。
• constexpr可以用来修饰变量、函数、构造函数。一旦以上任何元素被constexpr修饰，那么等于说是告诉编译器 “请大胆地将我看成编译时就能得出常量值的表达式去优化我”。
• 与const相比，被constexpr修饰的对象则强制要求其 初始化表达式能够在 编译期 完成计算。之后所有引用该常量对象的地方，若非必要，一律用计算出来的常量值替换。

调试帮助：

1. 精确匹配：(1)实参类型和形参类型相同。(2)实参从数组类型或函数类型转换成对应的指针类型。(3)向实参添加项层const或者从实参中删除顶层const。
2. 通过const转换实现的匹配。
3. 通过类型提升实现的匹配。
4. 通过算术类型转换或指针转换实现的匹配。
5. 通过类类型转换实现的匹配。

• 该函数 每个实参的匹配都不劣于 其他可行函数需要的匹配。
• 至少有一个实参的匹配优于 其他可行函数提供的匹配。

6.7 函数指针

int fun(int a, int b) { return a + b; }
int fun(double a, double b) { return a + b; }
double fun1(double a, double b) { return a + b; }

int main() {
	int (*pf)(int, int);     // pf是一个指向 有两个int参数且返回值为int类型的函数 的指针（注: pf两端括号必不可少，不然pf变成一个返回值为int*类型的函数）

	pf = fun;       // pf指向fun函数（当我们把函数名作为一个值使用时，该函数自动地转换成指针）
	pf = &fun;      // 与上面赋值语句等价: 取地址符是可选的

	int a = pf(1, 1);        // 调用fun函数，a=2（同理，当我们把函数名作为一个值使用时，该函数自动地转换成指针）
	int b = (*pf)(1, 1);     // 等价调用，a=2

	pf = 0;        // 正确，pf不指向任何函数
	pf = fun1;     // 错误: 返回类型不匹配（在指向不同函数类型的指针间不存在转换规则，必须精确匹配!）
	pf = fun;      // 正确: 和fun(int,int)精确匹配（形参类型，形参个数，返回值类型 都要精确匹配）
}

• 当我们把函数名作为一个值使用时，该函数自动地转换成指针
• 在指向不同函数类型的指针间不存在转换规则，必须精确匹配!

int fun(int a, int b);
int fun1(int a, int b, int pf(int, int));       // 第三个形参是函数类型，但它会自动转换成指向函数的指针
int fun1(int a, int b, int(*pf)(int, int));     // 等价声明: 显式地将形参定义成 指向函数的指针


// 使用类型别名或者decltype
typedef int func(int a, int b);
typedef decltype(fun) func1;            // func和fun1是相同的 函数类型

typedef int (*func_p)(int a, int b);
typedef decltype(fun)* func1_p;         // func_p和func1_p是相同的 函数指针类型


int main() {
	fun1(1, 1, fun);     // 自动将函数fun转换成指向该函数的指针（可以直接把函数作为实参使用，此时它会自动转换成指针）

	func f;              // f为 fun函数类型
	func_p f_p;          // f_p为 fun函数指针类型
	fun1(1, 1, f);       // 正确
	fun1(1, 1, f_p);     // 正确
}

int fun1(int, int) {}
int (*fun(int))(int, int) {  }      // 定义


using func = int(int, int);         // func为 函数类型
using func_p = int(*)(int, int);    // func_p为 函数指针类型


// 使用 类型别名、直接定义、尾置返回类型、decltype 四种方式声明返回函数指针的函数
func_p fun(int);
int (*fun(int))(int, int);
auto fun(int) ->int (*)(int, int);
decltype(fun1)* fun(int);           // (*)别忘记，decltype作用于函数时返回的是函数类型              


func fun(int);      // 错误: func是函数类型，fun不能返回一个函数（必须把返回值写成函数指针形式，编译器不会自动地将 函数返回类型当成对应指针类型处理）
func_p fun(int);    // 正确: func_p是指向函数的指针，fun返回指向函数的指针，并且类型匹配
func* fun(int);     // 正确: 显示地 指定返回类型 是指向函数的指针