什么是C语言【了解即可】

C语言是一种通用的高级编程语言，由美国贝尔实验室的Dennis Ritchie在20世纪70年代早期开发出来的。它在计算机科学和软件工程领域中被广泛使用。

C语言具有以下特点：

1. 简洁高效：C语言的语法相对简洁，易于理解和学习。它没有过多的高级特性和复杂的语法结构，具有很高的执行效率。

2. 可移植性强：C语言可以在不同的平台上进行编译和运行，具有很好的可移植性。一份C语言程序可以在多个操作系统和计算平台上运行而无需修改。

3. 底层控制能力强：C语言直接面向计算机的底层，允许程序员对内存和硬件进行直接的控制和操作，能够实现高效的系统级编程。

4. 强大的功能扩展性：C语言可以通过调用库函数来实现各种功能，并具有方便的扩展性。可以根据需要编写自定义函数库，以提供特定功能的支持。

5. 丰富的数据类型和运算符：C语言支持各种基本的数据类型（如整型、字符型、浮点型等），并提供丰富的运算符（如算术、逻辑、位运算符等），能够满足不同的编程需求。

6. 低级别的操作能力：C语言允许直接对内存进行操作，通过使用指针来实现底层的数据结构和算法，提供了更高的灵活性和效率。

7. 可重用性强：C语言的模块化特性使得程序员可以将程序分解为多个函数，每个函数都可以独立编译和测试，可以在其他项目中重复使用，提高了代码的可重用性。

8. 方便的与其他语言交互：C语言可以方便地与其他高级语言（如C++、Python等）进行交互，通过调用外部函数或使用特定的接口，可以实现不同语言之间的函数调用和数据传递。

总体而言，C语言是一种功能强大、灵活性高并且易于学习和使用的编程语言，适用于系统级开发、嵌入式系统、驱动程序和性能要求较高的应用程序。

它是学习计算机科学和软件开发的重要基础，也是研究和开发许多关键技术的基石。

什么是编译器，C语言的编译过程是什么样的

C语言的编译过程主要分为以下几个步骤：

1. 预处理（Preprocessing）：预处理器（Preprocessor）将对源代码进行预处理，包括处理宏定义、包含头文件、条件编译等操作。预处理器会生成一个经过预处理的源代码文件。

2. 编译（Compilation）：编译器（Compiler）将预处理后的源代码文件翻译成汇编语言。编译器会进行词法分析、语法分析、语义分析和优化等操作。这一步生成的汇编语言代码是与特定平台相关的。

3. 汇编（Assembly）：汇编器（Assembler）将汇编语言代码翻译成目标文件，目标文件中包含了可执行指令以及必要的数据和符号表等信息。目标文件是机器可以直接执行的二进制代码。

4. 链接（Linking）：链接器（Linker）将目标文件与运行时库文件进行合并，解析和解决各个目标文件间的符号引用关系，生成最终的可执行文件。链接器还可以进行地址重定位、符号重定位等操作，最终生成的可执行文件可以在特定平台上运行。

编译器是一种将高级语言源代码翻译成目标代码（通常是机器代码）的软件工具。它将源代码进行词法分析、语法分析、语义分析和代码优化等过程，生成目标文件或可执行文件。编译器具有将高级语言翻译成低级语言的功能，能够处理变量、函数、表达式等，并将其转化为底层计算机可以理解的指令。编译器还可根据编程语言的特性进行一些优化，提高程序的执行效率。值得注意的是，编译器是与具体语言相关的，不同的编程语言需要使用相应的编译器进行编译。

C语言编写格式

C语言的编写格式如下：

完整代码示例：

#include <stdio.h>

int main() {

   return 0;
}

1. #include ：这行代码用于引入标准输入输出库，以便在程序中使用输入输出函数。

2. int main()：这是C语言程序的入口函数，也是程序执行的起点。

3. {}：大括号用于界定代码块，其中的代码将会被视为main函数的内容。

