c++课程记录————函数（一）-工具盒子

函数 {#函数}

每个 C++ 程序都至少有一个函数，即主函数 main() ，所有简单的程序都可以定义其他额外的函数。

将多个功能拆分并最终组合，用于调用。实现功能如递归等

简单实例

|---------------------|---------------------------------------------| | 1 2 3 4 5 6 | void 函数名() { 函数执行内容 ... return 0; } |

|---------------------|----------------------------------------| | 1 2 3 4 5 6 | def 函数名(): 函数执行内容 ... return 0 |

c/c++程序入口为main函数，没有main不能执行，有且只有一个main函数。

|------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------| | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | // 函数返回两个数中较大的那个数 int max(int num1, int num2) { // 局部变量声明 int result; if (num1 > num2) result = num1; else result = num2; return result; } |

函数的构成 {#函数的构成}

函数声明 {#函数声明}

|-----------|------------------------------------------------------| | 1 | return_type function_name( parameter list ); |

函数类型 {#函数类型}

有返回值
int ，float，double，bool ...
无返回值
void

return_type: 返回类型，表示函数执行后返回的数据类型。例如，int、float、double等，而void表示无需返回结果的函数。

function_name: 函数名，用于标识函数的唯一名称。函数名应该遵循命名规则，以字母或下划线开头，后面可以跟字母、数字或下划线。

parameter list: 参数列表，用于指定函数接收的输入参数。参数列表中的每个参数都由一个类型和一个变量名组成，多个参数之间用逗号分隔。例如，int a, float b, double c。

;: 分号，用于结束函数声明。

函数的调用 {#函数的调用}

创建一个实例程序

|------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | int sum() //无参函数 { int x=10,y=60; int s = x + y; return s; } int sum1(int x,int y)//带参函数 { int s; s = x + y; return s; } void sum2()//无返回值 { int x = 10,y = 60; int s; s = x + y; cout <<s<<endl; } ... int main() { cout<<sum()<<endl; //调用参数（函数的调用） cout<<sum1(10,60)<<endl; //运行效果相同（） //实参传参给形参 10，60传递给函数里面的x，y sum2(); //调用函数 return 0; } |

创建 C++ 函数时，会定义函数做什么，然后通过调用函数来完成已定义的任务。

当程序调用函数时，程序控制权会转移给被调用的函数。被调用的函数执行已定义的任务，当函数的返回语句被执行时，或到达函数的结束括号时，会把程序控制权交还给主程序。

出自菜鸟教程

调用函数时，传递所需参数，如果函数返回一个值，则可以存储返回值。例如：

|------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | #include <iostream> using namespace std; // 函数声明 int max(int num1, int num2); int main () { // 局部变量声明 int a = 100; int b = 200; int ret; // 调用函数来获取最大值 ret = max(a, b); cout << "Max value is : " << ret << endl; return 0; } // 函数返回两个数中较大的那个数 int max(int num1, int num2) { // 局部变量声明 int result; if (num1 > num2) result = num1; else result = num2; return result; } |

参数 {#参数}

举例此次sum1函数

sum1(10,60) 中的10,60为实参，sum1(int x,int y) 中的int x,int y为形参，单向值传递，实参传递到形参，形参不影响实参

以后的地址传递可以影响

举例：
单向值传递，实参传递到形参，就像家人（实参）给你（形参，函数内）打的生活费（参数），你手上的资金不会改变（实参）

地址传递，就像家人（实参）给你（形参）一个银行账户（地址），你对账户内的改变会影响（实参）

地址传递是一种将实际参数的地址传递到函数中的参数传递方式。在函数中对参数进行的修改，将影响到实际参数。这是因为形参接收到的是实参的地址，即指向实参的存储单元，形参和实参占用相同的存储单元。例如，如果我们定义了一个指针类型的形参，然后将实参的地址传递给这个形参，那么在函数内部对形参所进行的修改，将影响到实际参数的值。

| 调用类型 | 描述 | |------|--------------------------------------------------------------| | 传值调用 | 该方法把参数的实际值赋值给函数的形式参数。在这种情况下，修改函数内的形式参数对实际参数没有影响。 | | 指针调用 | 该方法把参数的地址赋值给形式参数。在函数内，该地址用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。 | | 引用调用 | 该方法把参数的引用赋值给形式参数。在函数内，该引用用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。 |

地址传参 {#地址传参}

地址传递是C++中的一种参数传递方式，它允许函数直接修改实参的值。当我们使用地址传递时，函数会接收到实参的内存地址，而不是实参的值。因此，在函数内部对实参进行的任何修改都会影响到实参本身。

下面是一个使用地址传递的C++示例：

|------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | #include <iostream> using namespace std; void modify(int *num) { *num = 100; } int main() { int a = 50; cout << "Before calling modify function: " << a << endl; modify(&a); cout << "After calling modify function: " << a << endl; return 0; } |

在这个示例中，我们定义了一个名为modify的函数，它接受一个指向整数的指针作为参数。在main函数中，我们将变量a的地址传递给modify函数。在modify函数内部，我们通过解引用指针来修改实参的值。因此，当我们调用modify(&a)后，实参a的值被修改为100。

函数重载 overloading function {#函数重载-overloading-function}

函数名相同
参数不同
参数类型不同
参数个数不同

|------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | int min_num(int a,int b) { return a<b?a:b; } float min_num(float a,float b) { return a<b?a:b; } int min_num(int a,int b,int c) { return min_num(min_num(a,b),c); } int main() { min_num(a,b)//a,b参数的类型若为float则调用float min_num min_num(int a,int b,int c)//三个参数则会调用 min_num(int a,int b,int c) } |

参数默认值 {#参数默认值}

默认赋值只能自右向左。

若函数没有被传入参数，则使用默认参数

定义参数时viod minnum(int ,int =0,int =5)自右向左

调用函数时minnum(10,20);自左向右依次赋值给a，b

c使用默认值

|------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------| | 1 2 3 4 5 6 7 8 9 10 11 12 | viod minnum(int ,int =0,int =5); int main() { minnum(10,20); minnum(10); } viod minnum(int a,int b,int c) { cout<<a<<b<<m<<endl } |

内联函数 {#内联函数}

简单的短函数编译到主函数内

没有循环和switch的函数

inline int function

将函数直接编译到主函数内，可以加快执行速度

静态局部变量 {#静态局部变量}

static声明

函数中的局部变量不会随函数调用结束而清除

在C++中，static int a 是一个静态局部变量。它的作用域仅限于定义它的函数或代码块。当程序执行到这个变量时，它会在内存中分配一个固定大小的存储空间，用于存储整数值。静态局部变量的生命周期与程序的运行时间相同，即在整个程序运行期间，它都存在。

|-----------------------|---------------------------------------------------| | 1 2 3 4 5 6 7 | void f() { static int a; } int main() { } |

访问全局变量 {#访问全局变量}

在局部变量中使用::a访问全局变量

|-------------------------|----------------------------------------------------------------------------------------| | 1 2 3 4 5 6 7 8 | int a = 10; //全局变量 void func() { int a = 20; //局部变量 ::a; //访问全局变量a } ::a is 10 |

变量的引用 {#变量的引用}

int& a 是一个引用类型，表示一个整数变量的引用。在C++中，引用是一种别名，它允许你通过引用来访问和修改另一个变量的值。使用引用可以避免不必要的拷贝操作，提高程序的性能。

引用是C++中的一种特殊类型，它提供了一种方式来直接访问和操作其他变量的值。引用是一个已存在变量的别名，通过引用可以间接地访问该变量的值，而不需要复制整个变量。

在C++中，声明一个引用需要使用&运算符，后面跟着要引用的变量的名称。例如，int& a表示一个整数类型的引用，名为a。

引用与指针有些类似，但有一些重要的区别：

引用必须在声明时初始化，并且之后不能再改变指向的变量；而指针可以在任何时候改变指向的变量。
引用没有空引用的概念，即必须始终指向一个实际存在的变量；而指针可以为空。
引用使用.运算符来访问其指向的变量的值，而指针使用->运算符。
引用传递参数时，实际上是将实参的地址传递给形参，因此对形参的修改也会影响到实参；而指针传递参数时，是将实参的值（即地址）传递给形参，对形参的修改不会影响实参。

|------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | #include <iostream> void swap(int& a, int& b) { int temp = a; a = b; b = temp; } int main() { int x = 5; int y = 10; std::cout << "Before swap: x = " << x << ", y = " << y << std::endl; swap(x, y); // 通过引用交换x和y的值 std::cout << "After swap: x = " << x << ", y = " << y << std::endl; return 0; } |

|-------------|--------------------------------------------------------------| | 1 2 | Before swap: x = 5, y = 10 After swap: x = 10, y = 5 |

引用与指针 {#引用与指针}

在C++中，"地址的引用"通常被理解为对指针所指向的变量的别名。具体来说，当我们创建一个指针变量时，例如 int* p = &val;，指针变量p就包含了另一个变量val的地址。此时，我们可以通过 *p来访问或修改指针所指向的变量的值。

然而，C++还提供了一种更为简洁的方式，即引用(reference)。引用是某一变量（目标）的一个别名，对引用的操作与对变量直接操作完全一样，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。例如，我们可以声明一个整数类型的引用，如 int& a = val;，此后a就成为了val的别名，对a的任何操作都会直接影响到val。

总的来说，无论是使用指针还是引用，都可以实现对变量的间接访问。但需要注意的是，指针和引用在使用上有一些重要的区别：指针是一个包含了另一个变量地址的变量，而引用则是一个已经初始化并指向某个变量的别名。另外，一旦引用被初始化为一个变量后，就不能再改变它指向另一个变量。

ps."一旦引用被初始化为一个变量后，就不能再改变它指向另一个变量"的意思是，在C++中，一旦我们声明并初始化了一个引用，例如 int& a = val;，那么这个引用（这里用 a 表示）就会始终指向 val 变量，并且无法更改使其指向其他变量。换句话说，引用的生命周期是与它最初指向的变量共存亡的。
这是因为引用实际上就是目标变量的一个别名。换句话说，引用和它所引用的变量共享同一块内存空间。因此，如果我们试图让引用指向另一个变量，那将会导致意想不到的结果，因为那个新的变量并没有与旧的变量共享同一块内存空间。