C语言入门详解

一、C语言简介

C语言是一种通用的、过程式的编程语言，支持结构化编程、词法变量作用域和递归等功能，是迄今为止最为强大的编程语言之一。C语言设计提供了能轻松实现底层的访问，通常用于系统软件开发，应用程序的一部分可以与硬件直接或者间接操作，而且C语言的应用十分广泛，不仅仅是在软件开发上，而且各类科研都需要用到C语言，适于编写系统软件，三维，二维图形和动画。

C语言中的关键字是预定义的、保留的标识符，它们具有特殊的含义，并且在C语言中有着特定的用途。这些关键字不能被用作变量名、函数名或其他标识符。下面我将详细介绍C语言中的一些主要关键字及其用途：

  1. 数据类型关键字：
    • int：用于声明整数类型变量。
    • char：用于声明字符类型变量。
    • float：用于声明单精度浮点类型变量。
    • double：用于声明双精度浮点类型变量。
    • long：与int结合使用，表示长整型；与double结合使用，表示双精度长浮点型。
    • short：与int结合使用，表示短整型。
    • _Bool或bool：用于声明布尔类型变量（C99标准后支持）。
    • _Complex或complex，以及_Imaginary或imaginary：用于声明复数和虚数类型变量（C99标准后支持）。
  2. 控制流关键字：
    • if：用于条件判断。
    • else：与if一起使用，表示不满足条件时执行的代码块。
    • switch：用于多分支选择结构。
    • case：与switch一起使用，表示一个分支。
    • default：与switch一起使用，表示默认执行的分支。
    • for：用于循环结构。
    • while：用于当型循环。
    • do...while：用于直到型循环。
    • break：跳出当前循环或switch语句。
    • continue：跳过当前循环的剩余部分，进入下一次循环。
    • goto：无条件跳转到指定标签。
  3. 存储类关键字：
    • auto：局部变量的默认存储类。
    • register：建议编译器将局部变量存储在寄存器中（但现代编译器通常会自动优化，因此这个关键字的实际效果可能不明显）。
    • static：用于声明静态变量或函数，它们在程序的生命周期内只被初始化一次。
    • extern：用于声明在其他文件中定义的变量或函数。
    • _Thread_local：用于声明线程局部变量（C11标准后支持）。
  4. 函数和变量修饰关键字：
    • const：声明常量或指向常量的指针。
    • volatile：告诉编译器不要优化该变量的访问，因为该变量的值可能会在程序不知道的情况下改变。
    • restrict：用于指针，表示该指针是访问数据的唯一方式（C99标准后支持）。
    • inline：建议编译器内联函数，即将函数体直接插入到调用点。
  5. 其他关键字：
    • size_t：用于表示对象的大小，通常与sizeof操作符一起使用。
    • void：表示无类型或空类型，常用于函数返回类型或指针类型。
    • signed和unsigned：用于修饰整数类型，表示有符号或无符号整数。
    • struct和union：用于定义结构体和联合体类型。
    • enum：用于定义枚举类型。
    • typedef：用于为数据类型定义新名称。

二、C语言的基本语法

1.数据类型

C语言中的变量必须先声明后使用，声明变量时要指定变量的类型。

C语言的基本数据类型主要包括以下几种：

  1. 整型（Integer Types）：

    • int：最基本的整数类型，其大小依据不同的系统和编译器有所不同，通常为16位、32位或64位。
    • short或short int：一种比int小的整数类型。
    • long或long int：一种比int大的整数类型。
    • long long或long long int：一种比long更大的整数类型。
    • signed和unsigned：这两种是修饰符，用于指定整数是否应该包含负值。默认情况下，int、short、long和long long都是signed的，但也可以明确指定为unsigned，表示只包含非负值。

  2. 浮点型（Floating-Point Types）：

    • float：单精度浮点数。
    • double：双精度浮点数。
    • long double：扩展精度的浮点数。

  3. 字符型（Character Types）：

    • char：用于存储字符（例如字母或标点符号）。char本质上也是整数类型，因为字符在计算机内部是以ASCII码（或其他编码方式）的整数形式存储的。

  4. 枚举类型（Enumeration Types）：

    • enum：允许你为整数常量定义一组有名字的值。

  5. void 类型：

    • void：表示“无类型”。它经常用于指针类型（如void *），表示一个通用指针，可以指向任何数据类型。在函数定义中，void也可以用作返回类型，表示该函数不返回任何值。