4. return 0;：这是main函数的返回语句。在C语言中，0通常表示程序成功执行，而非0则表示程序出现错误。

这段代码是一个最简单的C语言程序，其中除了引入了标准输入输出库和定义了一个空的main函数，没有其他具体操作。执行这段代码时，程序会从main函数开始执行，然后立即返回0，表示程序成功执行。

编写C语言程序时，还需要注意以下几点：

- C语言是大小写敏感的，所以关键字如"int"和函数名如"main"必须使用正确的大小写。

- 代码中的语句必须以分号（;）结尾。

- 代码的缩进和空格使用不是强制要求的，但是良好的缩进风格能够使代码更易读。

- 在编写复杂的程序时，可以将代码划分到多个函数中，如定义其他函数来执行具体的操作，然后在main函数中调用这些函数。

- C语言程序中可以使用注释（// 或 /* */）来增加代码的可读性，注释部分的内容不会被编译器执行。

以上是C语言程序的基本编写格式和一些常见规范，具体的编写风格可以根据个人习惯和项目需求进行调整。

C语言中的输入输出

在C语言中，输入输出主要通过标准库函数来实现，其中最常用的函数是scanf和printf。

scanf函数用于从标准输入设备（如键盘）读取输入，而printf函数用于将输出打印到标准输出设备（如屏幕）。

下面是一个简单的代码案例，演示了如何使用scanf函数读取输入并使用printf函数进行输出：

#include <stdio.h>

int main() {
   int number;
   printf("请输入一个整数：");
   scanf("%d", &number);
   printf("你输入的整数是：%d\n", number);

   return 0;
}

在上面的代码中，首先使用printf函数输出提示信息，然后使用scanf函数读取一个整数，并将读取的值存储在名为number的变量中。最后，使用printf函数将读取的整数打印出来。

可以运行上述代码，并尝试在控制台中输入一个整数，然后查看输出结果。

C语言中的注释

在C语言中，注释用于对代码进行解释说明，对于其他开发者或者自己阅读代码时提供辅助信息。C语言中有两种类型的注释：单行注释（//）和多行注释（/* */）。

1. 单行注释（//）：单行注释通常用于注释一行代码，可以放在代码行的末尾或者单独一行。单行注释以两个斜杠（//）开头，直到行末结束。

以下是一个使用单行注释的示例代码：

#include <stdio.h>

int main() {
    int num1 = 10;  // 初始化一个整数变量num1为10
    int num2 = 20;  // 初始化一个整数变量num2为20

    // 计算两个数的和并输出结果
    int sum = num1 + num2;
    printf("Sum: %d", sum);

    return 0;
}

在上面的代码中，使用了单行注释对代码进行了解释，使其更易于理解。

2. 多行注释（/* */）：多行注释通常用于注释一段较长的代码或者注释某个代码块。多行注释以 /* 开始，以 */ 结束，中间的部分都被注释掉。

以下是一个使用多行注释的示例代码：

#include <stdio.h>

/*
这是一个用来打印"Hello, World!"的简单程序
*/

int main() {
    printf("Hello, World!");

    return 0;
}

在上面的代码中，使用了多行注释来注释程序的整个说明。这种注释可以提供有关程序的整体功能和设计思路的详细信息。

注释对代码的可读性和可维护性非常重要，它们可以帮助其他开发人员和自己更好地理解代码。无论是单行注释还是多行注释，都应该尽量清晰、准确地解释代码的含义和目的。

C语言中的数据类型有哪些

在C语言中，常见的数据类型包括整型、浮点型、字符型和指针类型。

整型（Integer）：整型数据类型用于存储整数值。在 C 语言中，有不同的整型类型，包括带符号和无符号类型。常见的整型类型有：

• int：用于存储整数值，通常占用4个字节的空间，取决于编译器和平台。
• short：用于存储较小范围的整数值，通常占用2个字节的空间。
• long：用于存储较大范围的整数值，通常占用至少4个字节的空间。
• long long：用于存储更大范围的整数值，占用至少8个字节的空间。

