C语言函数定义和函数声明
c语言函数的实现
c语言函数的实现摘要：1.C 语言函数的定义与声明2.C 语言函数的参数传递3.C 语言函数的返回值4.C 语言函数的调用5.C 语言函数的实现举例正文：C 语言函数的实现C 语言是一种广泛应用的编程语言，其主要特点之一是支持函数，即一段完成特定任务的代码。
函数可以提高代码的可读性、模块化程度和复用性。
本篇文章将介绍C 语言函数的实现。
一、C 语言函数的定义与声明在C 语言中，函数是通过定义和声明来实现的。
定义是指在函数体内编写实现代码，而声明是指在需要调用该函数的地方告诉编译器函数的原型。
函数定义的基本格式如下：```c返回类型函数名(参数类型参数名) {// 函数体return 返回值;}```例如，定义一个计算两个整数之和的函数：```cint add(int a, int b) {return a + b;}```二、C 语言函数的参数传递C 语言函数的参数传递分为两种：值传递和指针传递。
1.值传递：将实参的值复制给形参。
这种方式适用于基本数据类型。
2.指针传递：将实参的地址传递给形参。
这种方式适用于数组和结构体等复合数据类型。
三、C 语言函数的返回值函数可以返回一个值，这个值被称为返回值。
返回值可以通过return 语句来实现。
return 语句的格式为：```creturn 返回值;```如果函数不需要返回值，可以使用void 作为返回类型。
四、C 语言函数的调用在C 语言中，可以通过函数名并跟上括号内的参数列表来调用函数。
调用函数时，实参的类型和数量必须与形参匹配。
例如，调用上面定义的add 函数：```cint sum = add(3, 4);```五、C 语言函数的实现举例下面是一个C 语言函数实现的完整示例，该示例演示了如何定义、声明和使用一个计算两个整数之和的函数：```c#include <stdio.h>// 函数声明int add(int a, int b);int main() {int num1 = 5;int num2 = 10;int sum = add(num1, num2);printf("The sum of %d and %d is %d", num1, num2, sum);return 0;}// 函数定义int add(int a, int b) {return a + b;}```通过以上介绍，我们可以了解到C 语言函数的基本概念和实现方法。
c staitc 函数声明与定义
C静态函数声明与定义1.概述C语言中的函数声明和定义是程序中非常重要的部分，它们用于定义函数的功能和参数类型，以及在其他地方使用这些函数。
在C语言中，还有一种称为静态函数的声明和定义方式，它与普通函数有所不同。
本文将介绍C静态函数声明与定义的相关知识。
2.静态函数的声明在C语言中，函数的声明和定义都可以使用关键字static来修饰。
静态函数的声明可以在函数前面添加static关键字，用于告诉编译器该函数只能在当前文件中使用，其他文件无法访问该函数。
静态函数的声明格式如下所示：```cstatic 返回值类型函数名(参数列表);```其中，static是关键字，返回值类型用于定义函数返回值的类型，函数名是函数的标识符，参数列表包括函数的参数类型和参数名。
3.静态函数的定义静态函数的定义与普通函数的定义类似，只是在函数的返回值类型前添加了static关键字。
静态函数的定义格式如下所示：```cstatic 返回值类型函数名(参数列表){// 函数体}```在函数名前面添加了static关键字，用于表示该函数只能在当前文件中使用，其他文件无法访问该函数。
函数体内部包括了函数的具体实现代码。
4.静态函数的作用静态函数的主要作用是限制函数的作用域，使其只能在当前文件中使用。
这样可以避免函数被其他文件中的函数或代码误用，增强程序的安全性和可维护性。
另外，静态函数还可以避免函数名重复引起的命名冲突，提高了程序的可读性和可靠性。
5.静态函数与普通函数的区别静态函数与普通函数的区别主要在于作用域和信息性。
普通函数具有外部信息性，可以在其他文件中使用；而静态函数具有内部信息性，只能在当前文件中使用。
另外，静态函数与普通函数的区别还在于函数名重复引起的命名冲突，静态函数可以避免这个问题，提高了程序的可维护性。
6.静态函数的注意事项在使用静态函数时，需要注意以下几点：(1) 静态函数只能在当前文件中使用，不能在其他文件中使用；(2) 静态函数的声明和定义只能在同一个文件中，不能分开在不同的文件中；(3) 静态函数的作用域仅限于当前文件，不能被其他文件的函数或代码所访问。
C语言函数参考手册
C语言函数参考手册一、概述C语言是一种通用的、面向过程的程序设计语言，广泛应用于系统编程和应用软件开发等领域。
在C语言中，函数是非常重要的组成部分，通过函数可以实现代码的模块化和重复使用。
本手册旨在为C语言开发者提供函数相关信息的参考，包括常用函数的用法、参数说明和返回值等。
二、函数的声明函数声明是指在使用函数之前，需要先声明函数的存在及函数的参数类型和返回值类型。
函数声明通常位于源文件的开头部分，以便在其他代码中使用。
1. 函数声明的一般格式如下：返回值类型函数名(参数列表);2. 示例：int max(int a, int b);void printHello();三、函数的定义函数定义是指实现函数的功能代码，并且包含函数的参数和返回值类型的明确说明。
函数定义通常位于源文件的主体部分。
1. 函数定义的一般格式如下：返回值类型函数名(参数列表) {函数体代码return 返回值;}2. 示例：int max(int a, int b) {if (a > b) {return a;} else {return b;}}void printHello() {printf("Hello, world!\n");}四、函数的参数函数的参数是指在函数的括号内声明的变量，用于接受调用函数时传递的值。
函数的参数可以有多个，也可以没有参数。
1. 参数的声明格式如下：参数类型参数名2. 示例：int add(int a, int b);void printName(char* name);五、函数的返回值函数的返回值是指函数执行完成后返回的结果。
返回值可以是任何数据类型，如整数、浮点数、字符等。
函数的返回值可以有多种情况，根据具体逻辑来确定。
1. 返回值的声明格式如下：返回值类型2. 示例：int max(int a, int b);double calculateAverage(int array[], int length);六、常用函数C语言提供了许多常用的函数库，通过这些函数可以实现各种功能。
c语言函数的实验总结
c语言函数的实验总结C语言函数的实验总结一、实验目的C语言函数是C语言编程中的一个重要概念，能够帮助程序员实现代码模块化、提高代码复用性和可读性。
通过本次实验，旨在掌握C语言函数的基本用法和调用方式，提高编程能力和逻辑思维能力。
二、实验过程本次实验主要涉及以下几个方面的知识和技能：1. 函数的定义和声明2. 函数的参数传递方式3. 函数的返回值4. 函数的递归调用在实验开始前，我们首先了解了函数的定义和声明的概念。
函数的定义是指函数体的实现，包括函数的形参、返回值和函数体的具体实现；函数的声明是指对函数的提前声明，告诉编译器该函数的存在和返回值类型。
接下来，我们根据实验要求分别编写了一些示例函数来巩固相关的知识。
在函数的参数传递方式方面，我们编写了一些传值调用、指针调用和引用调用的示例函数，以便深入理解C语言中参数的传递方式为值传递。
在函数的返回值方面，我们编写了一些返回值为基本类型和引用类型的示例函数，以便理解C语言中函数返回值的作用和类型。
在函数的递归调用方面，我们编写了一些递归求阶乘、递归求斐波那契数列的示例函数，以便掌握递归调用的原理和实现方式。
在实验过程中，我们针对每一个示例函数进行了编码，并通过编译器进行了测试和调试。
在测试过程中，我们特别注意了函数的输入参数和输出结果，确保程序的正确性和可靠性。
同时，我们还使用了一些调试技巧，如打断点、输出调试信息来帮助我们查找代码中的错误和问题。
三、实验结果通过本次实验，我们成功实现了所有示例函数，并通过了编译器的测试和调试。
我们发现C语言函数在编程中的作用非常重要，能够帮助我们实现代码的模块化和封装。
同时，通过函数的参数传递方式可以提高代码的复用性，通过函数的返回值可以获得函数的执行结果，避免了代码之间的耦合性。
另外，通过递归调用函数可以简化代码的实现和理解，但同时也需要注意递归的终止条件和递归的效率问题。
四、实验总结通过本次实验，我们总结出以下几个重要的收获和体会：1. 函数是C语言中的基本概念，是代码模块化和可读性的重要手段。
c语言函数的定义格式
C 语言函数的定义由函数声明和函数体两部分组成。
通常情况下，函数定义的格式如下：```c返回类型函数名(参数类型参数1, 参数类型参数2, ...) {/* 函数体*/}```其中：- 返回类型：指明函数的返回值类型，如`int`、`float`、`double` 等。
- 函数名：为函数起一个名称，用于在程序中调用该函数。
- 参数类型和参数名：指明函数的参数类型和参数名，多个参数之间用逗号分隔。
参数名在函数体内可以用来表示该参数的值。
- 函数体：由一些语句组成，实现函数的具体功能。
下面是一个示例：```c#include <stdio.h>int add(int x, int y) {return x + y;}int main() {int a = 5, b = 3, sum;sum = add(a, b);printf("%d + %d = %d\n", a, b, sum);return 0;}```在上面的示例中，函数`add` 用于计算两个整数的和。
函数有两个参数，都是`int` 类型。
函数体中使用了`return` 语句返回计算结果。
`main` 函数调用了`add` 函数，并输出了计算结果。
函数声明和函数定义不同。
函数声明是指函数的原型声明，用于告诉编译器函数的返回类型和参数类型。
函数声明不需要函数体，一般放在程序的头部。
示例代码中没有给出函数声明，因为`add` 函数在`main` 函数前面被定义了，所以编译器可以自动识别出函数的原型。
但是，为了保证代码的可读性和可维护性，应该在程序开头给出所有函数的声明。
函数声明的格式如下：```c返回类型函数名(参数类型参数1, 参数类型参数2, ...);```下面是一个包含函数声明和函数定义的完整示例：```c#include <stdio.h>int add(int, int);int main() {int a = 5, b = 3, sum;sum = add(a, b);printf("%d + %d = %d\n", a, b, sum);return 0;}int add(int x, int y) {return x + y;}```在这个示例中，`add` 函数在`main` 函数前被声明，声明了函数的返回类型和参数类型，但没有给出参数名。
C语言—函数（function）函数定义、函数声明、函数调用！
C语⾔—函数（function）函数定义、函数声明、函数调⽤！转载：函数作⽤：提⾼代码复⽤率，提⾼程序模块组织性。
分类：系统库函数，标准C库 ·libc1)：必须要引⼊头⽂件#include函数声明2)：根据函数库函数原型，调⽤函数⽤户⾃定义函数bubble_sort() , ruprint(),除了需要提供函数原型之外，还需要提供函数实现。
使⽤函数：函数定义、函数声明、函数调⽤函数定义：函数定义必须包含“函数原型”和函数体。
函数原型：返回值类型 + 函数名 + 形参列表形参列表：形式参数列表，⼀定包含类型名、形参名。
//加法函数int add(int a, int b)函数体：⼀对{}包裹函数实现int add(int a , nit b){ int ret = a + b; return 0;}函数调⽤：包含函数名(实参列表)实参：(实际参数)在调⽤时，传参必须严格按照形参填充，(参数个数，类型顺序)实现在调⽤时，没有类型指述符。
int m = 20;int n = 34;inr ret = add(m, n);函数声明：包含函数原型(返回值类型 + 函数名 + 形参列表)int add(int a, int b);要求在函数调⽤之前，编译器必须是过函数定义，否则要求函数声明。
如果没有函数声明，编译器默认“隐式声明”，编译器认为所有的函数，返回值都是int 可以根据函数调⽤，推断函数原则。
#include内部，包含函数声明。
exit 函数return 关键字，返回值当前函数调⽤，将返回值返回调⽤者(在底层，会调⽤exit() 函数)。
exit () 函数 : 退出当前程序函数声明：//int test(int a, char ch);int test(int, char); //函数声明的简化写，声明时形参可以省略//函数调⽤int main(void){ int ret = test(10, 'a'); //test函数调⽤结束，return 给 main printf("test函数返回：ret = %d\n", ret); //return 0; //返回给调⽤者(启动例程) exit(0); //结束程序}//函数定义int test(int a, char ch);{ printf("a = %d\n", a); printf("ch = %d\n", ch); exit(97); //使⽤#include(stdib.h)}多⽂件编程解决⽅案—右键—添加—新建项⽬多⽂件—右键—设为启动项⽬头⽂件守卫：为了防⽌头⽂件被重复包含1)：#pragma Once是VS⾃动⽣成的，只应⽤于windows系统2)：#ifndef HEAD_H#define HEAD_H头⽂件内容：#include//宏定义：#define PI 3.14函数声明：类型定义：#endif#ifndef _HEAD_H_ //标准引⼊头⽂件#define _HEAD_H_//include 头⽂件#include#include#include#include#include//函数声明int add(int a, int b);int sub(int a, int b);//宏定义#define PI 3.14类型定义：#endif< > 包裹的是系统库头⽂件“ ” 包裹的是，⽤户⾃定义头⽂件// main 函数所在的 C · 头⽂件#include " head.h";▼往期精彩回顾▼C语⾔—创建function并使⽤初始化arrC语⾔—指针(pointer)and 内存单元使⽤！C语⾔——数组的定义和初始化。
C语言函数的定义与使用
C语言函数的定义与使用C语言是一种通用的高级计算机编程语言，广泛应用于系统软件、嵌入式系统和游戏开发等领域。
在C语言中，函数是一种非常重要的代码块，用于实现特定的功能。
函数的定义和使用是C语言程序的基本组成部分之一、本文将详细介绍C语言函数的定义与使用。
一、函数定义函数的定义包括函数头和函数体两部分。
函数头包括函数的返回类型、函数名和参数列表，函数体则包含了具体的代码实现。
函数的定义格式如下：返回类型函数名（参数列表）//函数体代码其中，返回类型指定了函数执行完毕后的返回值类型，可以是整型、浮点型、字符型、指针等。
函数名是用来唯一标识函数的名称，参数列表指定了函数接收的参数类型和参数个数。
下面是一个简单的例子，展示了一个求两个整数和的函数的定义：int sum(int a, int b)int result = a + b;return result;上述例子中，函数名为sum，返回类型为int，参数列表为两个整型变量a和b。
在函数体中，将a和b的和赋值给result，并通过return语句将result作为结果返回。
二、函数使用使用函数可以实现代码的复用，提高程序的可读性和可维护性。
在程序中调用函数时，可以通过函数名和实际参数来使用函数。
函数调用的一般格式如下：函数名（实际参数列表）在调用函数时，函数名后面的括号内可以填入实际参数列表。
实际参数是调用函数时传递给函数的具体数值。
下面是一个例子，展示了如何调用上述求和函数：#include <stdio.h>int sum(int a, int b); // 函数声明int mainint x = 1, y = 2;int result = sum(x, y); // 函数调用printf("The sum of %d and %d is %d\n", x, y, result);return 0;上述例子中，main函数中的sum(x, y)调用了上文定义的sum函数。
C语言自定义函数的方法
C语言自定义函数的方法C语言是一种面向过程的编程语言，它提供了定义和调用自定义函数的方法，通过自定义函数，我们可以将一段代码逻辑封装在一个函数中，从而提高代码的可读性、可维护性和重用性。
下面是关于C语言自定义函数的方法的详细介绍。
在C语言中定义自定义函数的方法如下：1.函数声明和函数定义在使用函数之前，需要进行函数声明或函数定义。
函数声明是告诉编译器函数的存在，函数定义是实现函数的具体内容。
函数声明的语法为：```返回类型函数名(参数列表);```其中，返回类型是指函数返回的数据类型，函数名是函数的标识符，参数列表是函数的参数及其数据类型。
函数定义的语法为：```返回类型函数名(参数列表)函数体```其中，函数体是具体实现函数功能的代码。
2.函数的返回值函数可以有返回值，也可以没有返回值。
返回值是函数执行完毕后返回给调用者的结果。
如果函数没有返回值，返回类型应声明为`void`，例如：```void function_name(参数列表)函数体```如果函数有返回值，返回类型可以是任意基本数据类型，例如：```int function_name(参数列表)函数体return 返回值;```函数体内的代码通过`return`语句返回结果。
3.函数的参数函数可以有参数，参数用于向函数传递数据。
参数可以是基本数据类型，也可以是数组、指针、结构体等复杂数据类型。
函数的参数列表中可以包含一个或多个参数，参数之间用逗号隔开。
例如：```void function_name(int arg1, float arg2)函数体```在函数体内，可以使用参数名称来引用参数的值。
4.函数的调用在程序中调用函数时，可以使用函数名后跟随参数列表的方式来调用函数。
例如：```function_name(arg1, arg2);```5.函数的递归调用C语言支持函数的递归调用，即在函数体内部调用函数本身。
递归函数需要满足终止条件，否则会导致无限递归。
c语言函数的定义和声明
c语言函数的定义和声明C语言函数的定义和声明在C语言中，函数是一种可重复使用的代码块，用于完成特定的任务。
函数的定义和声明是使用函数的关键步骤，本文将详细介绍这两个概念及其使用方法。
一、函数的定义函数的定义是指为实现特定功能而编写的函数代码。
在函数的定义中，需要包括函数的名称、返回类型、参数列表和函数体。
1. 函数的名称函数的名称是用来唯一标识函数的符号，通常采用驼峰命名法或下划线命名法。
函数的名称应该具有描述性，能够清晰地表达函数的功能。
2. 返回类型返回类型指的是函数执行完毕后的返回值的类型。
C语言中常用的返回类型有整型、浮点型、字符型、指针型等。
在函数定义中，需要使用关键字来指定返回类型，如int、float、char等。
3. 参数列表参数列表指的是函数接收的输入值，也称为函数的形参。
参数列表中需要指定参数的类型和名称。
如果函数不需要接收任何输入值，可以将参数列表留空或使用void关键字表示。
4. 函数体函数体是函数的具体实现代码，包括了一系列的语句和逻辑。
函数体中的代码会在函数被调用时执行。
函数体应该包含必要的变量定义、循环结构、条件判断等，以实现函数的功能。
二、函数的声明函数的声明是指在使用函数之前，需要提前声明函数的存在和函数的原型。
函数的声明主要包括函数的名称、返回类型和参数列表。
函数的声明可以放在函数的定义之前，也可以放在其他函数的内部。
在声明函数时，只需要提供函数的名称、返回类型和参数列表，不需要提供函数体。
函数的声明可以放在头文件中，以便其他源文件可以引用该函数。
在需要使用该函数的源文件中，只需包含头文件即可。
三、函数的定义和声明的关系函数的定义和声明是相辅相成的，函数的声明使得我们可以在不知道函数具体实现的情况下使用函数。
而函数的定义则提供了函数的具体实现，使得函数能够被正确执行。
在使用函数之前，我们需要先进行函数的声明，以便编译器能够知道函数的存在和函数的原型。
然后再在合适的位置进行函数的定义，即提供函数体和具体的实现代码。
C语言函数大全
C语言函数大全C语言是一种通用的高级语言，它广泛应用于系统软件、应用软件、驱动程序、网络通信、嵌入式系统等领域。
在C语言中，函数是非常重要的一部分，它可以帮助我们组织代码，提高代码的重用性和可维护性。
本文将介绍C语言中常用的函数，帮助大家更好地理解和应用C语言。
一、基本概念。
在C语言中，函数是一段完成特定任务的程序代码，它可以接受参数并返回值。
函数的基本结构包括函数名、参数列表、返回类型、函数体和返回语句。
函数的定义通常包括函数头和函数体两部分，函数头用于声明函数的名称、参数列表和返回类型，函数体包括具体的代码实现。
二、函数的声明与定义。
在C语言中，函数的声明和定义是分开的。
函数的声明用于告诉编译器函数的存在，函数的定义则包括函数的具体实现。
函数的声明通常包括函数名、参数列表和返回类型，函数的定义则包括函数名、参数列表、返回类型和函数体。
函数的声明和定义可以分开写在不同的文件中，通过头文件的方式进行引用。
三、函数的参数传递。
在C语言中，函数的参数传递可以通过值传递和引用传递两种方式。
值传递是指将实际参数的值复制一份传递给形式参数，函数内部对形式参数的修改不会影响实际参数。
引用传递是指将实际参数的地址传递给形式参数，函数内部对形式参数的修改会影响实际参数。
C语言中默认采用值传递的方式，如果需要使用引用传递，可以通过指针或引用的方式实现。
四、函数的返回值。
在C语言中，函数可以有返回值，也可以没有返回值。
有返回值的函数在定义时需要指定返回类型，函数体中需要使用return语句返回值。
没有返回值的函数通常使用void作为返回类型，函数体中可以省略return语句。
在调用函数时，可以通过赋值或者直接使用返回值的方式获取函数的返回结果。
五、常用的标准库函数。
C语言标准库提供了丰富的函数库，包括数学函数、字符串函数、输入输出函数等。
常用的标准库函数有printf、scanf、malloc、free、strcpy、strcat、strlen、sin、cos等。
c语言static函数声明和定义
c语言static函数声明和定义1. 静态函数是一种在C语言中用于限制函数的作用域的修饰符。
通过将函数声明为静态，我们可以将其限定在当前文件内部，使其对外部文件不可见。
这在大型项目中非常有用，可以避免命名冲突和函数被错误调用的情况。
2. 在C语言中，我们可以将函数声明为静态函数，方法是在函数定义之前加上关键字"static"。
这样的声明将告诉编译器该函数只能在当前文件中使用，无法被其他文件调用。
静态函数的声明通常放在源文件的头部，以便在需要时进行调用。
3. 静态函数的定义与普通函数类似，只是在函数名前添加了关键字"static"。
静态函数可以实现与普通函数相同的功能，但其作用范围仅限于当前文件。
这意味着其他文件无法通过函数名来调用静态函数，从而确保了函数的独立性和安全性。
4. 静态函数的另一个特点是它们的生命周期与程序的整个运行周期相同，即它们在程序启动时创建，直到程序终止才销毁。
这与普通函数不同，普通函数只在被调用时才会被创建，并在调用结束后自动销毁。
5. 静态函数的另一个特性是它们无法被其他文件所访问。
这是由于静态函数的作用域仅限于当前文件。
通过将函数声明为静态，可以有效地隐藏实现细节，提高了程序的安全性和可维护性。
6. 静态函数还可以用于实现私有函数。
私有函数是指只在当前文件内部使用的函数，不需要对外公开。
通过将私有函数声明为静态，可以防止其他文件误调用该函数，从而减少了程序错误的可能性。
总结：静态函数是一种用于限制函数作用范围的修饰符，通过将函数声明为静态，可以将其限定在当前文件内部，使其对外部文件不可见。
静态函数的声明和定义方式与普通函数类似，只是在函数名前添加了关键字"static"。
静态函数的作用范围仅限于当前文件，且无法被其他文件所访问，从而提高了程序的安全性和可维护性。
静态函数还可以用于实现私有函数，以减少程序错误的可能性。
c语言函数定义的语法
c语言函数定义的语法C语言函数定义的语法是学习C语言编程的基础，在编写C程序时，函数的正确定义和使用是非常重要的。
本文将详细介绍C语言函数定义的语法，包括函数的声明、参数、返回值和函数体的组成。
一、函数的声明在C语言中，函数的声明既可以放在主函数之前，也可以放在主函数之后。
函数的声明包括函数的返回类型、函数名和参数列表。
例如：int sum(int a, int b);上述代码中，int表示函数的返回类型是整数，sum是函数的名字，而int a和int b是函数的参数列表，表示函数接受两个整型参数。
二、函数的定义函数的定义包括函数的声明和函数体。
函数体由一对花括号{}包围，花括号中是函数的具体实现代码。
例如：int sum(int a, int b){int result = a + b;return result;}上述代码中，函数的定义与函数的声明相对应。
函数体中的代码是实现函数功能的具体代码，使用了两个参数a和b，计算它们的和并将结果返回。
三、参数传递C语言函数可以接受参数，参数可以是基本数据类型，也可以是数组或指针。
参数通过参数列表的形式传递给函数。
例如：void printName(char name[]){printf("My name is %s\n", name);}上述代码中，printName函数接受一个字符数组作为参数，然后将其打印出来。
四、返回值C语言函数可以有返回值，返回值可以是基本数据类型，也可以是数组或指针。
函数的返回值通过return语句返回。
例如：int square(int num){return num * num;}上述代码中，square函数接受一个整数作为参数，计算该整数的平方并返回。
五、函数的调用在C语言程序中，函数的调用是通过函数名和实参列表来完成的。
例如：int main(){int a = 2;int b = 3;int result = sum(a, b);printf("The sum of %d and %d is %d\n", a, b, result);return 0;}上述代码中，main函数是程序的入口函数，首先定义了两个整数变量a和b，然后调用了sum函数计算它们的和，并将结果打印出来。
c语言中function函数的用法
在C语言中，函数（function）是一个可重用的代码块，它可以被程序中的其他部分调用。
函数的使用有助于将程序划分为更小、更易于理解和维护的模块。
下面是一些关于C语言中函数的基本用法：1. **定义函数**：在C语言中，函数定义通常位于main()函数之前，这样它就可以在main()函数内部被调用。
函数定义包括函数名、参数列表和函数体。
```c返回类型函数名(参数列表) {// 函数体}```例如，下面是一个计算两个整数之和的函数的定义：```cint sum(int a, int b) {return a + b;}```2. **调用函数**：在main()函数或其他函数中，可以通过函数名和传递给函数的参数来调用自定义的函数。
```cint main() {int result = sum(5, 7); // 调用sum函数，并传递5和7作为参数printf("The sum is: %d", result); // 打印结果return 0;}```3. **函数参数**：函数参数是传递给函数的输入值。
这些参数可以是任何数据类型，包括整数、浮点数、字符、字符串等。
在函数定义中，参数列表包括参数类型和参数名。
参数类型指定参数的数据类型，参数名是用来引用参数的标识符。
在调用函数时，传递给函数的实际参数（实参）将替代函数定义中的形参。
4. **返回值**：函数可以返回一个值。
返回类型是定义函数时指定的数据类型，它必须与实际返回的值的类型相匹配。
可以使用return 语句来指定函数的返回值。
如果没有return语句，或者如果返回类型是void，则函数返回main()函数的值（通常是0）。
5. **函数声明与定义的区别**：有时，你会看到函数的声明（prototype）和定义（implementation）分开。
函数声明包括函数名、参数列表和返回类型，但没有函数体。
它告诉编译器有关函数的信息，以便其他代码可以使用该函数。
C语言编程函数
C语言编程函数函数在C语言编程中扮演着非常重要的角色，它们是由一组预定义的代码块组成，可重复使用以完成特定的任务。
C语言中的函数具有广泛的用途，能够简化程序的设计和组织，并提高代码的可维护性。
本文将介绍C语言中的编程函数及其常见用法。
一、函数的定义和声明函数的定义包括函数的名称、参数和返回值类型以及函数体的代码。
在程序中调用函数时，需要先声明函数，以便编译器能够识别和解析函数的调用。
下面是一个简单的函数定义和声明的示例：```// 函数声明int sum(int a, int b);// 函数定义int sum(int a, int b) {return a + b;}```在上面的示例中，函数名为 "sum"，参数为两个整型变量 "a" 和 "b"，返回值类型为整型。
函数声明告诉编译器有一个名为 "sum" 的函数存在，函数定义则提供了函数的具体实现。
二、函数的调用要调用函数，只需使用函数名以及传递给函数的参数。
调用函数时，可以将函数的返回值赋给一个变量，或直接在表达式中使用函数的返回值。
下面是一个函数调用的示例：```int result = sum(3, 5); // 调用 sum 函数，并将返回值赋给 result 变量printf("%d", result); // 打印 result 的值```在上面的示例中，我们调用了之前定义的 "sum" 函数，并将其返回的结果赋给 "result" 变量。
然后，使用 "printf" 函数打印 "result" 的值。
三、函数的返回值函数可以有返回值，也可以没有返回值。
如果函数没有返回值，则返回类型为 "void"。
如果函数有返回值，则使用合适的数据类型来指定返回值的类型。
C语言中函数的声明定义及使用的入门教程
C语言中函数的声明定义及使用的入门教程函数是在程序中完成一些任务的独立模块。
通过使用函数，可以将程序分解成更小的、可管理的部分，使代码具备可读性和可维护性。
在C语言中，函数的声明、定义和使用分为以下几个步骤：1.函数的声明在C语言中，函数的声明是指告诉编译器有一个函数存在，并描述了它的名称、参数和返回类型。
函数声明的语法如下：```c返回类型函数名(参数列表);```其中，返回类型表示函数执行完成后的返回值类型，函数名表示函数的名称，参数列表表示函数的参数类型和名称。
例如，下面是一个函数声明的例子：```cint add(int a, int b);```这个声明表示存在一个名为`add`的函数，它接受两个整型参数`a`和`b`，并返回一个整型值。
2.函数的定义函数的定义是指实现函数中具体的操作。
C语言中的函数定义包括函数头和函数体。
函数头包括了函数的名称、参数列表和返回类型，而函数体包括了函数的具体操作。
函数定义的语法如下：```c返回类型函数名(参数列表)//函数体//具体操作代码```使用上面的例子，下面是一个`add`函数的定义：```cint add(int a, int b)int result = a + b;return result;```这个定义表示`add`函数接受两个整型参数`a`和`b`，并返回它们的和。
3.函数的使用一旦函数声明和定义完成，就可以在程序中使用函数了。
函数的使用可以分为函数调用和函数返回值的处理两个方面。
函数调用的语法如下：```c函数名(参数列表);```例如，使用上面的例子，可以这样调用`add`函数：```cint sum = add(3, 4);```这个调用会返回`3`和`4`的和，并将结果赋值给变量`sum`。
在使用函数返回值时，需要注意函数的返回类型和返回值的类型必须一致。
如果函数没有返回值，返回类型应该设置为`void`。
例如，下面是一个没有返回值的函数定义和使用：```cvoid printHellprintf("Hello, world!\n");printHello(; // 输出：Hello, world!```在函数的使用过程中，还需要注意函数的作用域。
C语言函数的定义与调用
C语言函数的定义与调用函数是C语言中非常重要的概念，它可以让我们更加方便地组织和管理代码。
在本文中，我们将讨论C语言中函数的定义和调用方法。
一、函数的定义在C语言中，我们可以通过定义函数来实现代码的模块化和代码重用。
函数的定义包括函数类型、函数名、参数列表和函数体。
下面是一个示例：```c// 定义一个计算两个整数之和的函数int addition(int a, int b) {int sum = a + b;return sum;}```在上面的示例中，我们定义了一个名为"addition"的函数，它有两个参数a和b，返回类型为int。
函数体中的代码实现了两个整数的相加，并将结果存储在sum变量中。
最后使用return语句将sum返回。
二、函数的调用函数定义完成后，我们可以通过调用函数来执行其中的代码。
函数的调用需要写上函数名和传递给函数的实际参数。
下面是一个示例：```c// 调用addition函数计算两个整数之和int result = addition(3, 4);```在上面的示例中，我们通过传递参数3和4调用了名为"addition"的函数，并将返回的结果赋值给result变量。
三、函数的声明在某些情况下，我们可能需要在调用函数之前进行函数的声明。
函数的声明告诉编译器函数的存在和函数的返回类型，参数等信息，以便编译器能够正确解析函数调用。
下面是一个示例：```c// 声明addition函数int addition(int a, int b);// 调用addition函数计算两个整数之和int result = addition(3, 4);```在上面的示例中，在调用addition函数之前，我们先进行了函数的声明。
声明包括函数的返回类型、函数名和参数列表。
四、函数的返回值函数可以有返回值，也可以没有返回值。
在函数定义时，我们需要在函数名前面写上返回类型。
C语言函数缺省参数详情
C语⾔函数缺省参数详情⽬录⼀.函数简介1.函数声明2.函数定义3.函数调⽤4.函数形参和实参⼆.函数缺省参数1.函数全缺省参数2.函数半缺省参数三.注意事项⼀.函数简介1.函数声明函数声明只是⼀个空壳，不会有具体的函数实现，⽽定义要实现函数的实现，例如：int sub(int x,int y); //只需要声明即可，不需要实现这个函数的功能2.函数定义函数的定义需要实现这个函数的功能，例如：int sub(int x,int y) ////需要实现这个函数的功能{return (x-y);}3.函数调⽤函数调⽤之前必须声明或者定义，否则会报错：找不到标识符,这也是为什么 hello world 中调⽤ printf 函数必须要包含 stdio.h 头⽂件的原因；4.函数形参和实参形参:函数被定义或者声明时，参数列表都是形参；//函数被声明时，参数列表中的x,y都是形参int sub(int x,int y);//函数被定义时，参数列表中的x,y都是形参int sub(int x,int y){return (x-y);}实参:函数被调⽤时，传递的参数列表都是实参；int main(void){//sub函数被调⽤，传递的参数1，2都是实参sub(1,2);return 0;}⼆.函数缺省参数缺省参数：在声明或者定义函数时为函数的参数指定⼀个默认值。
在调⽤函数时，若没有指定实参则使⽤默认值，否则使⽤指定实参；其中缺省参数分为两类:全缺省参数和半缺省参数;1.函数全缺省参数函数全缺省参数：函数在定义或者声明时，所有的形参都默认值，举个例⼦：/************************************************************************///@Author:猿说编程//@Blog(个⼈博客地址): //@File:C语⾔函数缺省参数//@Time:2021/06/23 08:00//@Motto:不积跬步⽆以⾄千⾥，不积⼩流⽆以成江海，程序⼈⽣的精彩需要坚持不懈地积累！/************************************************************************/#include <stdio.h>//x,y为函数的形参，如果函数被调⽤时，没有设置x和y值，x值默认为100，y值默认为5int sub(int x=100,int y=5){return (x-y);}int main(void){int a=20;int b=10;//变量a、b为sub函数的实参printf("sub函数计算结果 = %d\n",sub(a, b));//注意：我们并没有为sub函数设置实参，此时默认x=100 y=5printf("sub函数计算结果 = %d\n",sub());return 0;}/*输出：sub函数计算结果 = 10sub函数计算结果 = 95*/2.函数半缺省参数函数半缺省参数：函数在定义或者声明时，只有⼀部分形参有默认值，举个例⼦：/************************************************************************///@Author:猿说编程//@Blog(个⼈博客地址): //@File:C语⾔函数缺省参数//@Time:2021/06/23 08:00//@Motto:不积跬步⽆以⾄千⾥，不积⼩流⽆以成江海，程序⼈⽣的精彩需要坚持不懈地积累！/************************************************************************/#include <stdio.h>//x,y为函数的形参，如果函数被调⽤时，没有设置y值，y值默认为5int sub(int x,int y=5){return (x-y);}int main(void){int a=20;int b=10;//变量a、b为sub函数的实参printf("sub函数计算结果 = %d\n",sub(a, b));//注意：我们并没有为sub函数第⼆个参数设置实参，此时默认y=5printf("sub函数计算结果 = %d\n",sub(a));return 0;}/*输出：sub函数计算结果 = 10sub函数计算结果 = 15*/三.注意事项1.参数给缺省值只能从右往左给定(即：有默认值的形参必须放在最后)，例如：void Funtest（int a ,int b;int c=30）*可以void Funtest（int a =10,int b;int c）*不⾏void Funtest（int a =10,int b;int c=30）*不⾏2.缺省值必须是常量或者全局变量到此这篇关于C语⾔函数缺省参数详情的⽂章就介绍到这了,更多相关C语⾔函数缺省参数内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。
C语言中函数的声明、定义及使用的入门教程
C语⾔中函数的声明、定义及使⽤的⼊门教程对函数的“定义”和“声明”不是⼀回事。
函数的定义是指对函数功能的确⽴，包括指定函数名，函数值类型、形参及其类型以及函数体等，它是⼀个完整的、独⽴的函数单位。
⽽函数的声明的作⽤则是把函数的名字，函数类型以及形参的类型、个数和顺序通知编译系统，以便在调⽤该函数时进⾏对照检查（例如，函数名是否正确，实参与形参的类型和个数是否⼀致），它不包括函数体。
——谭浩强，《C程序设计》（第四版），清华⼤学出版社，2010年6⽉，p182这段论述包含了许多概念性错误，这些概念错误在许多C语⾔书中都同样普遍存在。
为了说明这些错误，⾸先来回顾⼀下C语⾔演变和发展的⼀些情况。
最早，C语⾔的代码可以这样写：main(){printf("hello,world!\n");}注意，这段代码对标识符printf没有进⾏任何说明。
这是因为printf()函数的返回值为int类型。
当时的C语⾔规定，对于没有任何说明的函数名，编译器会默认为返回值为int类型，因此对这样的函数名可以不做任何说明。
那个时期的C语⾔，很多情况下int 可以不写。
例如main()函数返回值的类型为int就可以不写。
但是需要特别说明的是，这种“省劲”的写法已经过时，从C90标准起，这种写法就步⼊了被逐步抛弃的过程（尽管当时还没有完全⽴即废⽌）。
C99废除了隐式函数声明法则（remove implicit function declaration），另外，省略main()前⾯的int也已经不再容许了。
在C语⾔早期，尽管有时不需要对函数名进⾏说明，但有些情况下对函数名进⾏说明还是必须的，⽐如：double sqrt();int main(){printf("%f\n" , sqrt(9.) );}这是因为函数sqrt()返回值的类型不是int类型⽽是double类型，编译器编译时需要知道sqrt(9.)这个表达式的类型。
c语言 函数声明
c语言函数声明C语言函数声明函数是C语言中最为重要的概念之一，它是一组执行特定任务的语句集合。
在C语言中，函数必须先进行声明才能被使用。
本文将详细介绍C语言中函数声明的相关知识。
一、函数声明的定义函数声明是指在调用函数之前必须先告诉编译器该函数的名称、参数类型和返回值类型等信息。
通常情况下，函数声明应该放在程序文件头部或单独的头文件中。
二、函数声明的语法格式一个完整的函数声明应该包括以下几个部分：返回值类型函数名(参数列表);其中，返回值类型指定了该函数返回值的数据类型；函数名则是该函数在程序中被调用时所使用的名称；而参数列表则指定了该函数所需要接收的参数及其数据类型。
三、实例分析1. 不带参数不带返回值类型void printHello();上述代码定义了一个名为printHello() 的空参空返回值类型的函数。
2. 带参数不带返回值类型void printNum(int num);上述代码定义了一个名为printNum() 的带有一个整型参数num且无返回值类型的函数。
3. 不带参数带有返回值类型int getSum();上述代码定义了一个名为getSum() 的空参且有一个整型返回值类型的函数。
4. 带参数带返回值类型int add(int num1, int num2);上述代码定义了一个名为add() 的带有两个整型参数num1和num2且有一个整型返回值类型的函数。
四、注意事项1. 函数声明必须与函数定义的返回值类型、函数名及参数列表完全一致，否则会导致编译错误。
2. 在函数声明中，可以省略参数名，只需要指定参数类型即可。
3. 在多文件程序中，可以将所有的函数声明放在单独的头文件中，并通过#include指令包含到主程序文件中。
五、总结本文介绍了C语言中函数声明的相关知识。
通过学习本文，我们可以清楚地了解什么是函数声明、函数声明的语法格式及注意事项等内容。
同时，在实际编程过程中，我们应该根据具体需求选择不同类型的函数声明，并严格遵守规范进行编写。
c语言 函数声明 函数定义 函数原型
C语言函数声明、函数定义、函数原型一、函数声明1.1 定义：函数声明是指在程序中预先告知编译器函数的存在及其参数和返回值的类型，以便在函数定义之前可以在其他函数中调用该函数。
函数声明一般包括函数的返回类型、函数名和参数列表，但不包括函数体。
1.2 格式：函数声明的格式为：返回类型函数名(参数列表);1.3 示例：```cint add(int a, int b); // 声明add函数，参数为两个整数，返回值为整数```二、函数定义2.1 定义：函数定义是指实现函数功能的具体代码所在，可以包括函数的返回值、参数列表和函数体。
2.2 格式：函数定义的格式为：返回类型函数名(参数列表) { 函数体 } 2.3 示例：```cint add(int a, int b) { // add函数的定义return a + b; // 返回a和b的和}```三、函数原型3.1 定义：函数原型是函数的声明，包括函数名、参数列表和返回值类型的列表。
函数原型的作用是让编译器知道函数的名称、参数和返回类型，以便在程序中调用该函数。
3.2 作用：函数原型的作用在于可以提前告诉编译器该函数的存在，而不必等到函数定义的地方才能开始调用该函数。
3.3 示例：```cint add(int a, int b); // 函数原型，用于提前告知编译器add函数的存在```四、总结在C语言中，函数声明、函数定义和函数原型是程序中常见的概念。
函数声明用于在程序中提前告知编译器函数的存在及其参数和返回值的类型，函数定义用于实现函数的具体功能，函数原型则用于提前告知编译器该函数的存在。
合理使用函数声明、函数定义和函数原型，可以使程序结构更加清晰，并且方便程序的调用和维护。
C语言是一种广泛应用于系统软件和应用软件开发的编程语言，其灵活性和高效性使得它成为了编程领域中的重要工具。
在C语言中，函数声明、函数定义和函数原型是程序设计中不可或缺的部分，它们为程序的模块化设计和代码的复用提供了重要支持。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
失而保留原值，即其占用的存储单元不释放，在下一次函数调用时，该 变量已有值，就是上一次函数调用结束时的值。 静态局部变量在静态存储区分配存储单元，在程序的整个运行期间都不 释放。静态局部变量是在编译时赋初值的，即只赋初值一次。 在 SDT 编译器中，建议对静态局部变量赋初值，否则该静态局部变量的 初值为不确定值。在其他编译器中，未初始化的静态局部变量的初值可 能为零，这由具体的编译器所决定，使用前最好测试一下。 寄存器变量 register 带 register 修饰符的变量暗示（仅仅是暗示而不是命令）编译程序本 变量将被频繁使用，如果可能的话，应将其保留在 CPU 的寄存器中，以 加快其存取速度。 对于现有的大多数编译程序，最好不要使用 register 修饰符。因为它 是对早期低效的 C 编译程序的一个很有价值的补充。随着编译程序技术 的进步，在决定哪些变量应当被存到寄存器中时，现在的 C 编译程序能 比程序员做出更好的决定。 全局变量 在函数之外定义的变量称为外部变量，外部变量是全局变量，它可以为 本文件中其他函数所共用。全局变量都是静态存储方式，都是在编译时 分配内存，但是作用范围有所不同。 静态外部变量 static 静态外部变量只能在本文件中使用。所以静态外部变量应该在当前源文 件中声明和定义。
者）。 一个良好的编程习惯是在头文件中声明函数的原型。这可方便编译程序 查错。定义函数时，缺省的函数类型是外部函数。如：void fun2(void); 和 extern void fun2(void); 其函数类型是等价的，但前一个是定义函 数，后一个是声明函数。 小结 编写程序，尤其是大型程序时，建议采用上文所述的方法对不同的变量、 函数进行必要的声明、定义。做好这些细节上的事务，可以为您的编程、 调试、移植等带来很大的方便。
下例声明了一个变量和一个结构，定义了两个变量，其中一个定义带初 始化： extern int decl1; // this is a declaration
struct decl2
{
int member;
};
// this just declares the type – no variable
mentioned
void MasterFunction(void) { „ rc = stat_func( ); „ }
static int stat_func(void) {
„ return rc; }
外部函数 对于可在当前源文件以外使用的函数，应该在一个头文件中声明。其他 源文件可通过包含这个头文件或进行声明来使用这些函数（推荐用前 者）。 一个良好的编程习惯是在头文件中声明函数的原型。这可方便编译程序 查错。定义函数时，缺省的函数类型是外部函数。如：void fun2(void); 和 extern void fun2(void); 其函数类型是等价的，但前一个是定义函
void MasterFunction(void) { „ rc = stat_func( ); „ }
static int stat_func(void) {
„ return rc; }
外部函数 对于可在当前源文件以外使用的函数，应该在一个头文件中声明。其他 源文件可通过包含这个头文件或进行声明来使用这些函数（推荐用前
件中定义，在头文件中声明。
内部函数
只在当前源文件中使用的函数应该说明为内部函数。内部函数应该在当
前源文件中声明和定义。若内部函数在头文件中声明，其他源文件通过
包含这个头文件也可使用这个函数，但这样就失去了其做为内部函数的
意义。 优点：使用内部函数，可以使函数只局限于所在文件。这避免了与其他 源文件中可能出现的同名函数发生冲突。 例： File： function1.c #include “function1.h” static int stat_func(void);
包含这个头文件也可使用这个函数，但这样就失去了其做为内部函数的
意义。
优点：使用内部函数，可以使函数只局限于所在文件。这避免了与其他
源文件中可能出现的同名函数发生冲突。
例：
File： function1.c #include “function1.h” static int stat_func(void);
struct decl2
{
int member;
};
// this just declares the type – no variable
mentioned
int
def1 = 8; // this is a definition
int
def2; // this is a definition
函数
内部函数的声明和定义多在当前源文件中完成；而外部函数通常在源文
C 语言函数定义和函数声明
变量 在将变量前，先解释一下声明和定义这两个概念。声明一个变量意味着 向编译器描述变量的类型，但并不为变量分配存储空间。定义一个变量 意味着在声明变量的同时还要为变量分配存储空间。在定义一个变量的 同时还可以对变量进行初始化。 局部变量通常只定义不声明，而全局变量多在源文件中定义，在头文件 中声明。 局部变量 在一个函数的内部定义的变量是内部变量，它只在本函数范围内有效。 自动变量 auto 函数中的局部变量，其缺省格式是自动变量类型。例如，在函数体中 int b, c=3; 和 auto int b, c=3; 是等价的。 自动变量是动态分配存储空间的，函数结束后就释放。自动变量如不赋 初值，则它的值是一个不确定的值。 静态局部变量 static 静态局部变量是指在函数体内声明和定义的局部变量，它仅供本函数使 用，即其他函数不能调用它。静态局部变量的值在函数调用结束后不消 失而保留原值，即其占用的存储单元不释放，在下一次函数调用时，该 变量已有值，就是上一次函数调用结束时的值。 静态局部变量在静态存储区分配存储单元，在程序的整个运行期间都不 释放。静态局部变量是在编译时赋初值的，即只赋初值一次。
在 SDT 编译器中，建议对静态局部变量赋初值，否则该静态局部变量的 初值为不确定值。在其他编译器中，未初始化的静态局部变量的初值可 能为零，这由具体的编译器所决定，使用前最好测试一下。 寄存器变量 register 带 register 修饰符的变量暗示（仅仅是暗示而不是命令）编译程序本 变量将被频繁使用，如果可能的话，应将其保留在 CPU 的寄存器中，以 加快其存取速度。 对于现有的大多数编译程序，最好不要使用 register 修饰符。因为它 是对早期低效的 C 编译程序的一个很有价值的补充。随着编译程序技术 的进步，在决定哪些变量应当被存到寄存器中时，现在的 C 编译程序能 比程序员做出更好的决定。 全局变量 在函数之外定义的变量称为外部变量，外部变量是全局变量，它可以为 本文件中其他函数所共用。全局变量都是静态存储方式，都是在编译时 分配内存，但是作用范围有所不同。 静态外部变量 static 静态外部变量只能在本文件中使用。所以静态外部变量应该在当前源文 件中声明和定义。 外部变量 extern 定义函数中的全局变量时，其缺省格式是外部变量类型。外部变量应该 在一个头文件中声明，在当前源文件中定义。外部变量允许其他文件引 用。
int
def1 = 8; // this is a definitionFra bibliotekint
def2; // this is a definition
函数
内部函数的声明和定义多在当前源文件中完成；而外部函数通常在源文
件中定义，在头文件中声明。
内部函数
只在当前源文件中使用的函数应该说明为内部函数。内部函数应该在当
前源文件中声明和定义。若内部函数在头文件中声明，其他源文件通过
外部变量 extern 定义函数中的全局变量时，其缺省格式是外部变量类型。外部变量应该 在一个头文件中声明，在当前源文件中定义。外部变量允许其他文件引 用。 下例声明了一个变量和一个结构，定义了两个变量，其中一个定义带初 始化： extern int decl1; // this is a declaration
数，后一个是声明函数。 小结 编写程序，尤其是大型程序时，建议采用上文所述的方法对不同的变量、 函数进行必要的声明、定义。做好这些细节上的事务，可以为您的编程、 调试、移植等带来很大的方便。
变量 在将变量前，先解释一下声明和定义这两个概念。声明一个变量意味着 向编译器描述变量的类型，但并不为变量分配存储空间。定义一个变量 意味着在声明变量的同时还要为变量分配存储空间。在定义一个变量的 同时还可以对变量进行初始化。 局部变量通常只定义不声明，而全局变量多在源文件中定义，在头文件 中声明。 局部变量 在一个函数的内部定义的变量是内部变量，它只在本函数范围内有效。 自动变量 auto 函数中的局部变量，其缺省格式是自动变量类型。例如，在函数体中 int b, c=3; 和 auto int b, c=3; 是等价的。 自动变量是动态分配存储空间的，函数结束后就释放。自动变量如不赋 初值，则它的值是一个不确定的值。 静态局部变量 static 静态局部变量是指在函数体内声明和定义的局部变量，它仅供本函数使 用，即其他函数不能调用它。静态局部变量的值在函数调用结束后不消