这些基本数据类型在C语言中是非常重要的，因为它们构成了程序中最基本的元素。此外，C语言还提供了结构（struct）、联合（union）和数组等复合数据类型，这些都可以由基本数据类型组合而成。

例子：

在C语言中，变量和常量有不同的定义方式。下面将分别介绍它们的定义方法：

2.变量

变量是用来存储数据值，并且这些值可以在程序执行过程中改变的量。变量必须在使用前进行声明，以指定其数据类型和名称。

变量的定义（声明并初始化）一般使用以下语法：

type variable_name = initial_value;

其中：

  • type是变量的数据类型（如int,float,char等）。
  • variable_name是你选择的变量名。
  • initial_value是变量初始化的值（可选）。

例如：

int age = 25; // 定义一个整型变量age并初始化为25
float pi = 3.14159; // 定义一个浮点型变量pi并初始化为3.14159
char gender = 'M'; // 定义一个字符型变量gender并初始化为'M'

如果只声明变量而不初始化，可以省略initial_value：

int score; // 声明一个整型变量score，未初始化，其值是不确定的

3.常量

常量是在程序执行期间其值保持不变的量。常量通常用于定义不会改变的值，如数学常数或配置参数。

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

使用#define定义常量

#define MAX_VALUE 100 // 定义一个名为MAX_VALUE的常量，其值为100

使用#define定义的常量在预处理阶段就已经替换为相应的值，没有数据类型。

使用const关键字定义常量

const int MAX_SIZE = 50; // 定义一个名为MAX_SIZE的整型常量，其值为50

使用const定义的常量具有明确的数据类型，并且在编译时确定其值。一旦初始化后，const常量的值就不能再改变。

需要注意的是，const常量有作用域，它可以是全局的或局部的，取决于其定义的位置。而#define定义的常量没有作用域限制，其作用范围从定义开始到源文件结束。

选择使用#define还是const取决于你的具体需求，例如是否需要类型检查，以及常量是否需要跨多个源文件使用等。在C++中，通常更倾向于使用const或constexpr来定义常量，因为它们提供了类型安全和其他一些优势。但在纯C语言中，#define和const都是有效的常量定义方式。

4.运算符与表达式

在C语言中，有多种运算符用于执行不同的操作。下面是一些主要的C语言运算符，并附带有相应的例子来阐明它们是如何工作的：

算术运算符

  • 加法+

    int a = 5;
    int b = 3;
    int sum = a + b; // sum 的值为 8

  • 减法-

    int diff = a - b; // diff 的值为 2

  • 乘法*

    int product = a * b; // product 的值为 15

  • 除法/

    float quotient = (float)a / b; // quotient 的值为 1.666667

  • 取模（求余数）%

    int remainder = a % b; // remainder 的值为 2

  • 自增++

    a++; // a 的值变为 6

  • 自减--

    b--; // b 的值变为 2

关系运算符（比较运算符）

  • 等于==

    if (a == b) {
    // 这个代码块不会执行，因为 a 不等于 b
    }

  • 不等于!=

    if (a != b) {
    // 这个代码块会执行，因为 a 不等于 b
    }

  • 大于>

    if (a > b) {
    // 这个代码块会执行，因为 a 大于 b
    }

  • 小于<

    if (b < a) {
    // 这个代码块会执行，因为 b 小于 a
    }

  • 大于等于>=

    if (a >= b) {
    // 这个代码块会执行，因为 a 大于等于 b
    }

  • 小于等于<=

    if (b <= a) {
    // 这个代码块会执行，因为 b 小于等于 a
    }