浮点型（Floating-point）：浮点型数据类型用于存储浮点数（小数）。在 C 语言中，有两种常见的浮点型类型：

• float：用于存储单精度浮点数，通常占用4个字节的空间。
• double：用于存储双精度浮点数，通常占用8个字节的空间。

字符型（Character）：字符型数据类型用于存储单个字符。在 C 语言中，字符型使用 char 关键字。char 类型的变量通常占用一个字节的空间。

指针类型（Pointer）：指针类型用于存储变量的内存地址。指针变量包含另一个变量的内存地址，而不是存储实际的值。在 C 语言中，指针类型使用 * 符号进行声明。例如，int* 表示一个指向整型变量的指针。指针可以通过 & 运算符获取变量的地址，并使用 * 运算符访问指针指向的变量的值。

下面是一个案例，展示了这些不同数据类型的用法和定义：

#include <stdio.h>
#include <stdbool.h>

int main() {
    // 整型数据类型
    int num = 10;
    printf("整型: %d\n", num);

    short shortInt = 20;
    printf("短整型: %hd\n", shortInt);

    long longInt = 30;
    printf("长整型: %ld\n", longInt);

    long long longLongInt = 40;
    printf("长长整型: %lld\n", longLongInt);

    // 无符号整型
    unsigned int unsignedInt = 50;
    printf("无符号整型: %u\n", unsignedInt);

    // 浮点型数据类型
    float decimal = 3.14;
    printf("浮点型: %f\n", decimal);

    double doubleDecimal = 6.28;
    printf("双精度浮点型: %lf\n", doubleDecimal);

    // 字符型数据类型
    char character = 'A';
    printf("字符型: %c\n", character);

    // 布尔型数据类型
    bool boolean = true;
    printf("布尔型: %d\n", boolean);

    // 指针类型
    int *pointer = &num; // 定义指向整型变量的指针
    printf("指针类型: %p\n", pointer);

    return 0;
}

C语言中的变量和常量

在C语言中，可以使用#define预处理命令或者使用const关键字来定义常量。

使用#define预处理命令定义常量的语法如下：

#define 常量名 常量值

例如：

#define PI 3.1415926

在上述代码中，将常量名PI定义为3.1415926。

使用const关键字定义常量的语法如下：

const 数据类型 常量名 = 常量值;

例如：

const int MAX_VALUE = 100;

在上述代码中，将常量名MAX_VALUE定义为100，类型为整数类型。

在C语言中，可以在函数内部或者全局范围内声明变量。在函数内部声明的变量称为局部变量，只在函数内部有效。在函数外部声明的变量称为全局变量，对整个程序都有效。

声明变量的语法如下：

数据类型 变量名;

例如：

int age;
float salary;

在上述代码中，分别声明了整型变量age和浮点型变量salary。

在C语言中，可以使用赋值运算符将值赋给变量。

变量赋值的语法如下：

变量名 = 表达式;

例如：

age = 25;
salary = 5000.00;

在上述代码中，将整型变量age赋值为25，将浮点型变量salary赋值为5000.00。

代码块示例：

#include <stdio.h>

#define PI 3.1415926

int main() {
    const int MAX_VALUE = 100;
    int age;
    float salary;

    age = 25;
    salary = 5000.00;

    printf("PI: %f\n", PI);
    printf("MAX_VALUE: %d\n", MAX_VALUE);
    printf("age: %d\n", age);
    printf("salary: %.2f\n", salary);

    return 0;
}

在上述示例代码中，定义了一个常量PI，并在主函数内部声明了一个常量MAX_VALUE、一个整型变量age和一个浮点型变量salary。然后通过赋值运算符将age赋值为25，salary赋值为5000.00。最后使用printf函数输出这些常量和变量的值。输出结果如下：

PI: 3.141593
MAX_VALUE: 100
age: 25
salary: 5000.00

