C++面向过程程序设计

函数
引用
模板函数

1. 函数

1.1. 函数的声明与定义

C语言中，函数声明或定义中如果省略返回类型就是缺省为int。而在C++中，函数必须注明返回类型。比如
```
   1 max(int a, int b) { /*省略返回类型，在C语言中意味着返回类型为int，在C++中则是语法错误*/
   2     return a>b?a:b;
   3 }
```

C语言中，如果函数返回类型是int，则函数可以不用声明直接使用。C++中，在函数使用前必须先声明或定义。比如

   1 #include <stdio.h>
   2 int main() {
   3     printf("%d", max(4, 3)); /*调用的函数在此处并未声明或定义，在C语言中意味着max函数带两个int型的参数返回类型是int，在C++中是语法错误。*/
   4 }
   5 
   6 int max(int a, int b) {
   7     return a>b?a:b;
   8 }

C语言中，函数声明中空白的参数列表表示参数个数和类型未知。C++中，函数声明中空白的参数列表表示函数不需要参数。

   1 #include <stdio.h>
   2 int max(); /*此处函数声明中形参空白，在C语言中意味着这个函数的参数未知，在C++中意味着这个函数没有参数。*/
   3 
   4 int main() {
   5     printf("%d", max(4, 3)); /*此处函数调用，在C语言中是合法的，在C++中是不合法的，因为与前面函数声明不一致。*/
   6 }
   7 
   8 int max(int a, int b) {
   9     return a>b?a:b;
  10 }

在C++中需要这样声明和定义函数：

   1 #include <iostream>
   2 using namespace std;
   3 
   4 int max(int a, int b); //函数声明
   5 
   6 int main() {
   7     cout << max(4, 3);
   8 }
   9 
  10 /*函数定义*/
  11 int max(int a, int b) {
  12    return a>b? a : b;
  13 }

在C++中，main函数的标准写法有两种。返回int值用于告诉操作系统程序运行的结果，一般返回0表示程序正常结束，返回其它值表示错误代码。

   1 int main() {
   2     //...
   3     return 0;
   4 }
   5 int main(int argc, char *argv[ ]) {
   6     //...
   7     return 0;
   8 }

1.2. 内联函数

参见:C++:内联函数

1.3. 参数默认值

C++允许函数某些参数有默认值(default parameter)，比如：

   1 void print(int value, float s = 1.6, char t = '\n', bool c = true);
   2 int main() {
   3     print(14, 48.3, '\t', false);
   4     print(14, 48.3, '\t');
   5     print(14, 48.3);
   6     print(14);
   7 }
   8 void print(int value, float s, char t, bool c) {
   9     cout << value << s << t << c;
  10 }

注意：

默认值在函数声明中指定。
默认值必须以常数的形式指定。
有默认值的参数必须出现在没有默认值的参数的右边。
调用函数时，不能省略中间的参数而去指定后面的参数。

1.4. 函数重载

在C语言中，不允许有同名函数。在C++中允许两个以上的函数取相同的函数名，称作函数重载(overload)。例如要写一组功能相同但是参数类型不同的函数：

   1 /*in C*/
   2 void print_double(double d);
   3 void print_int(int i);
   4 void print_string(const char *s);

在C++中这些函数可以使用相同的名字。

   1 // in C++
   2 void print(double d);
   3 void print(int i);
   4 void print(const char *s);
   5 int main() {
   6     print(1.0);
   7     print(2);
   8     print("hello");
   9 }

注意：

同名的函数的形参的个数、类型或者顺序必须有所不同。在调用时，编译器根据实参和形参的个数、类型和顺序来进行匹配。参数相同、返回值不同的同名函数不能重载：
```
   1 void print(int i);
   2 int print(int i); //error
   3 
```
某些情况下，一些函数可以重载，但是特定的函数调用会产生歧义。比如：

   1 void print(int i);
   2 void print(int i, int j=0);
   3 int main() {
   4     print(1, 2); //ok!
   5     print(1); //error! ambiguous!
   6 }

   1 void print(int i, double j);
   2 void print(double i, int j);
   3 int main() {
   4     print(1.0, 2); //ok!
   5     print(1, 2.0); //ok
   6     print(1, 2); //error! ambiguous!
   7 }

2. 引用

引用(reference)就是变量的别名。定义一个变量的引用就相当于给一个变量取了个别名。

   1 int main() {
   2    int i;
   3    int &ref = i;  //ref是i的别名
   4    i = 3;
   5    ref = 5;
   6    float f[5] = {1,2,3,4,5};
   7    float &fref = f[3];
   8 }

注意：

定义引用一定要初始化。
被引用的必须是左值(l-value)。

例如：

   1 int main() {
   2     int &ref; // 没有指明引用的对象（即没有初始化）
   3     int &ref2 = 123; //不能引用常量，常量不是左值
   4 }

引用可以作为参数传递

   1 void swap(int &a, int &b) {//型参a和b是实参的别名，即对型参a和b的操作就是对实参的操作。
   2     int t = a;
   3     a = b;
   4     b = t;
   5 }
   6 int main() {
   7     int i = 7, j = -3;
   8     swap(i, j); // i and j swapped
   9 }

引用可以作为返回值

   1 int & index(int a[], int i) {
   2     return a[ i - 1];
   3 }
   4 int main() {
   5     int array[] = {1, 2, 3, 4, 5, 6, 7, 8};
   6     index(array, 1) = 5;
   7 }

在引用前面加const，表示不能通过这个引用（别名）去修改变量（但是原来的变量可能是可变的，也可能是不可变的）

   1 void display (const double &r) {
   2     cout << r << endl;  //可以读取变量的值
   3     r = 12.0; // error!但是不可以修改
   4 }
   5 int main() {
   6     double d = 10.0;
   7     const pi = 3.14159;
   8     display(d);    //可以给const型的引用传普通变量
   9     display(pi);   //可以给const型的引用传const变量
  10     display(10.0);  //可以给const型的引用传常量！！
  11 }

const引用变量可以引用普通变量，普通的引用变量不能引用const变量。比如

   1 int main() {
   2     int i = 5;
   3     const int &r1 = i;
   4     const int j = 10;
   5     const int &r3 = j; // ok
   6     int &r3 = j;       // error
   7 }

3. 模板函数

参见：C++:模板函数

CategoryCpp