逻辑运算符

  • 逻辑与&&

    if (a > 2 && b < 4) {
    // 这个代码块会执行，因为 a 大于 2 且 b 小于 4
    }

  • 逻辑或||

    if (a 3) {
    // 这个代码块会执行，因为 a 小于 3 或者 b 大于 3（实际上两者都满足）
    }

  • 逻辑非!

    if (!(a == b)) {
    // 这个代码块会执行，因为 a 不等于 b，逻辑非将表达式的结果取反
    }

位运算符

  • 按位与&

    int x = 60; /* 60 = 0011 1100 */
    int y = 13; /* 13 = 0000 1101 */
    int z = x & y; /* z 现在是 12，即 0000 1100 */

  • 按位或|

    z = x | y; /* z 现在是 61，即 0011 1101 */

  • 按位异或^

    z = x ^ y; /* z 现在是 49，即 0011 0001 */

  • 按位取反~

    int not_x = ~x; /* not_x 现在是 -61，因为按位取反后所有的位都反转了，符号位变为1，表示一个负数 */

  • 左移<<

    int left_shift = x << 2; /* left_shift 现在是 240，即 1111 0000 */

    右移>>

    int right_shift = x >> 2; /* right_shift 现在是 15，即 0000 1111 */

    赋值运算符

  • 赋值=
  • int num = 10; /* 将变量 num 赋值为 10 */
  • 加等于+=
  • num += 5; /* 相当于 num = num + 5，现在 num 的值为 15 */
  • 减等于-=
  • num -= 3; /* 相当于 num = num - 3，现在 num 的值为 12 */
  • 乘等于*=
  • num *= 2; /* 相当于 num = num * 2，现在 num 的值为 24 */
  • 除等于/=
  • num /= 4; /* 相当于 num = num / 4，现在 num 的值为 6 */
  • 模等于%=
  • num %= 2; /* 相当于 num = num % 2，现在 num 的值为 0 */

    条件运算符（三目运算符）

    int max = (a > b) ? a : b; /* 如果 a 大于 b，则 max 为 a 的值，否则为 b 的值 */

    其他运算符

  • sizeof 运算符
  • size_t size = sizeof(int); /* 返回 int 类型的大小，通常为 4 字节，但取决于编译器和平台 */
  • 取地址运算符&
  • int var = 20;
    int *ptr = &var; /* ptr 存储了变量 var 的地址 */
  • 间接引用运算符*
  • int value = *ptr; /* value 现在为 20，因为它是 ptr 所指向地址的内容 */

    这些运算符在C语言编程中是非常基础和常用的，它们允许你执行各种数学计算、逻辑判断、内存操作等任务。不同的运算符有不同的优先级和结合性，因此在编写复杂的表达式时，了解这些规则非常重要。当需要改变运算顺序时，可以使用括号来明确指定。

  1. 条件语句

C语言中的条件语句包括if语句和switch语句，用于根据条件执行不同的代码块。

例子（if语句）：

#include
int main() {
int num = 10;
if (num > 0) {
printf("num is positive.\n");
} else if (num < 0) {
printf("num is negative.\n");
} else {
printf("num is zero.\n");
}
return 0;
}

例子（switch语句）：

#include
int main() {
int day = 3;
switch (day) {
case 1:
printf("Monday\n");
break;
case 2:
printf("Tuesday\n");
break;
case 3:
printf("Wednesday\n");
break;
// ... 其他情况
default:
printf("Invalid day\n");
}
return 0;
}

5.流程控制

C语言的流程控制语句是用于控制程序执行顺序的关键构造。它们允许程序根据特定条件选择不同的执行路径，或者重复执行某段代码。以下是C语言中主要的流程控制语句的详细介绍：

5.1条件语句

if 语句

if语句用于基于某个条件来执行代码块。如果条件为真（非零），则执行if后的代码块；否则，跳过该代码块。

if (condition) {
// code to be executed if the condition is true
}
if…else 语句

if...else语句提供了两个执行路径：如果条件为真，则执行if后的代码块；否则，执行else后的代码块。

if (condition) {
// code to be executed if the condition is true
} else {
// code to be executed if the condition is false
}

if…else if…else 语句

多个if...else if...else可以一起使用，以根据多个条件执行不同的代码块。