C语言中的运算符

C语言中包含了多种运算符，可以根据其功能将其分为以下几类：

算术运算符主要用于执行基本的数学运算。

常用的算术运算符有加法运算符（+）、减法运算符（-）、乘法运算符（*）、除法运算符（/）和求余（取模）运算符（%）。它们的基本用法如下：

#include <stdio.h>

int main() {
    int a = 10;
    int b = 5;
    int c;

    c = a + b;  // 加法运算
    printf("a + b = %d\n", c);

    c = a - b;  // 减法运算
    printf("a - b = %d\n", c);

    c = a * b;  // 乘法运算
    printf("a * b = %d\n", c);

    c = a / b;  // 除法运算
    printf("a / b = %d\n", c);

    c = a % b;  // 求余运算
    printf("a %% b = %d\n", c);

    return 0;
}

赋值运算符用来给变量赋值。

常用的赋值运算符是等号（=）。

它的基本用法如下：

#include <stdio.h>

int main() {
    int a = 10;
    int b;

    b = a;  // 将a的值复制给b
    printf("b = %d\n", b);

    return 0;
}

关系运算符用于比较两个值的关系，并返回结果为真（1）或假（0）。

常用的关系运算符有相等运算符（==）、不等运算符（!=）、大于运算符（>）、小于运算符（<）、大于等于运算符（>=）和小于等于运算符（<=）。

它们的基本用法如下：

#include <stdio.h>

int main() {
    int a = 10;
    int b = 5;

    if (a == b) {
        printf("a 等于 b\n");
    } else {
        printf("a 不等于 b\n");
    }

    if (a != b) {
        printf("a 不等于 b\n");
    } else {
        printf("a 等于 b\n");
    }

    if (a > b) {
        printf("a 大于 b\n");
    } else {
        printf("a 不大于 b\n");
    }

    if (a < b) {
        printf("a 小于 b\n");
    } else {
        printf("a 不小于 b\n");
    }

    if (a >= b) {
        printf("a 大于等于 b\n");
    } else {
        printf("a 小于 b\n");
    }

    if (a <= b) {
        printf("a 小于等于 b\n");
    } else {
        printf("a 大于 b\n");
    }

    return 0;
}

逻辑运算符用于对两个或多个关系表达式进行逻辑运算。

常用的逻辑运算符有与运算符（&&）、或运算符（||）和非运算符（!）。

它们的基本用法如下：

#include <stdio.h>

int main() {
    int a = 10;
    int b = 5;

    if (a > 0 && b > 0) {
        printf("a 和 b 都大于 0\n");
    }

    if (a > 0 || b > 0) {
        printf("a 和 b 中至少有一个大于 0\n");
    }

    if (!(a > 0)) {
        printf("a 不大于 0\n");
    }

    return 0;
}

位运算符用于对整数的位进行操作。

常用的位运算符有按位与运算符（&）、按位或运算符（|）、按位异或运算符（^）和取反运算符（~）。

它们的基本用法如下：

#include <stdio.h>

int main() {
    unsigned int a = 60;       // 00111100
    unsigned int b = 13;       // 00001101
    unsigned int c = 0;

    c = a & b;  // 按位与运算
    printf("a & b = %d\n", c); // 输出为 12

    c = a | b;  // 按位或运算
    printf("a | b = %d\n", c); // 输出为 61

    c = a ^ b;  // 按位异或运算
    printf("a ^ b = %d\n", c); // 输出为 49

    c = ~a;     // 取反运算
    printf("~a = %d\n", c);    // 输出为 -61

    return 0;
}

移位运算符用于对整数进行位移操作。

常用的移位运算符有左移运算符（<<）和右移运算符（>>）。它们的基本用法如下：

#include <stdio.h>

int main() {
    int a = 5;

    int b = a << 2;  // 左移运算
    printf("a 左移 2 位：%d\n", b); // 输出为 20

    int c = a >> 1;  // 右移运算
    printf("a 右移 1 位：%d\n", c); // 输出为 2

    return 0;
}

