依然是 学习C++基础，本文让我们从函数开始。
函数
函数是一组一起执行一个任务的语句。每个 C++ 程序都至少有一个函数，即主函数 main() ，所有简单的程序都可以定义其他额外的函数。
函数的声明
函数声明告诉编译器函数的名称、返回类型和参数。在函数声明中，参数的名称并不重要，只有参数的类型是必需的
return_type function_name( parameter list );当在一个源文件中定义函数且在另一个文件中调用函数时，函数声明是必需的。此时，应该在调用函数的文件顶部声明函数。
函数的定义
C++ 中的函数定义的一般形式如下：
return_type function_name( parameter list ){ body of the function }在 C++ 中，函数由一个函数头和一个函数主体组成。下面列出一个函数的所有组成部分：
- 返回类型：一个函数可以返回一个值。return_type 是函数返回的值的数据类型。有些函数执行所需的操作而不返回值，在这种情况下，return_type 是关键字 void。
- 函数名称：这是函数的实际名称。函数名和参数列表一起构成了函数签名。
- 参数：参数就像是占位符。当函数被调用时，您向参数传递一个值，这个值被称为实际参数。参数列表包括函数参数的类型、顺序、数量。参数是可选的，也就是说，函数可能不包含参数。
- 函数主体：函数主体包含一组定义函数执行任务的语句。
函数的调用
当程序调用函数时，程序控制权会转移给被调用的函数。被调用的函数执行已定义的任务，当函数的返回语句被执行时，或到达函数的结束括号时，会把程序控制权交还给主程序。
调用函数时，传递所需参数，如果函数返回一个值，则可以存储返回值。
函数的参数
形式参数就像函数内的其他局部变量，在进入函数时被创建，退出函数时被销毁。当调用函数时，有三种向函数传递参数的方式：
1. 传值调用
把参数的实际值复制给函数的形式参数。在这种情况下，修改函数内的形式参数不会影响原实际参数。默认情况下，C++ 使用传值调用方法来传递参数。即：
void swap(int x, int y);2.指针调用
向函数传递参数的指针调用方法，把参数的地址复制给形式参数。在函数内，该地址用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。即：
void swap(int *x, int *y);3.引用传递
把引用的地址复制给形式参数。在函数内，该引用用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。比如swap:
// 函数定义
void swap(int &x, int &y)
{
int temp = x; /* 保存地址 x 的值 */
x = y; /* 把 y 赋值给 x */
y = temp; /* 把 x 赋值给 y */
return;
}优化的 swap：
int swap(int& a, int& b)
{
int temp = a ^ b;
a = temp ^ a;
b = temp ^ b;
return 0;
}利用了数异或的性质，一个数与其本身异或等于 0，0 与一个数异或不改变该数。
参数的默认值
定义函数时，可以为参数列表中每一个参数指定一个默认值（使用赋值运算符来为参数赋值）。当调用函数时，如果实际参数的值留空，则使用这个默认值；如果指定了值，则会忽略默认值，使用传递的值：
#include <iostream>
using namespace std;
int sum(int a, int b=20){return a+b;}
void main ()
{
// 局部变量声明
int a = 100,b = 200;
// 调用函数来添加值
cout << "Total value is :" << sum(a, b) << endl;
// 再次调用函数
cout << "Total value is :" << sum(a) << endl;
}Lambda 函数与表达式
C++11 提供了对匿名函数的支持,称为 Lambda 函数与表达式。
Lambda 表达式把函数看作对象。Lambda 表达式可以像对象一样使用，比如可以将它们赋给变量和作为参数传递，还可以像函数一样对其求值。Lambda 表达式具体形式如下：
[capture](parameters)->return-type{ body }举个例子：
[](int x, int y) -> int { int z = x + y; return z + x; }一个临时的参数 z 被创建用来存储中间结果。如同一般的函数，z 的值不会保留到下一次该不具名函数再次被调用时。如果 lambda 函数没有返回值值（例如 void），则返回类型可被完全忽略。
在Lambda表达式内可以访问当前作用域的变量，这是Lambda表达式的闭包（Closure）行为。 这与JavaScript闭包不同，C++变量传递有传值和传引用的区别。可以通过前面的 [ ] 来指定：
[] // 沒有定义任何变量。使用未定义变量会引发错误。
[x, &y] // x以传值方式传入（默认），y以引用方式传入。
[&] // 任何被使用到的外部变量都隐式地以引用方式加以引用。
[=] // 任何被使用到的外部变量都隐式地以传值方式加以引用。
[&, x] // x显式地以传值方式加以引用。其余变量以引用方式加以引用。
[=, &z] // z显式地以引用方式加以引用。其余变量以传值方式加以引用。注意：对于[=]或[&]的形式，lambda 表达式可以直接使用 this 指针。但是，对于[ ]的形式，如果要使用 this 指针，必须显式传入（在 [ ] 内写上this 指针）：
//[capture](params){ body }
[this] ( ) { this-> someFunc();}();数学运算
内置函数中有很多用于数学运算的函数，需要引用数学头文件 <cmath> 才能使用它们：
| 函数 | 描述 |
| double cos(double); | 该函数返回弧度角（double 型）的余弦。 |
| double sin(double); | 该函数返回弧度角（double 型）的正弦。 |
| double tan(double); | 该函数返回弧度角（double 型）的正切。 |
| double log(double); | 该函数返回参数的自然对数。 |
| double pow(double, double); | 假设第一个参数为 x，第二个参数为 y，则该函数返回 x 的 y 次方。 |
| double hypot(double, double); | 该函数返回两个参数的平方总和的平方根，也就是说，参数为一个直角三角形的两个直角边，函数会返回斜边的长度。 |
| double sqrt(double); | 该函数返回参数的平方根。 |
| int abs(int); | 该函数返回整数的绝对值。 |
| double fabs(double); | 该函数返回任意一个浮点数的绝对值。 |
| double floor(double); | 该函数返回一个不大于传入参数的最大整数。 |
随机数
对于c++的随机数生成器，有两个相关的函数（需要引用头文件 stdlib.h ）。一个是 int rand(void); ，该函数只返回一个伪随机数。生成随机数之前必须先调用 void srand(unsigned int seed); 函数来设置随机数的种子（种子相同时，每次执行程序时产生的随机数序列是一样的）。
#include <iostream>
#include <ctime>
#include <cstdlib>
using namespace std;
void main ()
{
int i,randNum;
// 设置种子
// time() : time_t time(time_t *t),返回时间戳, 若参数 *t不为空，将返回值也存储在指针 t 指向的内存空间//
srand( (unsigned)time( NULL ) );
/* 生成 10 个随机数 */
for( i = 0; i < 10; i++ ){ // 生成实际的随机数
randNum= rand();
cout <<"随机数： " << randNum << endl;
}
}数组
C++ 支持数组数据结构，它可以存储一个固定大小的相同类型元素的顺序集合。数组的声明是声明一个数组变量，数组中的特定元素可以通过索引访问。所有的数组都是由连续的内存位置组成。最低的地址对应第一个元素，最高的地址对应最后一个元素。
声明数组
C++ 中声明一维数组，需要指定元素的类型和元素的数量，如下所示：
type arrayName [ arraySize ];arraySize 必须是一个大于零的整数常量，type 可以是任意有效的 C++ 数据类型。
初始化数组
C++ 中，可以逐个初始化数组中的元素，也可以使用一个初始化语句：
double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};
大括号 { } 之间的值的数目不能大于我们在数组声明时在方括号 [ ] 中指定的元素数目。初始化的时候如果省略掉了数组的大小，数组的大小则为初始化时元素的个数。
访问数组
数组元素可以通过数组名称加索引进行访问。元素的索引是放在方括号内，跟在数组名称的后边。所有的数组都是以 0 作为它们第一个元素的索引，也被称为基索引，数组的最后一个索引是数组的总大小减去 1。以下是上面所讨论的数组的的m图形表示：
多维数组
多维数组声明的一般形式如下：
type name[size1][size2]...[sizeN];二维数组，在本质上，是一个一维数组的列表，其声明及初始化：
int a[2][3] = {
{0, 1, 2, 3} , /* 初始化索引号为 0 的行 */
{4, 5, 6, 7} , /* 初始化索引号为 1 的行 */
};
//内部嵌套的括号是可选的，下面的初始化与上面是等同的
int a[2][3] = {0,1,2,3,4,5,6,7};指向数组的指针
数组名是一个指向数组中第一个元素的常量指针。
double *p,balance[10];
p = balance;balance 是一个指向 &balance[0] 的指针，即数组 balance 的第一个元素的地址。 把 p 赋值为 balance 的第一个元素的地址。使用数组名作为常量指针是合法的，反之亦然。因此，*(balance + 4) 是一种访问 balance[4] 数据的合法方式。注意：
1. *p+4 是指 p 是指向balance数组的首地址（&balance[0]）的指针（&表示取地址），*p是对首地址的元素取值（*在赋值符号右边和表达式中表示取值），该值加4即为 balance[0] +4
2. *(p+4) 是指 p 是指向balance数组的首地址（&balance[0]）的指针（&表示取地址） , p+4表示地址加上4，*再对p+4取值，所以，*(p+4) 表示 balance[4] （第5个元素的值）。
C++ 中，将 char * 或 char[ ] 传递给 cout 进行输出，结果会是整个字符串，如果想要获得字符串的地址（第一个字符的内存地址），方法为：强制转化char * 为其他指针（void *，int *，float *， double *）：
#include <iostream>
using namespace std;
const int MAX = 3;
void main ()
{
char var[MAX] = {'a', 'b', 'c'};
char *ptr;
// 指针中的数组地址
ptr = var;
for (int i = 0; i < MAX; i++){
cout << "Address of var[" << i << "] = " << (int *)ptr ;
cout << "Value of var[" << i << "] = " << *ptr;
// 移动到下一个位置
ptr++;
}
}传递数组给函数
要在函数中传递一个数组作为参数，必须以下面三种方式来声明函数形式参数。这三种声明方式的结果是一样的，因为每种方式都会告诉编译器将要接收一个整型指针。
1. 形式参数是一个指针：
void myFunction(int *param) { body of function }2. 形式参数是一个已定义大小的数组：
void myFunction(int param[]) { body of function }3. 形式参数是一个未定义大小的数组：
void myFunction(int *param) { body of function }从函数返回数组
要从函数返回一个一维数组，必须声明一个返回指针的函数，：
int * myFunction(){ body of function }C++ 不支持在函数外返回局部变量的地址，除非为static 局部变量。示例（//从函数返回一个由10个随机数构成的数组）：
#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;
/* 要生成和返回随机数的函数 */
int * getRandom( ){
static int r[10];
/* 设置种子 */
srand( (unsigned)time( NULL ) );
for (int i = 0; i < 10; i++){
r[i] = rand();
cout << "r[" << i << "] = " << r[i] << endl;
}
return r;
}
/* 要调用上面定义函数的主函数 */
void main ()
{
/* 一个指向整数的指针 */
int *p;
p = getRandom();
for (int i = 0; i < 10; i++ )
cout << "*(p + " << i << ") : " << *(p + i) << endl ;
}