if (condition1) {
// code block for condition1
} else if (condition2) {
// code block for condition2
} else {
// code block for all other conditions
}

5.2.循环语句

for 循环

for循环用于在给定条件为真时重复执行一段代码。循环体在每次迭代后都会检查条件。

for (initialization; condition; update) {
// code to be executed repeatedly
}
while 循环

while循环会在给定条件为真时重复执行一段代码。与for循环不同，while循环在循环体执行前检查条件。

while (condition) {
// code to be executed repeatedly
}
do…while 循环

do...while循环至少会执行一次循环体，因为条件是在循环体执行后检查的。

do {
// code to be executed at least once
} while (condition);

5.3.跳转语句

break 语句

break语句用于立即跳出最内层的循环或switch语句。

continue 语句

continue语句用于跳过当前循环的剩余部分，并开始下一次迭代。

goto 语句

goto语句用于无条件跳转到程序中的另一个位置。尽管goto语句在某些情况下可能有用，但它通常不推荐使用，因为它会使代码难以理解和维护。

goto label;
// ...
label: statement;

5.4.选择语句

switch 语句

switch语句用于基于变量的不同值来执行不同的代码块。

switch (variable) {
case constant1:
// code block for constant1
break;
case constant2:
// code block for constant2
break;
// ...
default:
// code block for all other cases
}

在编写流程控制语句时，需要注意以下几点：

  • 确保条件表达式和循环条件正确无误，以避免无限循环或意外的程序行为。
  • 使用合适的缩进和空格来使代码结构清晰易读。
  • 尽量避免使用复杂的嵌套结构，这可能会使代码难以理解和维护。
  • 使用break语句来避免switch语句中的代码块贯穿（fall-through）行为，除非这是有意为之。

6.函数

函数是C语言中非常重要的概念，用于封装一段可重复使用的代码。

C语言中的函数是执行特定任务的一段独立代码块，它们可以被多次调用以执行相同的任务，而无需重复编写相同的代码。函数提高了代码的可重用性和模块化，使得程序更易于维护和扩展。下面是关于C语言函数的详细介绍：

函数的定义

函数的定义包括函数返回类型、函数名、参数列表和函数体。

return_type function_name(parameter list) {
// 函数体
// 执行特定任务的代码
}
  • return_type：函数返回值的类型。如果函数不返回任何值，则使用void关键字。
  • function_name：函数的唯一标识符，用于在程序中调用该函数。
  • parameter list：函数接受的参数列表，由逗号分隔。参数列表是可选的，如果函数不需要任何参数，则省略。
  • 函数体：包含执行特定任务的代码块。

函数的调用

通过函数名和传递必要的参数来调用函数。

function_name(argument list);
  • function_name：要调用的函数的名称。
  • argument list：传递给函数的参数列表，与函数定义中的参数列表相对应。

函数的返回值

函数可以返回一个值给调用者。返回值的类型在函数定义时指定。

return_type function_name() {
// ... 函数体 ...
return value; // 返回一个值给调用者
}

如果函数不返回任何值，它的返回类型应为void，并且不需要return语句。

函数的参数

函数参数可以是任何有效的C数据类型，包括基本类型、数组、指针和结构。函数定义中的参数列表指定了参数的类型和顺序，调用函数时必须按照相同的顺序和类型传递参数。

函数的分类

C语言中的函数可以根据其定义的位置和使用方式分为几类：

  • 库函数：由C标准库或其他库提供的函数，如printf、scanf等。
  • 自定义函数：由程序员自己定义的函数，用于执行特定的任务。
  • 主函数：main函数是C程序的入口点，程序执行从这里开始。

函数的作用域和可见性

  • 作用域：指变量或函数在程序中的有效范围。局部变量只在定义它们的函数内部可见，而全局变量在整个程序中都是可见的。
  • 可见性：指函数或变量是否可以在其他文件中访问。默认情况下，函数和全局变量是内部链接的，即它们只在定义它们的文件中可见。如果需要在其他文件中访问它们，可以使用extern关键字进行外部链接。

函数的递归