条件运算符，也叫三元运算符，用于根据条件选择执行不同的语句。它的基本用法如下：

#include <stdio.h>

int main() {
    int a = 10;
    int b = 5;
    int max;

    max = (a > b) ? a : b;  // 如果 a 大于 b，则max等于a；否则max等于b
    printf("较大的数：%d\n", max);

    return 0;
}

以上是C语言中常见的运算符及其基本用法的介绍和代码案例。

C语言中的控制结构

C语言中有三种基本的控制结构：顺序结构、选择结构和循环结构。

1. 顺序结构：程序按照代码的书写顺序一行一行地执行。这是最基本的结构，程序会依次执行每一条语句，没有跳转或分支。

2. 选择结构：

   • if语句：根据条件的真假来选择执行不同的代码块。
   • if-else语句：根据条件的真假来选择执行不同的代码块，如果条件为假，则执行else代码块中的代码。
   • if-else if-else语句：根据多个条件的真假来选择执行不同的代码块，每一个条件都会依次被检查，如果其中一个条件为真，则执行相应的代码块。
   • switch语句：根据表达式的值选择执行不同的代码块，可以使用case语句来匹配不同的值。

3. 循环结构：

   • while循环：在条件为真的情况下，重复执行一段代码块，每次循环都会根据条件判断是否继续执行。
   • do-while循环：首先执行一段代码块，然后在条件为真的情况下重复执行这段代码块，每次循环都会根据条件判断是否继续执行。
   • for循环：包含初始化、循环条件和迭代语句的循环结构，可以控制循环的次数。
   • 嵌套循环：在一个循环内部包含着另一个循环。

这些控制结构可以根据具体的业务逻辑和需求进行组合和嵌套，以实现复杂的程序逻辑和控制流程。

C语言中的选择结构

在C语言中，常见的选择结构有条件语句（if语句）、多重条件语句（if-else语句）和switch语句。

1. 条件语句（if语句）：当某个条件为真时，执行一段代码。
   代码案例：

   #include <stdio.h>

   int main() {
      int num = 10;

      if (num > 0) {
         printf("Number is positive\n");
      }

      return 0;
   }

2. 多重条件语句（if-else语句）：当某个条件为真时执行一段代码，否则执行另一段代码。
   代码案例：

   #include <stdio.h>

   int main() {
      int num = 10;

      if (num > 0) {
         printf("Number is positive\n");
      } else {
         printf("Number is negative\n");
      }

      return 0;
   }

3. switch语句：根据不同的表达式值，选择不同的代码分支进行执行。

switch语句的执行流程如下：

1. 先计算表达式的值。

2. 将表达式的值与每个case后的常量进行比较，如果匹配成功，则执行与该case关联的代码块，否则继续比较下一个case。

3. 如果匹配成功的case后面没有break语句，程序会继续执行下一个case中的代码块（不进行匹配），直到遇到break语句或者switch语句结束。

4. 如果所有的case都与表达式的值不匹配，且存在default语句，那么会执行default后面的代码块。

5. 如果没有default语句，并且没有匹配成功的case，那么switch语句不会执行任何代码块。

   #include

   int main() {
   int num = 2;

   switch (num) {
       case 1:
           printf("Number is 1\n");
           break;
       case 2:
           printf("Number is 2\n");
           break;
       case 3:
           printf("Number is 3\n");
           break;
       default:
           printf("Number is not 1, 2 or 3\n");
   }
   
   return 0;

   }

在以上代码中，当num的值为2时，输出结果为 "Number is 2"。

如果num的值是1，输出结果为 "Number is 1"，如果num的值是3，输出结果为 "Number is 3"。

如果num的值不是1、2、3中的任意一个，输出结果为 "Number is not 1, 2 or 3"。

