Tags:C++,《C++ Primer Plus》笔记
一、原型、定义与调用##
一个完整的函数包含原型、定义和调用三个部分。
原型###
除了 int main() 函数以外，所有的函数都应该有自己的原型声明，放在其作用域的最前端。
原型的作用类似于类型声明，它用于声明一个函数，告诉编译器如何处理这个函数的参数和返回值，从而更高效率地运用内存。原型的语法为：
<函数返回值的类型> <函数名>（<参数类型>）
< 函数返回值的类型 > 为 void 时，即表示函数不返回值，此时函数的行为如同一个语句。
< 参数类型 > 需要一个个指明每个参数的类型，为了良好习惯，原型中最好不要带参数名。为空或者 void 时，即表示函数不接受任何参数。
</br>
定义###
即定义函数的内容，通用语法如下：
typeName functionName(parameterList){
statements
return value; //value is type cast to type typeName
}
</br>
调用###
函数的调用直接 functionName(argumentList) 即可，需要注意的地方是静态类型检查。
原型已经告诉了编译器函数接受的参数类型，如果传递的实参类型不匹配，编译器会自动进行类型转化。但是类型转化仅对算术类型有用，编译器不能把一个指针转化为一个整型。这个过程就叫静态类型检查。
</br>
二、参数的传递##
函数的参数传递有按值传递、按引用传递和按指针传递三种，尤其要注意：
- 内在的实现机制及相互之间的区别。
- 指针传递中
const操作符的使用。
理顺了参数的传递才能理顺函数的原型类型声明，才算理清了C++的基础。
按值传递###
函数定义中用于接收传递值的变量被称为形参，调用时传递给函数的值被称为实参。平时所说的参数一般指实参，参量指形参。
double cube(double); //函数原型
double cube(double n){
n = 1; //n被重置为1，因此参数形同虚设，但haha值不会被影响
return n*n;
} //n就是形参
double haha = 5;
cube(haha); //5就是实参
cout << haha //haha值不会被影响
在函数定义中声明的变量，包括非引用的形参在内，都是函数私有的局部变量。
传递参数时，值将复制一份到实参中，以定义中形参的方式参与函数的计算。
函数运行完毕后，函数作用域被释放，复制出来的局部变量也被销毁。
这个过程就叫按值传递的过程，实参是复制出来的局部变量，是原始数据的副本。
因此，对于按值传递的参数而言，函数运行中若改变了实参的值，原来的值不会被改变。
</br>
按引用传递###
double cube(double &); //函数原型
double cube(double & n){
n = 1; //n被重置为1，由于是引用，haha值也被重置为1
return n*n;
}
double haha = 5;
cube(haha);
cout << haha; //haha值也被重置为1
引用是C++新增的一种复合类型，引用是已定义的变量的别名，而typedef是类型的别名，这两者概念雷同，但用法不同。
引用类型作为一种复合类型，就如同指针一样，具有其类型声明：<typeName> & aliasName = value 。注意引用类型必须在声明的同时赋值。（其实引用相当于 <typeName> * const pn = &value中的 *pn，是一种伪装过的指针常量。）
将引用变量作为函数的参数，函数将使用原始数据，而不是其副本，这就是按引用传递。换言之，原始数据会被更改。
</br>
按指针传递###
当函数与数组挂钩时，参数的类型就十分暧昧了。
C++允许直接使用 <typeName> [] 作为参数类型，也允许直接使用指针。
void show(const double arr[],int size);
void show(const double * arr,int size);
这两种方式没有区别，都指向数组的第一个元素。
重点是，为什么要使用 const ？
const double * 表示常量指针，其表示指针所保存的内存地址是只读的，这里有个很微妙的地方：
内存地址是只读的，内存是可写的。
这意味着不能通过常量指针修改指针所指向的内存，但可以修改变量本身：
int a = 5;
const int *p1 = &a;
*p1 = 10； //报错，Location只读
int a = 5;
const int *p1 = &a;
a = 10;
cout << *p1; //10...心塞...注意是通过指针访问的
因此我们可用这样的方法来控制函数内部是否可修改原始数据，按指针传递是否可修改原始数据是可控的。
作为扩展，可看看下面几种情况：
- 常量只能赋值给常量指针，谁都动不了原始数据。
const int a = 5;
int *p1 = &a; //报错，常量只能赋值给常量指针
- 还记得前面说的引用相当于指针常量（不是常量指针！）吗...
int a = 5;
int * const p1 = &a;
*p1 = 10; //通过指针常量修改了a的值
cout << *p1; //10，可行的！内存地址可写可读！
所以...这里的 const 有什么用？其实这里的 const 只是想说，指针本身是不可改变的。
int a = 5;
int b = 20;
int * const p1 = &a;
p1 = &b; //报错！p1只读！
/* *p1 = b */ //可以这么干，但这样相当于是重写a
那么，常量指针可以改变指针本身吗？
int a = 5;
int b = 20;
const int *p1 = &a;
p1 = &b; //可行！
因此总结下，指针其实有三层：变量、变量内存地址、指针本身（在高维指针中，也看成是个变量）。
const <typeName> * 表示指针所指向的变量内存地址是常量。
<typeName> * const 表示指针本身是常量。
什么？变量是常量怎么写？
呵呵。
</br>
二、函数与指针##
函数名本身表示该函数的地址。后面接 () 时，表示运行函数后的返回值，也是调用函数。
因此声明一个函数的指针，只需要将函数原型中的函数名改为 (*pn) 即可，pn 为指向函数名的指针，(*pn) 声明后与函数名等价。例如：
double (*pn)(int); //函数的指针
double *pn(int); //返回指针的函数
(*pn)();
</br>
数组与指针###
- 数组指针（行指针）
在看一些接下来那些恐怖的函数指针前，我们先来理解几个与指针有关的类型：
int a[2][3];
int (*p)[3];
按照之前与函数指针的对比，(*p) 对应 a[2] ，而 a 是一个两行三列横向填充的二维数组。显然，p 指向第一行（即 a[0][2]），p+1 将指向第二行（即 a[1][2]），因此也叫行指针。
例如下面的代码。假设我想拿到 20 ，通过指针应该怎么访问？
int a[2][3] = {{12,14,16},{18,20}};
int (*p)[3] = a;
cout << *p << endl;
cout << *(*(p+1)+1) << endl; //*(p+1)，指向第二行的指针解除引用，得到第二行的数组，即得到列指针。列指针加1指向第二列，解除引用得到20。
- 指针数组
就是一堆指针构成的数组，这个好理解很多。
int *p[3];
表示有三个指针构成的数组。
</br>
前方高能###
我们先来看一个恐怖的东西：
const double * f1(const double ar[],int n);
const double * f2(const double [],int);
const double * f3(const double *,int);
const double * (*pa[3])(const double *,int) = {f1,f2,f3};
const double *(*(*pn)[3])(const double *,int) = &pa;
没错，这是一个指向包含了三个函数元素的数组的指针...
来来来，我们抽丝剥茧... (*pa[3]) 是3个指针构成的指针数组，pa[0] 指向 f1 。而 (*pn)[3] 是一个数组指针，指向第一行数组。可是这里没有二维数组呀？
如果看到了 &pa ，那一切就能理解了。&pa 将整个数组的地址给了 pn，使其成为了一个类似于 {{f1,f2,f3}} 的行指针（尽管只有一行）。(*pn)[3] 前面的 * 号对其解除引用，得到了 f1 函数。