递归是一种特殊的函数调用方式，其中函数直接或间接地调用自身。递归在解决某些问题（如阶乘计算、斐波那契数列等）时非常有用，但需要小心处理，以避免无限递归和栈溢出。

函数指针

函数指针是指向函数的指针变量。它们可以用于将函数作为参数传递给其他函数，或从函数返回函数。函数指针提供了一种灵活的方式来处理函数，使得代码更加模块化和可重用。

通过合理使用函数，C语言程序员可以构建出结构清晰、易于维护和扩展的程序。

例子：

#include
// 定义一个函数，用于计算两个数的和
int add(int a, int b) {
return a + b;
}
int main() {
int x = 5, y = 10;
int sum = add(x, y); // 调用函数
printf("The sum of %d and %d is %d\n", x, y, sum);
return 0;
}

在上面的例子中，我们定义了一个名为add的函数，它接收两个整数作为参数，并返回它们的和。然后在main函数中，我们调用了add函数，并将结果存储在变量sum中。

7.数组

数组是一种用于存储多个相同类型数据的数据结构。

在C语言中，数组是一种用于存储多个相同类型数据元素的数据结构。这些元素在内存中连续存储，并可以通过索引来访问。下面将对C语言中的数组进行详细介绍：

1. 数组的定义

数组的定义语法如下：

类型说明符 数组名[常量表达式];
  • 类型说明符：指定数组中每个元素的数据类型，如int、char、float等。
  • 数组名：用于标识数组，遵循标识符的命名规则。
  • 常量表达式：表示数组的长度，即数组中元素的个数。注意，这个长度在数组定义后是不可变的。数组的下标从0开始，所以有效的下标范围是0到长度减1。

2. 数组的初始化

数组可以在定义时进行初始化，例如：

int myArray[5] = {1, 2, 3, 4, 5};

也可以部分初始化，剩余的元素会自动初始化为0（对于全局数组）或未定义值（对于局部数组）：

int myArray[5] = {1, 2}; // myArray[0] = 1, myArray[1] = 2, myArray[2] = 0, myArray[3] = 0, myArray[4] = 0

如果在对全部数组元素赋初值时，可以不指定数组长度，编译器会根据初始化的元素个数自动确定数组长度。

3. 数组的引用

在C语言中，数组元素是通过数组名和索引来引用的。索引是一个整数，用于指定要访问的数组元素的位置。数组元素的表示形式为：

数组名[下标];

下标可以是整型常量或整型表达式，但必须在数组的有效下标范围内。例如，对于上述定义的myArray，可以通过myArray[0]访问第一个元素，通过myArray[4]访问最后一个元素。

4. 数组的操作

可以使用循环结构（如for循环）来遍历数组，并对数组中的每个元素进行操作。例如，可以计算数组元素的和、查找特定元素、对数组进行排序等。

注意事项

  • 数组的长度在定义后是固定的，不能动态改变。如果需要动态改变数组大小，可以考虑使用动态内存分配（如使用malloc和free函数）。
  • 数组名在大多数上下文中会退化为指向数组首元素的指针。但请注意，数组名和指针并不完全等同，它们在内存布局和操作方式上有所区别。
  • 访问数组时，要确保索引在有效范围内，否则可能导致越界访问，引发程序错误或安全问题。

通过掌握这些关于C语言中数组的基本概念和操作，你可以更有效地使用数组来处理数据和执行各种计算任务。

例子：

#include
int main() {
int numbers[5] = {1, 2, 3, 4, 5}; // 声明并初始化一个整型数组
// 遍历数组并打印每个元素
for (int i = 0; i < 5; i++) {
printf("numbers[%d] = %d\n", i, numbers[i]);
}
return 0;
}

在上面的例子中，我们声明了一个包含5个整数的数组numbers，并使用循环遍历并打印数组的每个元素。

8.指针

指针是C语言中一个非常重要的概念，它存储了变量的内存地址。通过指针，我们可以直接访问和操作内存中的数据。