以上是C语言中常见的选择结构。根据不同的条件，程序可以选择执行不同的代码分支，从而实现更灵活的控制流程。

C语言中的循环结构

在C语言中，有以下几种循环结构：

1. while循环：通过判断条件来重复执行一段代码块，直到条件不成立退出循环。

int i = 0;
while (i < 5) {
  printf("i = %d\n", i);
  i++;
}

2. do…while循环：先执行一段代码块，然后再判断条件是否成立，如果条件成立则继续执行循环，否则退出循环。

int i = 0;
do {
  printf("i = %d\n", i);
  i++;
} while (i < 5);

3. for循环：在指定的初始条件下，重复执行一段代码块，然后每次循环结束后更新循环控制变量，直到不满足循环条件退出循环。

for (int i = 0; i < 5; i++) {
  printf("i = %d\n", i);
}

4. 嵌套循环：在循环结构内部再嵌套一个或多个循环结构，用于处理多维数组或多次迭代的问题。

for (int i = 0; i < 3; i++) {
  for (int j = 0; j < 2; j++) {
    printf("i = %d, j = %d\n", i, j);
  }
}

5. break语句：在循环结构内部，可以使用break语句跳出当前循环，立即结束循环的执行。

for (int i = 0; i < 5; i++) {
  if (i == 3) {
    break;
  }
  printf("i = %d\n", i);
}

6. continue语句：在循环结构内部，可以使用continue语句跳过本次循环的剩余代码，继续执行下一次循环。

for (int i = 0; i < 5; i++) {
  if (i == 2) {
    continue;
  }
  printf("i = %d\n", i);
}

C语言中的goto语句

在C语言中，goto语句是一种跳转语句，它允许程序根据特定条件无条件地跳转到程序中的某个标签位置。该标签位置通常是被定义在程序的其他位置。

goto语句在C语言中的作用如下：

1. 跳转到特定位置：使用goto语句，可以直接跳转到程序中的某个标签位置，避免了通过循环或条件判断语句来实现跳转的复杂性。这在某些情况下可以提高程序的可读性和简化代码的结构。

2. 退出嵌套循环：当需要在嵌套循环中提前退出所有循环时，使用goto语句可以直接跳转到循环外部的标签位置。这比使用多层循环结构和标志位等方法更简洁。

3. 处理错误或异常情况：通过goto语句，可以直接跳转到错误处理或异常处理的代码段，从而方便地处理错误或异常情况，提高程序的健壮性。

4. 简化代码逻辑：通过合理使用goto语句，可以将代码跳转逻辑更加清晰地表达出来，避免了使用过多的条件判断语句或复杂的循环结构。

#include <stdio.h>

int main() {
    int num;

    printf("请输入一个大于10的数字：");
    scanf("%d", &num);

    if (num <= 10) {
        printf("输入的数字小于或等于10，出现错误！\n");
        goto error;  // 跳转到错误处理部分
    }

    printf("输入的数字大于10，没有错误。\n");

    return 0;

error:
    printf("错误处理代码段\n");

    return 1;
}

在上述代码中，用户首先被要求输入一个数字，然后检查输入是否合法。如果输入的数字小于或等于10，将输出错误消息并通过goto语句跳转到错误处理部分。否则，将输出一个没有错误的消息。

在错误处理部分，可以添加额外的代码来处理错误的情况，比如关闭文件、释放资源等。

请注意，此处只是一个简单示例，实际中的错误处理可能更复杂。对于复杂的程序，在使用goto语句时应格外小心，确保代码的可读性和可维护性。

需要谨慎使用goto语句，因为过多地使用goto语句可能会导致代码混乱和可读性下降。而且，滥用goto语句可能会造成程序的流程控制不可预测和难以理解。因此，在实际编程中，应该慎重使用goto语句，合理使用其他控制结构来实现相同的功能。

C语言中的函数

C语言中的函数是一段可重复使用的代码，用于执行特定任务。函数由一组语句组成，可以接受输入参数并返回一个值。

