【技术积累】C语言中的基础知识【三】

什么是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 <stdio.h>:这行代码用于引入标准输入输出库,以便在程序中使用输入输出函数。

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 <stdio.h>

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;
}

在这个例子中,首先在程序中包含了<stdio.h>头文件,该头文件包含了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函数打印局部变量和全局变量的值。

热门相关:恭喜你被逮捕了   道君   锦乡里   重生野性时代   民国之文豪崛起