在C语言中，指针是一个非常重要的概念，它允许程序直接访问和操作内存地址。指针的语法规则相对直接，但理解其背后的概念和使用方法是至关重要的。下面将详细解释C语言中指针的语法规则。

1. 指针的声明

指针的声明使用星号（*）作为前缀，后面跟着数据类型和变量名。例如：

c复制代码
int *ptr; // 声明一个指向整数的指针变量ptr 
char *str; // 声明一个指向字符的指针变量str
这里，ptr是一个指向int类型数据的指针，str是一个指向char类型数据的指针。
2. 指针的初始化
指针在声明后必须被初始化，否则它可能包含随机的内存地址，这可能导致未定义的行为。初始化指针通常有两种方式：
2.1 指向一个已分配的变量
int x = 10; 
int *ptr = &x; // 将ptr初始化为x的地址
2.2 设置为NULL或nullptr（C++11及以后）
int *ptr = NULL; // 将ptr初始化为NULL，表示它不指向任何有效的内存地址 
// 或者在C++11及以后的版本中 
int *ptr = nullptr; // 使用nullptr代替NULL，更加明确和安全
3. 通过指针访问数据
使用星号（*）运算符来解引用指针，即获取指针指向的值。
int x = 10; 
int *ptr = &x; 
printf("%d\n", *ptr); // 输出：10，通过解引用ptr获取x的值
4. 指针的运算
指针可以进行一些基本的算术运算，如加法、减法和比较。这些运算通常在处理数组和动态内存分配时非常有用。
4.1 指针加法
int arr[5] = {1, 2, 3, 4, 5}; 
int *ptr = arr; // ptr指向arr的第一个元素 
ptr++; // ptr现在指向arr的第二个元素
4.2 指针减法
int *ptr1 = &arr[2]; // ptr1指向arr的第三个元素 
int *ptr2 = &arr[0]; // ptr2指向arr的第一个元素 
ptrdiff_t diff = ptr1 - ptr2; // diff的值为2，因为ptr1和ptr2之间相隔两个元素
4.3 指针比较
if (ptr1 > ptr2) { 
// ptr1指向的位置在ptr2之后 
}
5. 指针作为函数参数
指针可以作为函数的参数，这样函数就可以修改外部变量的值。
void increment(int *num) { 
(*num)++; // 解引用num，并增加其指向的值 
} 
int main() { 
int x = 5; 
increment(&x); // 调用函数，将x的地址传递给increment 
printf("%d\n", x); // 输出：6，x的值已经被increment函数修改 
return 0; 
}
6. 指针和数组
在C语言中，数组名在大多数情况下会退化为指向数组首元素的指针。这使得我们可以使用指针来遍历和操作数组。
int arr[] = {1, 2, 3, 4, 5}; 
int *ptr = arr; // ptr指向arr的首元素 
for (int i = 0; i < 5; i++) { 
printf("%d ", *(ptr + i)); // 输出数组的每个元素 
}
7. 多级指针
指针本身也可以是一个指针的指向，这称为多级指针。例如，int **ptr是一个指向整数指针的指针。
int x = 10; 
int *p = &x; // p是一个指向整数的指针 
int **pp = &p; // pp是一个指向整数指针的指针，它指向p
注意事项
  • 未初始化的指针包含随机值，尝试解引用这样的指针会导致程序崩溃或未定义行为。
  • 野指针（悬挂指针）是指向已经被释放的内存的指针，同样不能解引用。
  • 避免指针运算超出其有效范围，这可能导致访问不属于程序的内存区域。