函数在C语言中具有以下特点：

1. 函数声明：在使用函数之前，需要进行函数声明。声明提供了函数的名称、返回类型和参数类型。

2. 参数传递：函数可以接受输入参数，这些参数用于向函数传递数据。可以传递参数的类型包括基本类型（如整型、字符型等）和指针类型。

3. 函数体：函数体包含一组语句，用于实现函数的具体功能。

4. 返回值：函数可以返回一个值，该值可以是任意类型的数据。如果函数没有返回值，可以使用void来声明函数。

5. 函数调用：使用函数名称和参数列表进行函数调用。函数调用可以在程序中的任何地方进行，可以嵌套调用同一个函数。

6. 可重复使用：函数可以被多次调用，从而实现代码的复用。

7. 局部变量：函数中可以定义局部变量，这些变量的作用域仅限于函数内部，不会干扰其他函数或全局变量。

8. 递归调用：函数可以递归调用自身，实现复杂的算法和逻辑。

函数是C语言中的基本组件之一，可以帮助开发者组织代码，并提高代码的可维护性和可重用性。

在C语言中，函数的定义、声明和调用可以分为以下三个步骤：

函数的定义包括函数的返回类型、函数的名称、函数的参数列表以及函数的具体实现。函数定义的一般形式如下：

   返回类型 函数名(参数列表) {
       // 函数体，实现函数的具体功能
       // 可以包括一组语句
   }

其中，返回类型指定函数返回的数据类型，函数名是函数的标识符，参数列表包含了函数接受的参数类型和名称，函数体是实现函数功能的一组语句。

函数的声明提供函数的名称、返回类型和参数类型，用于在函数被使用之前进行声明。函数声明的一般形式如下：

返回类型 函数名(参数列表);

函数声明可以在函数的定义之前或其他函数中进行。

函数调用是通过函数名和参数列表来调用函数，传递参数并执行函数体中的语句。函数调用的一般形式如下：

函数名(参数列表);

在调用函数时，函数名后紧跟着一对小括号，括号内是对应的参数列表。

下面是一个具体示例，展示了函数的定义、声明和调用的过程：

#include <stdio.h>

// 函数声明
int sum(int a, int b);

// 函数定义
int sum(int a, int b) {
    int res;
    res = a + b;
    return res;
}

int main() {
    int num1 = 5;
    int num2 = 10;
    int result;

    // 调用函数
    result = sum(num1, num2);

    printf("两数之和为：%d\n", result);

    return 0;
}

在这个例子中，首先在程序中包含了头文件，该头文件包含了printf函数的定义。然后，在代码中先进行了函数的声明，接着定义了函数sum，在main函数中调用了sum函数，并打印出函数的返回值。

局部变量与全局变量

C语言中，局部变量是在函数、代码块或语句中定义的变量，其作用范围限制在定义它的函数、代码块或语句内部，生命周期与其所属的作用域相同。

局部变量在函数执行时被创建，在函数返回时被销毁，对外部作用域不可见。

全局变量是在函数外部定义的变量，在程序的整个运行期间都存在。

全局变量的作用范围在整个程序中可见，可被多个函数共享访问。

全局变量会在程序启动时被创建，在程序终止时才会销毁。

下面是一个案例，演示了局部变量和全局变量的使用：

#include <stdio.h>

// 全局变量
int globalVariable = 10;

void testFunction()
{
    // 局部变量
    int localVariable = 20;

    printf("局部变量: %d\n", localVariable);
    printf("全局变量: %d\n", globalVariable);
}

int main()
{
    printf("全局变量: %d\n", globalVariable);

    testFunction();

    return 0;
}

在上述例子中，全局变量globalVariable可以在整个程序中被访问。

在testFunction函数中，我们定义了一个局部变量localVariable，它的作用范围仅限于testFunction函数内部。在main函数中，我们可以访问全局变量globalVariable，同时调用testFunction函数打印局部变量和全局变量的值。