理解这些语法规则是掌握C语言中指针使用的基础，而熟练掌握指针的使用则是成为一名优秀的C语言程序员的关键。
例子：
#include 
int main() { 
int var = 20; // 一个普通的整型变量 
int *ptr = &var; // 声明一个指向整型的指针，并将它初始化为var的地址 
printf("Value of var: %d\n", var); 
printf("Address stored in ptr: %p\n", (void*)ptr); 
printf("Value of var using pointer: %d\n", *ptr); 
return 0; 
}
在上面的例子中，我们声明了一个整型变量var和一个指向整型的指针ptr。然后我们将var的地址赋值给ptr，并通过*ptr来访问var的值。
9.结构体
C语言中的结构体（struct）是一种用户自定义的数据类型，它允许你将不同类型的数据组合成一个单独的数据类型。通过使用结构体，你可以创建具有多个属性的复合数据类型，这些属性可以包括基本数据类型（如int、float、char等）以及其他结构体类型。
定义结构体
结构体的定义使用struct关键字，后面跟着结构体的名称和结构体成员列表。例如：
struct Student { 
int id; 
char name[50]; 
float score; 
};
在这个例子中，我们定义了一个名为Student的结构体，它有三个成员：一个整数类型的id，一个字符数组类型的name用于存储学生姓名，以及一个浮点类型的score用于存储学生的分数。
使用结构体
1. 声明结构体变量
你可以像声明其他类型的变量一样声明结构体变量：
struct Student student1;
2. 初始化结构体变量
在声明结构体变量的同时，你可以对其进行初始化：
struct Student student1 = {1, "Alice", 90.5};
3. 访问结构体成员
通过结构体变量和点运算符（.）可以访问结构体的成员：
printf("Student ID: %d\n", student1.id); 
printf("Student Name: %s\n", student1.name); 
printf("Student Score: %.2f\n", student1.score);
4. 结构体数组
你可以创建结构体数组来存储多个具有相同类型的数据：
struct Student students[3]; 
students[0] = {1, "Alice", 90.5}; 
students[1] = {2, "Bob", 85.0}; 
students[2] = {3, "Charlie", 92.0};
5. 结构体指针
你还可以使用指针来访问结构体的成员：
struct Student *ptr = &student1; 
printf("Student ID: %d\n", ptr->id);
在这里，ptr是一个指向Student类型结构体的指针，它指向student1。通过指针和箭头运算符（->）可以访问结构体的成员。
结构体的用途
结构体在C语言中有着广泛的应用。它们不仅可以用于组织复杂的数据，还可以作为函数参数或返回值，用于在函数之间传递多个相关的数据。此外，结构体还可以用于模拟面向对象编程中的对象，尽管C语言本身并不支持面向对象编程。
注意事项
  • 结构体的成员可以是任何有效的C数据类型，包括基本数据类型、数组、指针以及其他结构体。
  • 结构体的成员默认是公有的（public），没有像C++中的私有（private）或保护（protected）成员的概念。
  • 结构体的大小通常等于其所有成员大小的总和，但可能因为内存对齐（padding）而有所不同。
通过掌握结构体的定义和使用方法，你可以更加灵活地组织和处理C语言中的数据，提高代码的可读性和可维护性。
三、C语言的标准函数库
C语言中的标准函数库，也称为C标准库（C Standard Library），是一组预定义的函数、宏和类型的集合，它们提供了许多常用的功能，帮助开发者简化编程任务。这些函数和宏被组织在多个头文件中，开发者只需在程序中包含相应的头文件，就可以使用这些标准库中的功能。
以下是一些常用的C语言标准库及其主要功能：
  1. stdio.h：这是输入/输出库，主要用于文件操作和标准输入输出。它包含了如printf（用于输出格式化数据到标准输出设备）和scanf（用于从标准输入设备读取格式化数据）等函数。
  2. stdlib.h：这是标准通用库，包含了一些常用的工具函数和变量类型。例如，malloc和free用于动态内存分配和释放，exit用于退出程序，rand和srand用于生成随机数等。
  3. string.h：这是字符串处理库，包含了一系列操作字符串的函数。如strcpy（复制字符串），strcat（连接字符串），strlen（获取字符串长度）等。
  4. math.h：这是数学函数库，提供了一系列数学运算的函数。例如，sin、cos、tan等三角函数，sqrt（计算平方根），pow（计算幂）等。
  5. time.h：这是时间处理库，包含了一些处理日期和时间的函数。例如，time函数返回当前时间，localtime将时间转换为本地时间等。
  6. ctype.h：这是字符处理库，包含了一系列用于测试和映射字符的函数。例如，isalpha用于判断字符是否为字母，tolower用于将大写字母转换为小写等。