C语言历史与计算机结构

1972年贝尔实验室 Dennis Ritchie 和 Ken Thompson 在开发 UNIX 时设计 C 语言。

C语言在 B 语言（汤普逊发明）的基础上进行设计。

由于 C 语言与 UNIX 关系密切，UNIX 系统通常会将 C 编译器作为软件包的一部分。安装 Linux 时，通常也会安装 C 编译器。

功能强大且灵活的 UNIX 操作系统，大部分是用 C 语言写的。

很多其它的语言（如 FORTRAN、Perl、Python、Pascal、LISP、Logo、BASIC）的许多编译器和解释器都是用 C 语言编写的。也就是用 C 开发的工具去把这些语言的源码转换为计算机可以执行的程序。

另外，大多数 C 实现都有一个大型的库，包含众多有用的 C 函数。这些函数用于处理程序员经常需要解决的问题。

先了解计算机的结构：

1. 中央处理单元（CPU）承担绝大部分的运算工作
2. 随机存取内存（RAM）是存储程序和文件的工作区
3. 永久内存存储设备（过去一般指机械硬盘，现在还包括固态硬盘）即使在关闭计算机后，也不会丢失之前储存的程序和文件
4. 外围设备（如键盘、鼠标、触摸屏、监视器）提供人与计算机之间的交互

CPU 的工作是核心，其实它的工作也是很简单枯燥：它就是从内存中读取一条条的指令，执行一条指令再到下一条指令，指令执行的时候，可能需要用到一些数据。

CPU 就是这样不断在执行这些指令。只不过是它的执行速度非常快。每秒钟可以达到十几亿次。以后还会更快。

就是因为它快，所以我们的计算机可以同时多个软件在运行。

CPU 由若干个寄存器组成，每个寄存器都可以储存一个数字。这些数字有可能代表一个数据，比如 12、2、3 这些，也可能表示一条指令，比如 mov 移动等。

CPU 能理解的指令有限（这些指令的集合叫作指令集）。而且，这些指令相当具体，其中的许多指令都是用于请求计算机把一个数字从一个位置移动到另一个位置。例如，从内存移动到寄存器。

比如下面要求两个数的和：

1. 从内存位置 2000 上把一个数字拷贝到寄存器 A。
2. 从内存位置 2004 上把另一个数字拷贝到寄存器 B。
3. 把寄存器 B 中的内容与寄存器 A 中的内容相加，把结果储存在寄存器 A 中。
4. 把寄存器 A 中的内容拷贝到内存位置 2008。

mov 2000 A
mov 2004 B
add B A
mov A 2008

上面的指令就完成了两个数的和，具体就是 2000 内存中的数和 2004 内存中的数的和。

机器语言、汇编语言、高级语言

高级语言的目的就是抽象和简化低级语言，使得程序员可以使用更接近人类思维的语言来要求计算机做事情。

例如我们之前要求两个数的和，汇编语言可能是这样子（如下代码只是例子，不是正确的代码）：

mov 2000 A
mov 2004 B
add B A
mov A 2008

如果是机器语言，比如以前的卡片机。bug 为什么叫 bug？

现在高级语言就简单了：

int a = 1;
int b = 2;
int c = a + b;

对于我们人来说看上面的高级语言可能非常好理解，但是对于计算机来说那就是一堆无法理解的无用数据。

编译器在这里派上了用场。编译器是把高级语言程序翻译成计算机能理解的机器语言指令集的程序。

程序员进行高级思维活动，而编译器则负责处理冗长乏味的细节工作。

编译器还有一个优势：它可以把同一份代码，转换为不同的 CPU 的机器语言。因为不同的 CPU 它们的架构是不一样的，指令也就不一样。比如对于 Intel 的 CPU 可能 0111110 是加，而对于 ARM 的 CPU 可能 01101010 是加。

因此，使用合适的编译器或编译器集，便可把一种高级语言程序转换成供各种不同类型 CPU 使用的机器语言程序。一旦解决了一个编程问题，便可让编译器集翻译成不同 CPU 使用的机器语言。

简而言之，高级语言（如 C、Java、Pascal）以更抽象的方式描述行为，不受限于特定 CPU 或指令集。而且，高级语言简单易学，用高级语言编程比用机器语言编程容易得多。

程序开发过程

最早的编译器

我们如果要开发一个程序，那么要经过那些过程呢？

1. 程序的作用和目的是什么？想要程序去做什么首先自己要明确自己想做什么，思考你的程序需要哪些信息，要进行哪些计算和控制，以及程序应该要报告什么信息，也就是程序是做什么的。要用户提供什么，最后给什么结果用户。
2. 设计程序，给程序设计，要什么数据，提供什么，那个地方放什么，比如按钮、图片等等，还有程序分多少个模块等等这些。
3. 编写代码。代码是一串文本，我们可以使用一些工具来编写。

#include <stdio.h>

int main(void)
{
    int dogs;
    printf("How many dogs do you have?\n");
    scanf("%d", &dogs);
    printf("So you have %d dog(s)!\n", dogs);
    return 0;
}

C 是最广泛使用的计算机编程语言之一。C 之所以如此受欢迎是因为它可靠、简单且易于使用。这就是为什么尽管出现了许多新语言的事实，但 C 仍然是使用最广泛的语言。

C的特点

• 快
• 简单易学
• 最强大的编程语言
• 具有许多内置功能和运算符，可简化复杂程序
• 可以在多种计算机平台上进行编译
• 快速高效
• 用 C 编写的程序是可移植的，即，为一种类型的计算机或操作系统编写的程序可以在最小的修改下就可以在另一种类型的计算机或操作系统上运行
• 也广泛用于许多大型项目

如何开始？

在整个 C 教程中，我们将学习编写 C 程序。但是之后呢？

编写完任何程序后，我们需要编译并运行它以查看程序的输出。

那么，编译是什么意思？

当我们用 C 语言编写程序时，需要将其转换为机器语言（由 0 和 1 组成的二进制语言），以便计算机能够理解并执行它。这种转换称为编译程序。我们借助编译器来编译代码。

集成开发环境（IDE）

为了编写和编译我们的 C 程序，我们提供了许多 IDE。

IDE 由文本编辑器和编译器组成。我们在文本编辑器中键入程序，然后由编译器进行编译。

文本编辑器：我们在文本编辑器中编写程序。包含我们程序的文件称为源文件，并以 .c 扩展名保存。

C 编译器：将程序保存在扩展名为 .c 的文件中后，我们需要对其进行编译。如我们所见，我们需要编译代码以将其转换为计算机可以理解的机器语言。

现在让我们看看如何在不同的操作系统上编译和执行 C 程序。

在 Windows 上编写和编译 C 程序​

尽管有很多 IDE 可以用于 Windows 的 C 程序的编辑和编译，但在这里我们讨论的是使用 DevC++ 进行编辑和编译的程序，它允许我们编辑、编译和运行程序。我们可以使用 DevC++ 本身编写和保存程序，然后使用该程序进行编译。

在学习用 DevC++ 编写程序之前，请首先确保已将其安装在计算机中。如果没有，请下载并安装它。

要在 DevC++ 中编写和编译，请按照以下步骤操作：

1. 打开 DevC++ 时，您将看到一个窗口。单击”源文件”选项。
2. 如下所示，在空白处编写 C 程序并保存。

#include <stdio.h>
int main()
{
    printf("Hello World\n");
    return 0;
}

1. 编写程序后，单击”编译并运行”。
2. 将出现一个输出窗口，显示打印为”Hello World”的结果。

在 Linux 上编写和编译 C 程序​

对于 Linux，您可以使用各种文本编辑器（如 vim、gedit 或 Emacs）编写 C 程序。假设文本编辑器是 gedit，以下步骤显示了如何编辑和编译 C 程序。

1. 打开终端（ctrl+alt+T）。
2. 在您喜欢的编辑器中打开一个扩展名为 .c 的新文件（在我们的情况下文件名为 hello.c）。命令是：gedit hello.c
3. 文本编辑器窗口将打开。在下面键入下面的 C 程序并保存。

#include <stdio.h>
int main()
{
    printf("Hello World\n");
    return 0;
}

1. 要编译程序，请键入 cc -c hello.c，然后按 Enter。
2. 现在键入 cc hello.c -o hello 并按 Enter。这将创建名称为 hello 的可执行文件。
3. 要运行程序，请键入 ./hello，然后按 Enter。这将显示程序的输出。

第一个C程序解析

现在让我们从停下来的”Hello World”代码开始。

#include <stdio.h>
int main()
{
    printf("Hello World\n");
    return 0;
}

编译以上代码后，”Hello World”将显示在屏幕上。

printf("Hello World\n"); → printf 是一个函数，它在屏幕上显示括号内的内容。

我们使用了单词函数，所以让我们讨论一下它是什么。函数就像一个机器，需要从我们这里得到东西（不一定），然后执行操作。简而言之，函数从用户那里获取输入，然后返回输出。

在上面的示例中，printf 以”Hello World\n”作为输入，并在屏幕上显示”Hello World”，但不带有”\n”。因此，让我们讨论一下它是什么。

\n 是称为换行符的特殊字符，用于更改行或打印新行。因此，’Hello World’之后的’\n’更改了行或打印了新行。

#include <stdio.h>
int main()
{
    printf("Hello\n World\n");
    return 0;
}

如您所见，”\n”在”Hello”和”World”之间打印了新行。因此，”\n”用于在程序中打印新行。

最后尝试编写不带’\n’的相同代码，您将看到光标不会更改行，并且将开始在同一行上打印所有内容。

;（分号）告诉编译器语句结束。我们需要输入”;”在每个语句的末尾，例如函数调用、变量声明等。

因此，通过输入”;”在末尾 printf("Hello World\n");，我们已经在此处结束了该声明。此后写的所有内容将是新的声明。

#include <stdio.h>
int main()
{
    printf("Hello World\n"); return 0;
}

int main() → main 也是一个函数。它是在执行 C 代码时首先编译的，也就是说，任何 C 程序的执行都从该 main() 函数开始。int 在 main 之前表示该函数将返回（或返回给我们）一个整数。

由于每个 C 程序的执行均从该 main 功能开始，因此所有 C 程序都必须具有此 main() 功能。

{ }（大括号）在刚过 main() 功能包围该功能的主体。这意味着它表示”主体”内部的事物。

return 0 → 如前所述，该 main 函数返回一个整数值（int main()），因此此处返回 0。return 是一个关键字，用于从函数返回一些值。返回 0 表示我们的程序已成功运行，并且我们使用此 return 语句终止 main 函数。

#include <stdio.h> → stdio.h 代表标准输入输出。它是 C 语言的一个库，其中包含函数的定义，例如 printf。因此，它将告诉编译器”printf”应如何工作。#include 是一个预处理器，用于将程序与 stdio.h 链接。

注释

注释是在代码内部编写的语句，在编译我们的代码时，编译器只会忽略它们。编写注释以使我们的代码对人类更具可读性。

注释介于 /* ... */ 或 // 之间。

为什么要注释：如前所述，它使我们的代码更具可读性。假设您已经编写了一个软件，并在发布它之后，雇用了一些优秀的程序员来进行软件维护。没有注释，对他们来说，理解您的代码将是非常困难的工作。

//This is single line comment
//This is also a comment
#include <stdio.h>
int main()
{
    printf("Hello World\n");
    return 0;
}

/*Hello World code*/
/* Comments will not be compiled and will be ignored */
/* It is a
multiline
comment*/
#include <stdio.h>
int main()
{
    //printf function
    printf("Hello World\n");
    return 0;
}

接受用户输入

#include <stdio.h>
int main()
{
    int a;
    printf("Enter an integer");
    scanf("%d", &a);
    printf("Entered value is : %d\n", a);
    return 0;
}

int a; → 这是一条声明变量”a”是整数的语句。通过此声明，”a”进入了我们程序的世界。

scanf 是另一个功能，用于从键盘取值。%d 用于 C 中的整数，在这里，它表示 scanf 将从键盘获取整数值。&a → 表示在’a’的地址上。

#include <stdio.h>
int main()
{
    int x;
    int y;
    printf("Enter two integers\n");
    scanf("%d %d", &x, &y);
    int z = x + y;
    printf("Entered value is : %d and %d and their sum is %d\n", x, y, z);
    return 0;
}

数据类型与变量

在程序中使用变量之前，需要对其进行声明。数据类型用于为变量分配类型。

#include <stdio.h>
int main()
{
    int x;
    x = 10;
    return 0;
}

%d 用于 int，%c 用于 char，%f 用于 float。

#include <stdio.h>
int main()
{
    float a;
    int b;
    char ch;

    printf("\nEnter value of float\n");
    scanf("%f", &a);

    printf("\nEnter value of int\n");
    scanf("%d", &b);

    printf("\nEnter value of char\n");
    scanf(" %c", &ch);

    printf("\nValue of float : %f", a);
    printf("\nValue of int : %d", b);
    printf("\nValue of char : %c", ch);
    printf("\nValue of float(rounded) : %.2f\n", a);

    return 0;
}

%.2f 表示要打印的变量将为 float 类型，而’.2’表示将仅舍入到小数点后两位的数字。

有符号和无符号：有符号和无符号变量告诉我们它是否可以采取正值、负值或同时采取这两种方法。signed 关键字用于那些可以取正值也可以取负值的变量。unsigned 关键字用于那些只能接受零或正值的变量。

unsigned int x;

在 printf 中，%d 用于有符号整数，而 %u 用于无符号整数。

如何存储字符值：只要将字符值赋予 char 类型的变量，就会存储其 ASCII 值。

#include <stdio.h>
int main()
{
    char ch;
    printf("\nEnter value of char\n");
    scanf("%c", &ch);
    printf("\nCharacter value of character = %c", ch);
    printf("\nASCII value = %d\n", ch);
    return 0;
}

类型转换：类型转换是变量从一种数据类型到另一种数据类型的转换。

隐式转换：假设我们在 C 中添加一个整数和一个字符，例如 2 + 'a'。这是 C 语言中的有效表达式，因为 C 语言会自动将字符值”a”转换为整数（ASCII 值），然后将它们加起来。

#include <stdio.h>
int main()
{
    int a = 12;
    char ch = 'h';
    int sum = a + ch;
    printf("Sum = %d\n", sum);
    return 0;
}

显式转换：我们还可以手动将值从一种数据类型转换为另一种数据类型，如下所示：(数据类型)值;

#include <stdio.h>
int main()
{
    float x = 2.45;
    printf("%d\n", (int)x);
    return 0;
}

运算符

运算符是告诉编译器对变量执行某些操作的符号。

算术运算符

#include <stdio.h>
int main()
{
    int a = 25;
    int b = 8;
    printf("sum = %d", (a+b));
    printf("\ndifference = %d", (a-b));
    printf("\nproduct = %d", (a*b));
    printf("\nremainder = %d\n", (a%b));
    return 0;
}

如果我们将两个整数相除，则结果将是一个整数。5/2 = 2（不是 2.5）。要获得 2.5，分子或分母中的至少一个必须具有十进制（浮点）值。

运算符优先级：首先对方括号'()’中的表达式求值。之后遵循优先级表。

关系运算符

#include <stdio.h>
int main()
{
    int a = 5, b = 6;
    printf("\n%d", a == b);
    printf("\n%d", a != b);
    printf("\n%d", a > b);
    printf("\n%d", a < b);
    printf("\n%d", a >= b);
    printf("\n%d", a <= b);
    return 0;
}

= 和 == 之间的差异：= 是赋值运算符，而 == 是相等运算符。

逻辑运算符

#include <stdio.h>
int main()
{
    int a = 5, b = 0;
    printf("\n%d", a && b);
    printf("\n%d", a || b);
    printf("\n%d", !a);
    printf("\n%d", !b);
    return 0;
}

赋值运算符

#include <stdio.h>
int main()
{
    int a = 25;
    int b = 8;
    a += b;
    printf("%d\n", a);
    a -= b;
    printf("%d\n", a);
    a *= b;
    printf("%d\n", a);
    a /= b;
    printf("%d\n", a);
    a %= b;
    printf("%d\n", a);
    return 0;
}

增减运算符

++ 和 -- 分别称为增量和减量运算符。a++ 将变量’a’的值增加 1，而 a-- 将 a 的值减小 1。

前缀和后缀之间的区别：a++ 在’a’的值递增之前返回’a’的值，而 ++a 首先将’a’的值增加 1，然后返回递增值”a”。

#include <stdio.h>
int main()
{
    int a = 15, b = 15, c = 15, d = 15;
    printf("\nvalue of a++ = %d", a++);
    printf("\nvalue of ++b = %d", ++b);
    printf("\nvalue of c-- = %d", c--);
    printf("\nvalue of --d = %d", --d);
    return 0;
}

sizeof 运算符

sizeof() 运算符用于返回变量的大小。

#include <stdio.h>
int main()
{
    int i = 6;
    int j;
    char c;
    float f;
    double d;
    printf("size of integer variable i = %d", sizeof(i));
    printf("\nsize of integer variable j = %d", sizeof(j));
    printf("\nsize of character variable = %d", sizeof(c));
    printf("\nsize of float variable = %d", sizeof(f));
    printf("\nsize of double variable = %d", sizeof(d));
    return 0;
}

决策与条件

很多时候，我们需要先查看条件，然后做出决定。这种决策方式是通过在 C 中使用 if 语句完成的。

if 语句

#include <stdio.h>
int main()
{
    int a = 5;
    int b = 5;
    if (a == b)
    {
        printf("a and b are equal\n");
    }
    return 0;
}

if…else 语句

#include <stdio.h>
int main()
{
    int a = 5;
    int b = 8;
    if (a == b)
    {
        printf("a and b are equal\n");
    }
    else
    {
        printf("a and b are not equal\n");
    }
    return 0;
}

else if 语句

#include <stdio.h>
int main()
{
    int a = 10;
    if(a == 30)
    {
        printf("It is 30\n");
    }
    else if(a == 10)
    {
        printf("It is 10\n");
    }
    else if(a == 5)
    {
        printf("It is 5\n");
    }
    return 0;
}

如果有一条语句在 if、else 或者 else if 里面，我们可以跳过括号（{}）。

if/else 嵌套

#include <stdio.h>
int main()
{
    int a = 8;
    int b = 4;
    int c = 10;
    if (a > b)
    {
        if (a > c)
        {
            printf("a is the greatest number.\n");
        }
    }
    return 0;
}

三元运算符

条件 ? expression1 : expression2 ;

#include <stdio.h>
int main()
{
    int age;
    printf("Enter age");
    scanf("%d", &age);
    (age > 18) ? printf("eligible to vote\n") : printf("not eligible to vote\n");
    return 0;
}

循环

while 循环

#include <stdio.h>
int main()
{
    int a = 1;
    while (a <= 10)
    {
        printf("Hello World\n");
        a++;
    }
    return 0;
}

for 循环

for (初始化; 条件; 改变)
{
    语句
}

#include <stdio.h>
int main()
{
    int a;
    for (a = 1; a <= 10; a++)
    {
        printf("Hello World\n");
    }
    return 0;
}

嵌套循环

#include <stdio.h>
int main()
{
    int i;
    int j;
    for(i = 12; i <= 14; i++)
    {
        printf("Table of %d\n", i);
        for(j = 1; j <= 10; j++)
        {
            printf("%d*%d\t=\t%d\n", i, j, i*j);
        }
    }
    return 0;
}

do…while 循环

#include <stdio.h>
int main()
{
    int a = 1;
    do
    {
        printf("Hello World\n");
        a++;
    }
    while(a <= 10);
    return 0;
}

无限循环

#include <stdio.h>
int main()
{
    for(;;)
    {
        printf("This is not gonna end!\n");
    }
    return 0;
}

要终止无限循环，请按 Ctrl+C。

switch..case 语句

switch(expression)
{
    case constant1:
        statement(s);
        break;
    case constant2:
        statement(s);
        break;
    default:
        statement(s);
}

#include <stdio.h>
int main()
{
    char grade;
    printf("Enter your grade\n");
    scanf(" %c", &grade);
    switch(grade)
    {
        case 'A':
            printf("Excellent!\n");
            break;
        case 'B':
            printf("Outstanding!\n");
            break;
        case 'C':
            printf("Good!\n");
            break;
        case 'D':
            printf("Can do better\n");
            break;
        case 'E':
            printf("Just passed\n");
            break;
        case 'F':
            printf("You failed\n");
            break;
        default:
            printf("Invalid grade\n");
    }
    return 0;
}

break 和 continue

break 用于在需要时中断或终止循环。continue 语句将控制权传递给条件测试，跳过了循环的其余语句。

#include <stdio.h>
int main()
{
    int a;
    for(a = 1; a <= 10; a++)
    {
        printf("Hello World\n");
        if(a == 2)
        {
            break;
        }
    }
    return 0;
}

#include <stdio.h>
int main()
{
    int a;
    for(a = 1; a <= 10; a++)
    {
        printf("Hello World\n");
        if (a == 2)
        {
            continue;
        }
        printf("a is not 2\n");
    }
    return 0;
}

函数

函数不过是一组代码并命名而来。而且可以随时调用它们而无需一次又一次地编写整个代码。

库函数和用户定义函数

库函数是 C 中的预定义函数，如 printf() 和 scanf()。

用户定义函数：我们还可以在 C 中定义我们自己的函数。

return_type function_name(parameters);

float average(int num1, int num2);

定义函数：

float average(int num1, int num2)
{
    float avg;
    avg = (num1 + num2) / 2.0;
    return avg;
}

调用函数：

#include <stdio.h>

float average(int num1, int num2)
{
    float avg;
    avg = (num1 + num2) / 2.0;
    return avg;
}

int main()
{
    int num1, num2;
    float c;
    printf("Enter first number\n");
    scanf("%d", &num1);
    printf("Enter second number\n");
    scanf("%d", &num2);
    c = average(num1, num2);
    printf("Average is %.2f\n", c);
    return 0;
}

如果一个函数不返回任何东西，则其返回类型为 void。

void display(int n)
{
    printf("Number is %d\n", n);
}

在另一个内部调用一个函数：

#include <stdio.h>

int div_2(int a)
{
    if(a % 2 == 0)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

void div_6(int b)
{
    if(div_2(b) == 1 && b % 3 == 0)
    {
        printf("Yes, the number is divisible by 6.\n");
    }
    else
    {
        printf("No, the number is not divisible by 6.\n");
    }
}

int main()
{
    div_6(12);
    div_6(25);
    return 0;
}

递归：递归是在同一函数内调用一个函数。

#include <stdio.h>

int factorial(int a)
{
    if(a == 0 || a == 1)
    {
        return 1;
    }
    else
    {
        return a * factorial(a - 1);
    }
}

int main()
{
    int n;
    printf("Enter number\n");
    scanf("%d", &n);
    int fact = factorial(n);
    printf("Factorial of %d is %d\n", n, fact);
    return 0;
}

指针

指针指向某个变量，即它存储变量的地址。例如，如果”a”具有地址 9562628，则指向”a”的指针将在其中存储值 9562628。

int a = 44;
int *b;
b = &a;

int *b 表示”b”是一个指向整数的指针。b = &a 意味着”b”现在存储”a”的地址。

#include <stdio.h>
int main()
{
    int a = 10;
    int *p;
    p = &a;
    printf("p = %u\n", p);
    printf("*p = %d\n", *p);
    printf("&p = %u\n", &p);
    printf("*&p = %u\n", *&p);
    return 0;
}

将指针传递给函数：

#include <stdio.h>
void swap(int *a, int *b)
{
    int t;
    t = *a;
    *a = *b;
    *b = t;
}

int main()
{
    int num1, num2;
    printf("Enter first number\n");
    scanf("%d", &num1);
    printf("Enter second number\n");
    scanf("%d", &num2);
    swap(&num1, &num2);
    printf("First number : %d\n", num1);
    printf("Second number : %d\n", num2);
    return 0;
}

数组

简单来说，数组就是一个集合。在 C 语言中，它是一组相似类型的数据。

声明数组

int n[6];

int n[] = {2, 3, 15, 8, 48, 13};

数组索引从 0 开始。n[0] 是第一个元素。

#include <stdio.h>
int main()
{
    int marks[3];
    float average;

    printf("Enter marks of first student\n");
    scanf("%d", &marks[0]);

    printf("Enter marks of second student\n");
    scanf("%d", &marks[1]);

    printf("Enter marks of third student\n");
    scanf("%d", &marks[2]);

    average = (marks[0] + marks[1] + marks[2]) / 3.0;
    printf("Average marks : %f\n", average);

    return 0;
}

指向数组的指针

数组的名称是指向数组第一个元素的指针。

#include <stdio.h>
int main()
{
    float n[5] = {20.4, 30.0, 5.8, 67, 15.2};
    float *p;
    int i;
    p = n;
    for (i = 0; i < 5; i++)
    {
        printf("*(p + %d) = %f\n", i, *(p + i));
    }
    return 0;
}

在函数中传递数组

#include <stdio.h>
float average(float a[], int size)
{
    int i;
    float avg, sum = 0;
    for(i = 0; i < size; i++)
    {
        sum += a[i];
    }
    avg = sum / size;
    return avg;
}

int main()
{
    int size, j;
    printf("Enter the size of array");
    scanf("%d", &size);
    float b, n[size];
    for(j = 0; j < size; j++)
    {
        printf("Value of n[%d] : ", j);
        scanf("%f", &n[j]);
    }
    b = average(n, size);
    printf("Average of numbers=%.2f\n", b);
    return 0;
}

使用指针将数组传递给函数：

#include <stdio.h>
display(int *p)
{
    int i;
    for(i = 0; i < 8; ++i)
    {
        printf("n[%d] = %d\n", i, *p);
        p++;
    }
}

int main()
{
    int n[] = {1, 2, 3, 4, 5, 6, 7, 8};
    display(n);
    return 0;
}

二维数组

二维数组是数组的数组。

int board[3][3] = {
    {'1','2','3'},
    {'4','5','6'},
    {'7','8','9'}
};

数组

简单来说，数组就是一个集合。

同样在 C 语言中，它是一组相似类型的数据，可以是 int，float，double，char（字符串）等。所有数据类型必须相同。例如，我们不能有一个数组，其中一些数据是整数，有些数据是浮点数。

为什么要数组？

假设我们需要在一个班级中存储 50 名学生的分数并计算平均分数。因此，声明 50 个单独的变量将完成这项工作，但是没有程序员愿意这样做。数组就派上用场了。

如何声明数组

数据类型 array_name[array_size];

例如，采用整数 n 的数组：

int n[6];

n[ ] 用于表示数组 n。这意味着 n 是一个数组。

因此，int n[6] 意味着 n 是 6 个整数的数组。在这里，6 是数组的大小，即数组 n 中有 6 个元素。

我们需要给出数组的大小，因为编译器需要在内存中分配空间，而这在不知道大小的情况下是不可能的。编译器借助数组中元素的数量和数组中存在的数据类型的大小来确定数组所需的大小。

在这里 int n[6] 将空间分配给 6 个整数。

我们还可以通过其他方法声明数组：

int n[] = {2, 3, 15, 8, 48, 13};

在这种情况下，我们要同时声明并为数组分配值。此处，无需指定数组大小，因为编译器从 {2,3,15,8,48,13} 中获取它。

数组索引

数组的每个元素都有其索引。我们使用其索引访问数组的任何元素。

上述数组的图片视图为：

0、1、2、3、4 和 5 是索引。就像它们是数组的 6 个不同元素的标识一样。索引始终从 0 开始。因此，数组的第一个元素的索引为 0。

数组的索引从 0 开始。

我们使用其索引访问数组的任何元素，并且语法如下：

array_name[index]

例如，如果数组的名称为 n，那么我们要编写访问第一个元素（索引为 0 的元素）n[0]。

在这里：

• n[0] 是 2
• n[1] 是 3
• n[2] 是 15
• n[3] 是 8
• n[4] 是 48
• n[5] 是 13

n[0]、n[1] 等等。就像我们使用的是任何其他变量，我们可以设置值作为 n[0] = 5; 像我们这样做与任何其他变量（x = 5;，y = 6; 等）。

给数组赋值

通过编写 int n[] = {2,4,8};，我们可以同时声明并向数组分配值，从而对其进行初始化。

但是，当我们声明类似的数组时 int n[3];，我们需要分别为其分配值。因为 int n[3]; 肯定会在内存中分配 3 个整数的空间，但是该空间中没有整数。

要对其进行初始化，请为数组的每个元素分配一个值。

n[0] = 2;
n[1] = 4;
n[2] = 8;

就像我们声明一些变量，然后为它们分配值一样。

int x, y, z;
x = 2;
y = 4;
z = 8;

因此，将值分配给数组元素的第一种方法是在声明数组时进行：

int n[] = {2, 4, 8};

第二种方法是先声明数组，然后为它的元素赋值：

int n[3];
n[0] = 2;
n[1] = 4;
n[2] = 8;

您可以通过将对待 n[0]、n[1] 和 n[2] 与之前使用的不同变量类似来理解这一点。

就像变量一样，数组也可以是任何其他数据类型。

float f[] = {1.1, 1.4, 1.5};

在这里，f 是一个浮点数数组。

首先，让我们看一下计算 3 个学生的平均分数的示例。在此，marks[0] 代表第一个学生的成绩，marks[1] 代表第二个学生的成绩，marks[2] 代表第三个学生的成绩。

#include <stdio.h>

int main()
{
    int marks[3];
    float average;

    printf("Enter marks of first student\n");
    scanf("%d", &marks[0]);

    printf("Enter marks of second student\n");
    scanf("%d", &marks[1]);

    printf("Enter marks of third student\n");
    scanf("%d", &marks[2]);

    average = (marks[0] + marks[1] + marks[2]) / 3.0;
    printf("Average marks : %f\n", average);

    return 0;
}

在这里，您看到了一个数组的工作示例，我们对待数组元素的方式与对待普通变量的方式完全相似。&marks[0]、&marks[1] 和 &marks[2] 分别表示 marks[0]、marks[1] 和 marks[2] 的地址。

在上面的示例中，应牢记两点：

• 平均值应为 float 类型，因为整数的平均值也可以为 float。
• 其次，在取平均值时，将数字的总和除以 3.0 而不是 3，否则平均值将作为整数而不是浮动的。

我们也可以使用 for 循环，如下面的示例所示：

#include <stdio.h>

int main()
{
    int n[10]; /* declaring n as an array of 10 integers */
    int i, j;
    /* initializing elements of array n */
    for (i = 0; i < 10; i++)
    {
        printf("Enter value of n[%d]", i);
        scanf("%d", &n[i]);
    }
    /* printing the values of elements of array */
    for (j = 0; j < 10; j++)
    {
        printf("n[%d] = %d\n", j, n[j]);
    }
    return 0;
}

上面的代码只是让您熟悉对数组使用循环，因为您将在以后做很多次。

代码很简单，因为数组的索引从 0 开始到 9（对于 10 个元素），所以 i 和 j 从 0 开始。因此，i 和 j 上升到 9 而不是 10（i < 10 和 j < 10）。因此，在代码 n[i] 中将是 n[1]、n[2]、…、n[9]，事情将因此而去。

如果我们声明了一个具有一定数组大小的数组，并且仅对该数组的某些元素分配了值，则其他元素的值将自动分配为零。

假设我们声明并初始化一个数组为：

int n[5] = {12, 13, 5};

这意味着 n[0] = 12，n[1] = 13 和 n[2] = 5，其余所有元素均为零，即 n[3] = 0 和 n[4] = 0。

同样：

int n[5];
n[0] = 12;
n[1] = 13;
n[2] = 5;

在上面的代码中，n[0]、n[1] 和 n[2] 分别初始化为 12、13 和 5。因此，n[4] 和 n[5] 均为 0。

数组分配连续的内存。因此，如果整数数组的第一个元素的地址为 223698688，则第二个元素的地址将为 223698692（223698688 + 4（4 是一个整数的大小）），第三个元素的地址将为 223698696，依此类推。这意味着数组的所有元素的内存都分配在一起并且是连续的。

指向数组的指针

到目前为止，我们已经看到了如何声明和初始化数组。现在，我们将看到如何也可以拥有指向数组的指针。

众所周知，指针是一个变量，其值是其他变量的地址，即，如果变量 y 指向另一个变量 x，则意味着变量 y 的值就是 x。

同样，如果我们说变量 y 指向数组 n，则意味着 y 的值是数组第一个元素的地址，即 n[0]。这意味着数组的指针是其第一个元素的指针。

数组的名称是指向数组第一个元素的指针。

如果 p 是指向数组 age 的指针，则意味着 p（或 age）指向 age[0]。

int age[50];
int *p;
p = age;

上面的代码为 p 分配了数组 age 的第一个元素的地址。

现在，由于 p 指向数组 age 的第一个元素，因此 *p 是数组的第一个元素的值。

由于 *p 表示第一个数组元素，因此 *(p + 1) 和 *(p + 2) 分别表示第二个元素和第三个元素，依此类推。

因此，*p 是 age[0]，*(p + 1) 是 age[1]，*(p + 2) 是 age[2]。

类似地，*age 是 age[0]（年龄值），*(age + 1) 是 age[1]（年龄+1 值），*(age + 2) 是 age[2]（年龄+2 值）等等。

这就是所有指向数组的指针。

现在让我们看一些例子：

#include <stdio.h>

int main()
{
    float n[5] = {20.4, 30.0, 5.8, 67, 15.2}; /* declaring n as an array of 5 floats */
    float *p; /* p as a pointer to float */
    int i;
    p = n; /* p now points to array n */
    /* printing the values of elements of array */
    for (i = 0; i < 5; i++)
    {
        printf("*(p + %d) = %f\n", i, *(p + i)); /* *(p+i) means value at (p+0),(p+1)...*/
    }
    return 0;
}

因为 p 指向数组的第一个元素，所以 *p 或 *(p+0) 表示 p[0] 处的值或 p 的第一个元素处的值。类似地，*(p+1) 表示 p[1] 处的值。并且分别 *(p+3) 和 *(p+4) 代表 p[3] 和 p[4]。因此，事情就已经印出来了。

以上示例总结了以上概念。现在，让我们打印数组的地址以及数组的各个元素：

#include <stdio.h>

int main()
{
    int n[4] = {20, 30, 5, 67}; /* declaring n as an array of 4 integers */
    int *p; /* a pointer */
    int i;
    p = n; /* p is pointing to array n */
    /* printing the address of array */
    printf("Address of array n[4] = %u\n", p); /* p points to array means store the address of the first element of array */
    /* printing the addresses of elements of array */
    for (i = 0; i < 4; i++)
    {
        printf("Address of n[%d] = %u\n", i, &n[i]);
    }
    return 0;
}

您已经注意到 n 和 p 的第一个元素的地址相同，这意味着我没有说谎！

您也可以使用 (p + 1)、(p + 2) 和 (p + 3) 打印其他元素的地址。

在函数中传递整个数组

在 C 语言中，我们可以将数组的元素或整个数组作为参数传递给函数。

首先让我们传递单个数组元素以起作用：

#include <stdio.h>

void display(int a)
{
    printf("%d\n", a);
}

int main()
{
    int n[] = {20, 30, 23, 4, 5, 2, 41, 8};
    display(n[2]);
    return 0;
}

在函数中传递整个数组

我们还可以通过将数组名称作为参数来传递整个数组给一个函数。是的，诀窍是我们将传递数组的地址，即数组的第一个元素的地址。因此，通过拥有第一个元素的指针，我们可以像上面的示例中那样获得整个数组。

让我们看一个例子来理解它：

#include <stdio.h>

float average(float a[])
{
    int i;
    float avg, sum = 0;
    for (i = 0; i < 8; ++i)
    {
        sum += a[i];
    }
    avg = sum / 8;
    return avg;
}

int main()
{
    float b, n[] = {20.6, 30.8, 5.1, 67.2, 23, 2.9, 4, 8};
    b = average(n);
    printf("Average of numbers=%.2f\n", b);
    return 0;
}

average(float a[]) → 该函数正在获取一个 float 数组。并且该功能的其余部分正在相应地执行。

b = average(n) → 您在此处应注意的一件事是，我们传递了 n。如前所述，n 是指向第一个元素的指针或指向数组的指针 n[]。因此，我们实际上已经传递了指针。

在上面的示例中，我们计算了数组元素的平均值，我们已经知道数组的大小，即 8。

假设我们从用户那里获取数组的大小。在这种情况下，数组的大小是不固定的。在这里，我们需要将数组的大小作为第二个参数传递给函数。

#include <stdio.h>

float average(float a[], int size)
{
    int i;
    float avg, sum = 0;
    for (i = 0; i < size; i++)
    {
        sum += a[i];
    }
    avg = sum / size;
    return avg;
}

int main()
{
    int size, j;
    printf("Enter the size of array");
    scanf("%d", &size);
    float b, n[size];
    for (j = 0; j < size; j++)
    {
        printf("Value of n[%d] : ", j);
        scanf("%f", &n[j]);
    }
    b = average(n, size);
    printf("Average of numbers=%.2f\n", b);
    return 0;
}

该代码与上一个代码相似，除了我们显式传递了数组的大小。

我们还可以使用指针将数组传递给函数。让我们看看如何：

#include <stdio.h>

display(int *p)
{
    int i;
    for (i = 0; i < 8; ++i)
    {
        printf("n[%d] = %d\n", i, *p);
        p++;
    }
}

int main()
{
    int n[] = {1, 2, 3, 4, 5, 6, 7, 8};
    display(n);
    return 0;
}

在上面的示例中，将数组的地址（即 n[0] 的地址）传递给函数的形式参数。

display(int *p) → 这意味着函数 display 正在使用指向整数的指针。

现在我们根据函数 display 的要求传递了整数指针，即数组 n[] 的指针。

由于 p 是函数 display 中数组 n[] 的地址，即数组第一个元素（n[0]）的地址，因此 *p 表示 n[0] 的值。在 for 循环功能中，p++ 将 p 的值增加 1。因此，当 i = 0 时，将打印 *p 的值。然后 p++ 将 *p 增加到 *(p + 1)，在第二个循环中，*(p + 1) 的值，即 n[1] 也被打印出来。当 *(p + 7) 的值（即 n[7]）被打印时，此循环一直持续到 i = 7。

二维数组

如果数组是二维的怎么办？

是的，二维数组也存在，通常称为 matrix。这些由行和列组成。

在进入其应用程序之前，让我们首先了解如何声明和初始化 2D 数组。

二维数组声明

与一维数组相似，我们定义如下的二维数组：

int a[2][4];

这里，a 是整数的 2D 阵列，其由 2 行和 4 列。

它就像是：

现在让我们看一下如何初始化二维数组。

将值分配给二维数组

与一维数组相同，我们也可以通过 2 种方式为二维数组的元素分配值。

在第一种方法中，只需为数组的元素分配一个值。如果未将任何值分配给任何元素，则假定其值为零。

假设我们声明了一个二维数组 a[2][2]。现在，我们需要为其元素分配值。

int a[2][2];
a[0][0] = 1;
a[0][1] = 2;
a[1][0] = 3;
a[1][1] = 4;

第二种方法是与一维数组同时声明和分配值：

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

此处，a[0][0] 的值为 1，a[0][1] 为 2，a[0][2] 为 3，a[1][0] 为 4，a[1][1] 为 5，a[1][2] 为 6。

我们也可以将以上代码编写为：

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

在声明时将值分配给数组时，不需要在一维数组中指定大小，但是在 2D 数组中，我们至少需要给出第二维的值。

让我们考虑在声明时将值分配给数组的不同情况：

int a[2][2] = {1, 2, 3, 4}; /* 有效 */
int a[][2] = {1, 2, 3, 4}; /* 有效 */
int a[2][] = {1, 2, 3, 4}; /* 无效 */
int a[][] = {1, 2, 3, 4}; /* 无效 */

为什么要使用二维数组

假设我们有 3 个学生，每个学生都在学习 2 个主题（主题 1 和主题 2），并且我们必须在这 3 个学生的两个主题中都显示分数。让我们输入用户的标记。

#include <stdio.h>

int main()
{
    float marks[3][2];
    int i, j;
    for (i = 0; i < 3; i++)
    {
        /* input of marks from the user */
        printf("Enter marks of student %d\n", (i + 1));
        for (j = 0; j < 2; j++)
        {
            printf("Subject %d\n", (j + 1));
            scanf("%f", &marks[i][j]);
        }
    }
    /* printing the marks of students */
    for (i = 0; i < 3; i++)
    {
        printf("Marks of student %d\n", (i + 1));
        for (j = 0; j < 2; j++)
        {
            printf("Subject %d : %f\n", (j + 1), marks[i][j]);
        }
    }
    return 0;
}

这就像：

字符串

数学和数学，代码与代码，但是在现实世界中，我们必须处理单词，句子等。C 语言中是否有任何东西可以处理这些类型的事物？答案是肯定的，它们被称为 string。

我们可以将字符串视为字符数组，例如 Sam 是字符串。

因此，Sam 是字符 S、a、m 和 \0 的数组。

查看第 3 个索引处的字符。它代表空字符。ASCII 值的 \0 是 0 和的正常 0 是 48。它表示字符串的终止（结束）。

我们将字符串声明为：

char name[] = "Sam";

如您所见，字符串（char name[]）的语法还告诉我们它是一个字符数组。

我们总是在 "" 中放置一个字符串，在 '' 中放置一个字符。

我们还可以使用字符声明一个字符串变量，如下所示：

char name[] = {'S', 'a', 'm', '\0'};

让我们看两个示例，分别显示不带 for 循环和带循环的字符串。

#include <stdio.h>

int main()
{
    char str[] = "Hello";
    printf("%s\n", str);
    return 0;
}

请注意，%s 用于字符串。

在上面的示例中，我们一次打印了整个字符串。现在，我们将看到相同的示例，但使用 for 循环打印单个字符。

#include <stdio.h>

int main()
{
    char str[] = "Hello";
    int i;
    for (i = 0; i < 6; i++)
    {
        printf("%c\n", str[i]);
    }
    return 0;
}

在第一个示例中，我们打印了字符串，并为此 %s 与 printf 函数一起使用。而在第二个示例中，我们每次只打印单个字符，因此我们使用 %c 该 printf 函数。

现在，让我们看一个从用户输入字符串的示例：

#include <stdio.h>

int main()
{
    char name[25];
    printf("Enter your name\n");
    scanf("%s", name);
    printf("Your name is %s\n", name);
    return 0;
}

您一定想知道在声明名称数组时将数组大小写为 25 的原因。这样做是因为我们不知道用户将输入的名称的长度。如果在上面的示例中，我们将数组的大小指定为 2，则字符串变量将不会采用输入，因为输入的大小大于数组的大小。因此，为了安全起见，请采用大于假定的输入大小的数组大小。

在使用 scanf 从用户那里获取字符串时，请勿在字符串名称前使用 &，因为在 name[25] 中，name 本身就是指向 name[25] 的指针。

scanf 从用户到字符串变量仅需要一个词。它以任何空白结尾。尝试在空格后写点什么，这只会占用第一个单词。

例如，如果在上面的示例中，我们输入 Sam Brad 作为名称，则输出将仅是 Sam，因为 scanf 仅考虑一个单词并在第一个单词之后终止。

如何获取多行字符串

#include <stdio.h>

int main()
{
    char name[25];
    printf("Enter your name\n");
    gets(name);
    printf("Your name is ");
    puts(name);
    return 0;
}

我们可以使用 gets 和 puts 接受输入并给出包含多个单词的字符串的输出，其中 gets 用于获取用户的字符串输入，而 puts 用于显示字符串。

考虑以下示例。

如果您收到关于 gets 的任何警告，请忽略它。

要进行打印，您也可以使用 printf 代替 puts。

您也可以使用 scanf("%[^\n]s", name); 用于获取多字串。

指针和字符串

字符串也可以使用指针声明。让我们考虑一个例子：

#include <stdio.h>

int main()
{
    char name[] = "Sam";
    char *p;
    p = name; /* for string, only this declaration will store its base address */
    while (*p != '\0')
    {
        printf("%c", *p);
        p++;
    }
    return 0;
}

在上面的示例中，p 存储 name[0] 的地址，因此 *p 的值等于 name[0] 的值，即 S。因此，在 while 循环中，第一个字符被打印出来，并将 p++ 的值加 1，以便现在 p + 1 指向 name[1]。这一直持续到指针到达字符串的末尾，即，在 *p 等于 \0 之前。

将字符串传递给函数

这与我们处理其他阵列相同。唯一的区别是这是一个字符数组。而已！

让我们来看一个例子：

#include <stdio.h>

void display(char ch[])
{
    printf("String :");
    puts(ch); /* display string */
}

int main()
{
    char arr[30];
    printf("Enter string\n");
    gets(arr); /* input string from user */
    display(arr);
    return 0;
}

预定义的字符串函数

我们可以执行不同类型的字符串功能，例如连接 2 个字符串，将一个字符串与另一个字符串进行比较或找到字符串的长度。让我们看一下这些函数的列表。

这些函数在 string.h 头文件中定义，因此我们需要通过编写以下代码在代码中包含该头文件：

#include <string.h>

我们将看到一些例子 strlen、strcpy、strcat 和 strcmp 因为这些是最常用的。

strlen(s1) 计算字符串 s1 的长度。空格也以字符串的长度计算。

#include <stdio.h>
#include <string.h>

int main()
{
    char name[] = "Hello";
    int len1, len2;
    len1 = strlen(name);
    len2 = strlen("Hello World");
    printf("length of %s = %d\n", name, len1);
    printf("length of %s = %d\n", "Hello World", len2);
    return 0;
}

在计算字符串的长度时，strlen 不会计数 \0。

strcpy(s1, s2) 将第二个字符串 s2 复制到第一个字符串 s1。

#include <string.h>
#include <stdio.h>

int main()
{
    char s2[] = "Hello";
    char s1[10];
    strcpy(s1, s2);
    printf("Source string = %s\n", s2);
    printf("Target string = %s\n", s1);
    return 0;
}

strcat(s1, s2) 将第二个字符串 s2 连接（连接）到第一个字符串 s1。

#include <stdio.h>
#include <string.h>

int main()
{
    char s2[] = "World";
    char s1[20] = "Hello";
    strcat(s1, s2);
    printf("Source string = %s\n", s2);
    printf("Target string = %s\n", s1);
    return 0;
}

请注意，在上面的示例中，我们将数组大小指定为 s1，因为我们要向其中添加另一个字符串的字符。给定的数组大小应大于或等于串联后的字符串数组的大小。

strcmp(s1, s2) 比较两个字符串，找出它们是否相同。它逐字符比较两个字符串，直到不匹配为止。如果两个字符串相同，则返回 0。如果不是，则返回第一个非匹配字符对的 ASCII 值之间的差。

#include <stdio.h>
#include <string.h>

int main()
{
    char s1[] = "Hello";
    char s2[] = "World";
    int i, j;
    i = strcmp(s1, "Hello");
    j = strcmp(s1, s2);
    printf("%d \n %d\n", i, j);
    return 0;
}

二维字符数组

与整数和其他数据类型的 2D 数组相同，我们也有 2D 字符数组。

例如，我们可以写：

char names[4][10] = {
    "Andrew",
    "Kary",
    "Brown",
    "Lawren"
};

C语言中的预处理器

预处理程序在进入编译器之前会处理我们的程序。

如何声明？

预处理程序指令以哈希符号（#）开头。预处理程序指令是预处理程序命令。

最常见的预处理器指令是 #include。

这 #include 是一个预处理程序指令，它使诸如 stdio.h 的头文件对我们可用。

让我们再举一个预处理器指令的例子：

#define PI 3.14

这 #define 是预处理程序指令。它用于定义某些内容，例如此处我们已定义 PI 为 3.14。因此，在进入编译器之前，如果 PI 出现在程序中的任何位置，它将被 3.14 替换。

它与普通变量不同，因为普通变量是在编译期间处理的。但是，定义中的任何内容 #define 在编译之前都会被其值替换。

同样，#include 在开始编译之前，链接任何头文件。

以下是一个 C 程序来查找圆的区域：

#include <stdio.h>
#define PI 3.14

int main()
{
    int radius;
    float area;
    printf("Enter radius of circle\n");
    scanf("%d", &radius);
    area = PI * radius * radius;
    printf("Area of circle is %.2f\n", area);
    return 0;
}

您在这里应该唯一了解的是，即使在编译之前，只要程序中有 PI，PI 就会被 3.14 替换。因此，PI * radius * radius 将是 3.14 * radius * radius。

带参数的宏

#define 也可以用来编写宏定义，如下所示。宏也类似于函数，但与此有所不同。他们也可以争论。让我们看一个示例，以了解如何使用它们。

#define area(r) (3.14 * r * r)

让我们看一个使用宏打印圆形区域的示例：

#include <stdio.h>
#define area(r) (3.14 * r * r)

int main()
{
    int radius;
    float area;
    printf("Enter radius of circle\n");
    scanf("%d", &radius);
    area = area(radius);
    printf("Area of circle is %.2f\n", area);
    return 0;
}

我们定义了一个宏 area，它接受一个参数 r。所以，当我们叫 area(radius)，它得到了替换 3.14 * radius * radius（如 area(r) 为 3.14 * r * r）。

与 area(x) 在编译过程中调用的函数不同，我们代码中的任何地方，在编译之前都会被直接替换 3.14 * x * x。

因此，以上代码等效于：

#include <stdio.h>

int main()
{
    int radius;
    float area;
    printf("Enter radius of circle\n");
    scanf("%d", &radius);
    area = 3.14 * radius * radius;
    printf("Area of circle is %.2f\n", area);
    return 0;
}

让我们将宏与函数进行比较

我们刚刚看到了使用宏打印圆形区域的示例。现在，让我们看看使用函数的相同示例。

#include <stdio.h>

float CircleArea(int r)
{
    float a;
    a = 3.14 * r * r;
    return a;
}

int main()
{
    int radius;
    float area;
    printf("Enter radius of circle\n");
    scanf("%d", &radius);
    area = CircleArea(radius);
    printf("Area of circle is %.2f\n", area);
    return 0;
}

让我们看一下宏和函数之间的基本区别：

• 第一个区别是宏用其值替换代码（因为它用 (3.14 * r * r) 替换了 area(r)）。因此，每次都会为代码分配一些空间。这意味着每次出现 area(r) 时，都会在内存中分配空间。但这不是函数的情况。
• 其次，函数调用需要一些时间，但是在实际程序之前定义了宏。因此，宏更快。

结构

我们已经处理了数组。数组用于存储相似类型的数据。您是否曾经想过是否有任何方法可以存储不同的数据？

答案是肯定的。我们使用结构来存储不同类型的数据。例如，您是一名学生。您的名字是一个字符串，您的电话号码和 roll_no 是整数。因此，这里的姓名、地址和电话号码是这些不同类型的数据。在这里，结构出现在图片中。

定义结构

结构的语法为：

struct structure_name
{
    数据类型 member-1;
    数据类型 member-2;
    数据类型 member-3;
    数据类型 member-4;
};

在我们的例子中，我们将该结构命名为 student。在我们的案例中，该结构的成员为 name、roll_no 和 phone_number。

因此，我们的结构如下所示：

struct student
{
    int roll_no;
    char name[30];
    int phone_number;
};

结构变量声明

正如我们声明 int、char 等类型的变量一样，我们也可以声明结构的变量。

假设我们要存储三个学生的名册编号、姓名和电话号码。为此，我们将定义一个名称为 student 的结构（如上所述），然后声明结构 student 的三个变量，分别为 p1、p2 和 p3（分别代表三个学生）。

struct student
{
    int roll_no;
    char name[30];
    int phone_number;
};

main()
{
    struct student p1, p2, p3;
}

在此，p1、p2 和 p3 是结构 student 的变量。

我们还可以在定义结构时声明结构变量，如下所示：

struct student
{
    int roll_no;
    char name[30];
    int phone_number;
} p1, p2, p3;

现在，让我们看看如何输入每个学生的详细信息，例如 roll_no、姓名和电话号码。

假设我们要为第一个学生分配一个卷号。为此，我们需要访问第一个学生的卷号。我们通过写来做到这一点：

p1.roll_no = 1;

这意味着使用点（.）在结构中使用变量。p1.roll_no 可以理解为 p1 的 roll_no。

如果要为变量分配任何字符串值，将使用 strcpy，如下所示：

strcpy(p1.name, "Brown");

现在，让我们存储所有三个学生的详细信息：

#include <stdio.h>
#include <string.h>

int main()
{
    struct student
    {
        int roll_no;
        char name[30];
        int phone_number;
    };
    struct student p1 = {1, "Brown", 123443};
    struct student p2, p3;
    p2.roll_no = 2;
    strcpy(p2.name, "Sam");
    p2.phone_number = 1234567822;
    p3.roll_no = 3;
    strcpy(p3.name, "Addy");
    p3.phone_number = 1234567844;
    printf("First Student\n");
    printf("roll_no : %d\n", p1.roll_no);
    printf("name : %s\n", p1.name);
    printf("phone_number : %d\n", p1.phone_number);
    printf("Second Student\n");
    printf("roll_no : %d\n", p2.roll_no);
    printf("name : %s\n", p2.name);
    printf("phone_number : %d\n", p2.phone_number);
    printf("Third Student\n");
    printf("roll_no : %d\n", p3.roll_no);
    printf("name : %s\n", p3.name);
    printf("phone_number : %d\n", p3.phone_number);
    return 0;
}

始终使用 strcpy 将字符串值分配给字符串变量。

原因是在 C 语言中，我们不能将两个字符串（即字符数组）等价。如果我们写了 p1.name = "Brown";，那会给出一个错误。因此，通过编写 strcpy(p1, "Brown")，我们将字符串 Brown 复制到字符串变量 p1.name。

struct student p1 = {1, "Brown", 123443}; → 这也是我们初始化结构的方法之一。在下一行中，我们只是给变量赋值并打印出来。

结构使用连续的内存位置。

结构数组

我们还可以制作结构数组。在结构的第一个示例中，我们存储了 3 个学生的数据。现在假设我们需要存储 100 个此类孩子的数据。声明 100 个单独的结构变量绝对不是一个好选择。为此，我们需要创建一个结构数组。

让我们看一个 5 个学生的例子：

#include <stdio.h>

struct student
{
    int roll_no;
    char name[30];
    int phone_number;
};

int main()
{
    struct student stud[5];
    int i;
    for (i = 0; i < 4; i++)
    {
        printf("Student %d\n", i + 1);
        printf("Enter roll no. :\n");
        scanf("%d", &stud[i].roll_no);
        printf("Enter name :\n");
        scanf("%s", stud[i].name);
        printf("Enter phone number :\n");
        scanf("%d", &stud[i].phone_number);
    }
    for (i = 0; i < 4; i++)
    {
        printf("Student %d\n", i + 1);
        printf("Roll no. : %d\n", stud[i].roll_no);
        printf("Name : %s\n", stud[i].name);
        printf("Phone no. : %d\n", stud[i].phone_number);
    }
    return 0;
}

在这里，stud[0] 存储第一个学生的信息，stud[1] 第二个以此类推。

我们也可以一次复制两个结构：

#include <stdio.h>
#include <string.h>

int main()
{
    struct student
    {
        int roll_no;
        char name[30];
        int phone_number;
    };
    struct student p1 = {1, "Brown", 123443};
    struct student p2;
    p2 = p1;
    printf("roll_no : %d\n", p2.roll_no);
    printf("name : %s\n", p2.name);
    printf("phone_number : %d\n", p2.phone_number);
    return 0;
}

我们只写了 p2 = p1 就是这样。p1 的所有元素都已复制到 p2。

指向结构的指针

就像我们有用于 int、char 和其他数据类型的指针一样，我们也有指向结构的指针。这些指针称为结构指针。

现在，如何定义一个指向结构的指针？答案如下：

struct structure_name
{
    数据类型 member-1;
    数据类型 member-1;
    数据类型 member-1;
    数据类型 member-1;
};

main()
{
    struct structure_name *ptr;
}

让我们考虑一个使用结构指针的示例：

#include <stdio.h>

int main()
{
    struct student
    {
        char name[30];
        int roll_no;
    };
    struct student stud = {"sam", 1};
    struct student *ptr;
    ptr = &stud;

    printf("%s %d\n", stud.name, stud.roll_no);
    printf("%s %d\n", ptr->name, ptr->roll_no);

    return 0;
}

struct stud *ptr; → 我们已经声明 ptr 是结构 student 的指针。

ptr = &stud; → 我们使指针 ptr 指向结构 stud。

这是我们到目前为止所做的相同的事情。现在，来到 printf。

printf("%s %d\n", ptr->name, ptr->roll_no); → 是的，我们用来 -> 从其指针访问结构。就像我们在结构中使用（.）一样，我们在指针中使用 ->。

将结构传递给函数

我们还可以将结构传递给函数。

我们可以通过两种方法将结构传递给函数：

• 值传递
• 通过引用

值传递：在此，我们将结构变量作为参数传递给函数。通过一个例子，这将变得清楚。

#include <stdio.h>
#include <string.h>

struct student
{
    int roll_no;
    char name[30];
    int phone_number;
};

void display(struct student st)
{
    printf("Roll no : %d\n", st.roll_no);
    printf("Name : %s\n", st.name);
    printf("Phone no : %d\n", st.phone_number);
}

int main()
{
    struct student s;
    s.roll_no = 4;
    strcpy(s.name, "Ron");
    s.phone_number = 888888;
    display(s);
    return 0;
}

在此示例中，我们使用功能打印卷号、学生的姓名和电话号码。我们首先声明一个名为 student 的结构，其名称为 roll_no、名称和电话为成员，变量为 s。然后，我们将编号、姓名和电话号码的值分配给结构变量 s。就像我们将其他任何变量传递给函数一样，我们也将结构变量 s 传递给函数 display。

现在，在定义函数时，我们传递了变量 s 的副本作为其参数，并在其前面写入了 struct student，因为传递的变量是一个名为 student 的类型结构。最后，在函数中，我们将打印结构变量的名称、编号和电话号码。

通过引用：通过引用传递时，结构变量的地址传递给函数。在这种情况下，如果我们更改函数内部的结构变量，则用于调用该函数的原始结构变量将发生变化。按值调用不是这种情况。

#include <stdio.h>
#include <string.h>

struct student
{
    int roll_no;
    char name[30];
    int phone_number;
};

void display(struct student *st)
{
    printf("Roll no : %d\n", st->roll_no);
    printf("Name : %s\n", st->name);
    printf("Phone no : %d\n", st->phone_number);
}

int main()
{
    struct student s;
    s.roll_no = 4;
    strcpy(s.name, "Ron");
    s.phone_number = 888888;
    display(&s);
    return 0;
}

这种情况与前一种情况相似，唯一的区别是这一次，我们将结构变量的地址传递给了函数。在声明该函数时，我们的函数采用结构 st 的指针。由于指针是一个名为 student 的类型结构变量，因此我们在函数参数的指针名称之前写了 struct student。在函数中，如前所述，我们使用 -> 符号访问了指针的成员。

尝试在两种情况下都更改函数内部变量的值，并查看实际变量的更改。

纸牌游戏

游戏规则：

1. 第一名玩家将选择一张牌。
2. 现在，第二个玩家将选择一张牌。
3. 如果第二位玩家选择的值与第一位玩家选择的卡相同，则将获得积分。
4. 现在，第二位玩家将首先选择一张牌，然后是第一位玩家。
5. 如果第一位玩家选择的值与第二位玩家选择的牌相同，那么他将获得积分。
6. 重复步骤 1 至 5。
7. 得分更高的玩家将赢得比赛。

#include <stdio.h>
#include <string.h>
#include <stdlib.h> //for srand and screen clear and echo off and on
#include <time.h>   //for shuffling

main()
{
    system("clear"); //screen clear
    int i, j, z, k, lp;
    char s, rc;
    struct card
    {
        char *value;
        char *suite;
    };
    struct card temp, list[52], player1[26], player2[26];
    //temp for swaping

    char *value[] = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "K", "Q", "J"};
    char *suite[] = {"diamond", "spade", "heart", "club"};
    for (i = 0; i < 52; i++)
    {
        if (i < 13)
        {
            list[i].suite = *(suite);
            list[i].value = *(value + i);
        }
        else if (i >= 13 && i < 26)
        {
            list[i].suite = *(suite + 1);
            list[i].value = *(value + (i - 13));
        }
        else if (i >= 26 && i < 39)
        {
            list[i].suite = *(suite + 2);
            list[i].value = *(value + (i - 26));
        }
        else if (i >= 39)
        {
            list[i].suite = *(suite + 3);
            list[i].value = *(value + (i - 39));
        }
    }

    do //do while to ask after game play more ?y or n:
    {

        //shuffling

        int n = 52;
        srand(time(NULL));
        for (i = n - 1; i > 0; i--)
        {
            int j = rand() % (i + 1);
            temp.value = list[i].value;
            temp.suite = list[i].suite;
            list[i].value = list[j].value;
            list[i].suite = list[j].suite;
            list[j].value = temp.value;
            list[j].suite = temp.suite;
        }

        //distributing cards
        for (i = 0; i < 52; i++)
        {
            if (i < 26)
            {
                player1[i].value = list[i].value;
                player1[i].suite = list[i].suite;
            }
            else if (i >= 26)
            {
                player2[i - 26].value = list[i].value;
                player2[i - 26].suite = list[i].suite;
            }
        }

        //for cards info
        printf("Player1 has:\t\t\tPlayer2 has:\n");
        for (i = 0; i < 26; i++)
            printf("%d\t%s\t%s\t\t%d\t%s\t%s\n", i + 1, player1[i].value, player1[i].suite, i + 1, player2[i].value, player2[i].suite);

        printf("YOUR INPUT WILL NOT BE VISIBLE\n");

        int p1score = 0, p2score = 0;
        char a[10], b[10];
        char c[10], d[10];

        for (j = 0; j < 26; j++)
        {

            system("stty -echo"); //echo off. input will not be visible

            //even value of i will first let player1 to play and odd value to player 2
            if (j % 2 == 0)
            {

                int x = 0;
                do
                {
                    printf("Player1: type value and suite:");
                    scanf("%s %s", &a[0], &b[0]);

                    for (i = 0; i < 26; i++)
                    {
                        //checking if player owns card or not
                        z = strcmp(player1[i].value, a);
                        k = strcmp(player1[i].suite, b);

                        if (z == 0 && k == 0)
                        {
                            //removing used cards
                            player1[i].value = "\0";
                            player1[i].suite = "\0";

                            x++;
                        }
                    }
                    if (x == 0)
                        printf("ENTER CORRECT CARD\n");
                } while (x == 0);

                int y = 0;
                do
                {
                    printf("Player2: type value and suite:");
                    scanf("%s %s", &c[0], &d[0]);

                    for (i = 0; i < 26; i++)
                    {

                        z = strcmp(player2[i].value, c);
                        k = strcmp(player2[i].suite, d);

                        if (z == 0 && k == 0)
                        {
                            player2[i].value = "\0";
                            player2[i].suite = "\0";

                            y++;
                        }
                    }
                    if (y == 0)
                        printf("ENTER CORRECT CARD\n");
                } while (y == 0);

                //score if player2 choose same card
                lp = strcmp(a, c);

                if (lp == 0)
                    p2score = p2score + 10;
            }
            else //if i is odd first turn to player2
            {

                int y = 0;
                do
                {
                    printf("Player2: type value and suite:");
                    scanf("%s %s", &c[0], &d[0]);

                    for (i = 0; i < 26; i++)
                    {

                        z = strcmp(player2[i].value, c);
                        k = strcmp(player2[i].suite, d);

                        if (z == 0 && k == 0)
                        {
                            player2[i].value = "\0";
                            player2[i].suite = "\0";

                            y++;
                        }
                    }
                    if (y == 0)
                        printf("ENTER CORRECT CARD\n");
                } while (y == 0);

                int x = 0;
                do
                {
                    printf("Player1: type value and suite:");
                    scanf("%s %s", &a[0], &b[0]);

                    for (i = 0; i < 26; i++)
                    {

                        z = strcmp(player1[i].value, a);
                        k = strcmp(player1[i].suite, b);

                        if (z == 0 && k == 0)
                        {
                            player1[i].value = "\0";
                            player1[i].suite = "\0";

                            x++;
                        }
                    }
                    if (x == 0)
                        printf("ENTER CORRECT CARD\n");
                } while (x == 0);

                lp = strcmp(a, c);

                if (lp == 0)
                    p1score = p1score + 10;
            }

            //to see remaining cards

            printf("\nPlayer1 has:\t\t\tPlayer2 has:\n");
            for (i = 0; i < 26; i++)
                printf("%d\t%s\t%s\t\t%d\t%s\t%s\n", i + 1, player1[i].value, player1[i].suite, i + 1, player2[i].value, player2[i].suite);

            printf("\nPLAYER1 SCORE:%d\tPLAYER2 SCORE:%d\n\n", p1score, p2score);

            system("stty echo"); //echo on
        }

        if (p1score > p2score)
            printf("PLAYER1 WINS\n");
        else if (p1score < p2score)
            printf("PLAYER2 WINS\n");
        else
            printf("MATCH DRAWS\n");

        //if one has to play more...do while loop

        printf("want to play more? y or n:");
        scanf(" %c", &s);
    } while (s == 'y');
}

真正的游戏是这样制作的吗？

是的，我们刚刚制作了游戏的结构以将其链接到图形。完成本课程后，您可以扩展知识。

使它变得更好。

使用函数来减少代码的长度，询问用户播放器的数量，或实现您所拥有的其他想法。

文件

当程序运行时，数据在内存中，但是当程序结束或计算机关闭时，数据将会丢失。为了永久保留数据，我们需要将其写入文件。

文件用于存储数据。在本主题中，我们将学习从文件中读取数据以及在文件中写入数据的知识。

首先，让我们看看如何声明文件。

使用文件类型的指针声明文件，如下所示：

FILE *fr;

我们可以对文件执行许多功能。下面列出了其中一些功能。

让我们看看如何将数据写入文件，打开，关闭或读取文件。

打开文件

我们使用 fopen() 功能打开文件或创建新文件。让我们看一下语法的 fopen()。

int main()
{
    FILE *fr;
    fr = fopen("filename", "mode");
    return 0;
}

这里 fr 是指向文件的指针，filename 是我们要打开的文件的名称，也是我们要打开文件 mode 的原因。

模式可以采用以下值：

这些是文本文件的模式。如果必须处理二进制文件，则模式如下：

rb、wb、ab、rb+、wb+、ab+

但是，在我们的教程中，我们将只处理文本文件。

当我们使用 fopen 它时，它将搜索磁盘上的文件，然后将文件加载到称为缓冲区的内存中。我们在关闭之前所做的更改是在缓冲存储器中进行的。进行更改时，可避免通过一次又一次访问磁盘来节省缓冲存储器。

关闭文件

我们使用 fclose() 函数关闭打开的文件。

fclose() 的语法如下：

#include <stdio.h>

int main()
{
    FILE *fr;
    fclose(fr);
    return 0;
}

fclose() 如果文件成功关闭，函数将返回零。如果关闭文件时出现错误，则返回 EOF（文件末尾）。

我们刚刚看到了如何打开和关闭文件。现在，我们将了解如何在文件中进行读写。

读取和写入文件

我们用于读取和写入的功能取决于我们要处理的是字符还是字符串。

例如，函数 fgetc() 和 fputc() 用于读取和写入文件中的字符。同样，函数 fscanf() 和 fprintf() 用于读取和写入文件中的字符串。

让我们来看每个示例，然后逐行了解它。

使用 fgetc() 和 fputc()：fgetc() 读取在打开的文件的字符读模式使用 fopen()。它 EOF 在到达文件末尾时返回。

fputc() 将一个字符写入到打开的文件中写入模式使用 fopen()。

现在，让我们看一个从文件读取的示例：

#include <stdio.h>

int main()
{
    FILE *fr;
    char c;
    fr = fopen("prog.txt", "r");
    while (c != EOF)
    {
        c = fgetc(fr); /* read from file*/
        printf("%c", c); /* display on screen*/
    }
    fclose(fr);
    return 0;
}

在上面的示例中，首先我们以读取模式打开了一个名为 prog.txt 的文件，以便我们可以从该文件读取数据。为此，您的计算机中必须存在 prog.txt。

在 while 循环中，fgetc(fr) 从文件 prog.txt 中读取 c 的值。从文件中读取 c 的整个值并 EOF 达到（文件末尾）后，fclose(fr) 关闭文件。

就如此容易！

我们 fgetc() 使用变量 c 读取文件的内容。在 while 期间，printf 函数在屏幕上打印 c 的值。之后，我们将使用关闭文件 fclose。

使用 fscanf() 和 fprintf()：虽然 getc 和 putc 用于字符，但是我们使用 fscanf() 和 fprintf 来读取和写入字符串到文件。

让我们借助示例来理解：

#include <stdio.h>

int main()
{
    FILE *fr;
    char s[40];
    int n;
    fr = fopen("welcome.txt", "w");
    printf("Enter a string and a number");
    scanf("%s%d", s, &n); /* read from keyboard */
    fprintf(fr, "%s %d", s, n); /* write to file */
    fclose(fr);
    fr = fopen("welcome.txt", "r");
    fscanf(fr, "%s%d", s, &n); /* read from file */
    printf("%s %d", s, n); /* display on screen */
    fclose(fr);
    return 0;
}

在这里，我们首先创建了一个名为 welcome.txt 的文件，并使用 fopen 功能在写入模式下将其打开。然后，我们使用 scanf 功能从键盘输入一个字符串和一个整数值，并将这些值分别存储在变量 s 和 n 中。

然后，fprintf 将字符串和整数值都写入文件。之后，fclose(fr) 关闭文件。

现在，我们将读取文件的内容，然后将其打印在屏幕上。为此，我们将首先使用 fopen 函数以读取模式打开文件。之后，fscanf 函数将读取文件的内容，printf 函数将在屏幕上显示文件的内容。

现在看到该程序将一个文件复制到另一个文件：

#include <stdio.h>

int main()
{
    FILE *s, *t;
    char c;
    s = fopen("source.txt", "r");
    t = fopen("target.txt", "w");
    while (1)
    {
        c = fgetc(s);

        if (c == EOF)
        {
            break;
        }
        else
        {
            fputc(c, t);
        }
    }

    fclose(s);
    fclose(t);
    return 0;
}

fputc(c, t) 将存储在 c 中的字符放入以 t 打开的文件中。

这是一项令人印象深刻的工作，您刚刚编写了复制两个文件的代码。为了使该程序正常运行，您必须具有一个名为 source.txt 的文件，或在代码本身中更改该文件的名称，以匹配存储在光盘中的文件。

动态内存分配

假设您想将玩具放在盒子里，但是您只知道它的大小。为此，您需要一个盒子，盒子的大小等于玩具的近似大小。

当我们想将一个句子作为字符数组输入但不确定该数组中的字符数时，我们也会遇到类似的情况。

现在，在声明字符数组时，如果我们指定其大小小于输入字符串的大小，则由于分配给数组的内存中的空间小于输入字符串的大小，我们将收到错误消息。这与尝试将大玩具放入较小的盒子中的情况相同。如果我们指定它的大小远大于输入字符串的大小，那么将在内存中为该数组分配一个比输入字符串的大小大得多的空间，因此即使在不需要时也不必要地消耗了更多的内存。这就像将一个小玩具放在一个大盒子里。

在上述情况下，直到编译时（当计算机编译代码并由用户输入字符串时），我们才知道数组的大小。在这种情况下，我们使用 malloc() 函数。

malloc

malloc 函数在运行时分配内存。它采用字节大小，并在内存中分配那么多空间。这意味着 malloc(50) 将在内存中分配 50 个字节。它返回一个空指针，并在 stdlib.h 中定义。

让我们借助示例来了解它：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
    char name[20];
    char *address;

    strcpy(name, "Harry Lee");
    address = (char *)malloc(50 * sizeof(char)); /* allocating memory dynamically */
    strcpy(address, "Lee Fort, 11-B Sans Street");

    printf("Name = %s\n", name);
    printf("Address: %s\n", address);
    return 0;
}

在上面的示例中，我们像以前一样分配并打印了名称。对于地址，我们估计字符数应为 50 个左右。因此，地址的大小将为 50 * sizeof(char)。

char *address → 在这里，我们声明了指向地址字符的指针，而没有指定需要多少内存。

address = (char *)malloc(50 * sizeof(char)) → 通过编写此代码，我们为地址分配了 50 * sizeof(char) 字节的内存。我们曾经 (char *) 将 malloc 返回的指针类型转换为 character。

strcpy(address, "Lee Fort, 11-B Sans Street") → 通过编写此代码，最后我们分配了地址。

默认情况下，malloc 返回一个类型为 void 的指针，但是我们可以将其类型转换为任何其他形式的指针（在上面的示例中，我们将其转换为字符类型）。

如果 malloc 分配的内存空间不足，则分配失败，并且 malloc 返回 NULL 指针。

我们来看另一个例子：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int n, i, *p;
    printf("Enter number of elements: ");
    scanf("%d", &n);
    p = (int *)malloc(n * sizeof(int)); //memory allocated using malloc
    if (p == NULL)
    {
        printf("memory cannot be allocated\n");
    }
    else
    {
        printf("Enter elements of array:\n");
        for (i = 0; i < n; ++i)
        {
            scanf("%d", &*(p + i));
        }
        printf("Elements of array are\n");
        for (i = 0; i < n; i++)
        {
            printf("%d\n", *(p + i));
        }
    }
    return 0;
}

在此示例中，首先，我们声明了一个 int 类型的指针 p，其中包含 n 个元素。因此，p 是包含 n 个元素的整数数组。因此，我们 n * sizeof(int) 为指针 p 所指向的数组分配了一个大小为大小的内存。因此，我们现在有一个存储空间分配给由 n 个元素组成的整数数组。此外，我们要求用户输入数组元素的值并显示这些值。

calloc

现在，假设您要在一个盒子里放多个玩具，而您只对玩具的数量和大小有一个大概的了解。为此，您需要一个盒子，盒子的大小等于所有玩具的大小之和。

在这种情况下，我们使用 calloc 函数。与 malloc 一样，calloc 也在运行时分配内存，并在 stdlib.h 中定义。它需要元素的数量和每个元素的大小（以字节为单位），将每个元素初始化为零，然后将空指针返回到内存。

它的语法是：

void *calloc(n, element-size);

在这里，n 是元素的数量，element-size 是每个元素的大小。

让我们再次看一下 malloc 的最后一个示例，但是这次是 calloc：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int n, i, *p;
    printf("Enter number of elements: ");
    scanf("%d", &n);
    p = (int *)calloc(n, sizeof(int)); //memory allocated using calloc
    if (p == NULL)
    {
        printf("memory cannot be allocated\n");
    }
    else
    {
        printf("Enter elements of array:\n");
        for (i = 0; i < n; ++i)
        {
            scanf("%d", &*(p + i));
        }
        printf("Elements of array are\n");
        for (i = 0; i < n; i++)
        {
            printf("%d\n", *(p + i));
        }
    }
    return 0;
}

因此，这与 malloc 的示例相同，但 calloc 的语法有所不同。在这里，我们写了 (int *)calloc(n, sizeof(int))，其中 n 是整数数组中的元素数量（在这种情况下 sizeof(int) 为 5），并且是每个元素的大小。因此，数组的总大小为 n * sizeof(int)。

calloc 将分配的内存初始化为零值，malloc 否则不初始化。

为了证明这一点，让我们看两个例子：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int n, i, *p;
    printf("Enter number of elements: ");
    scanf("%d", &n);
    p = (int *)calloc(n, sizeof(int));
    if (p == NULL)
    {
        printf("memory cannot be allocated\n");
    }
    else
    {
        printf("Elements of array are\n");
        for (i = 0; i < n; i++)
        {
            printf("%d\n", *(p + i));
        }
    }
    return 0;
}

在这里，我们指定了元素的数量，即 5，但是没有初始化任何元素。因此，calloc 将每个元素初始化为 0，从而将每个元素的值打印为 0。

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int n, i, *p;
    printf("Enter number of elements: ");
    scanf("%d", &n);
    p = (int *)malloc(n, sizeof(int));
    if (p == NULL)
    {
        printf("memory cannot be allocated\n");
    }
    else
    {
        printf("Elements of array are\n");
        for (i = 0; i < n; i++)
        {
            printf("%d\n", *(p + i));
        }
    }
    return 0;
}

由于 malloc 未将元素初始化为 0，因此在这种情况下会出现错误。

calloc 用于将内存分配给大多数数组和结构。

realloc

如果假设我们分配的内存多于或少于所需，则可以使用 realloc 更改先前分配的内存空间的大小。其语法如下：

void *realloc(pointer, new-size);

让我们看一个关于 realloc 的例子：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
    char *p1;
    int m1, m2;
    m1 = 10;
    m2 = 20;
    p1 = (char *)malloc(m1);
    strcpy(p1, "Codesdope");
    p1 = (char *)realloc(p1, m2);
    strcat(p1, "Practice");
    printf("%s\n", p1);
    return 0;
}

在上面的示例中，我们声明了一个指针 p1，该指针将用于动态分配内存空间。

p1 = (char *)malloc(m1) → 通过编写此代码，我们分配了指针 p1 指向的 10 个字节的存储空间。我们曾经 (char *) 将 malloc 返回的指针类型转换为 character。

strcpy(p1, "Codesdope") → 这会将字符串值 Codesdope 分配给指针 p1 指向的内存。当前，存储空间为 10 个字节，可以轻松存储字符串 Codesdope，但如果现在我们希望该存储空间存储字符串 CodesdopePractice 怎么办？为此，我们需要扩展内存空间的大小，这可以通过 realloc 轻松实现。

p1 = (char *)realloc(p1, m2) → 这样会将内存空间（其地址存储在 p1 中）的大小增加到 20 个字节（由于 m2 的值为 20），因此可以轻松存储字符串 CodesdopePractice。

strcat(p1, "Practice") → 这会将字符串 Practice 添加到存储在 p1 指向的内存（即 Codesdope）中的字符串的末尾。因此，现在，由 p1 指向的内存现在存储字符串值 CodesdopePractice。

free

free 函数用于在程序完成后释放或释放内存，该内存是在程序中动态分配的。建议在程序完成后释放动态分配的内存，以便将来使用。

void free(pointer);

这是 free 函数的语法，其返回类型为 void。现在，让我们看一个示例，其中我们在程序结尾使用 free 释放了动态分配的内存。

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int n, i, *p;
    printf("Enter number of elements:\n");
    scanf("%d", &n);
    p = (int *)malloc(n * sizeof(int));
    if (p == NULL)
    {
        printf("memory cannot be allocated\n");
    }
    else
    {
        printf("Enter elements of array:\n");
        for (i = 0; i < n; ++i)
        {
            scanf("%d", &*(p + i));
        }
        printf("Elements of array are\n");
        for (i = 0; i < n; i++)
        {
            printf("%d\n", *(p + i));
        }
    }
    free(p);
    return 0;
}

因此，在这里，通过编写 free(p)，我们释放了使用 malloc 动态分配的内存。

枚举

枚举（enum）是用户定义的数据类型（与结构相同）。它由该类型的各种元素组成。枚举没有这种特定的用途，我们只是为了使我们的代码更整洁，更易读而使用。我们也可以在不使用枚举的情况下编写 C 程序。

例如，夏季，春季，冬季和秋季是四个季节的名称。因此，可以说这些是季节类型。因此，这成为以季节和夏季，春季，冬季和秋季为名称的枚举。

因此，您很清楚枚举的基本概念。现在让我们看看如何定义它。

定义枚举

枚举以与结构相同的方式定义，其中关键字 struct 被关键字替换为关键字 enum，而元素由 逗号 分隔，如下所示：

enum enum_name
{
    element1,
    element2,
    element3,
    element4,
};

现在让我们定义上述季节示例的枚举：

enum Season
{
    Summer,
    Spring,
    Winter,
    Autumn
};

在这里，我们定义了一个名为 Season 和 Summer、Spring、Winter 和 Autumn 的枚举作为元素。

枚举变量声明

我们还以与结构相同的方式声明枚举变量。我们如下创建一个枚举变量：

enum season
{
    Summer,
    Spring,
    Winter,
    Autumn
};

main()
{
    enum season s;
}

因此，这里的 s 是名为 season 的枚举的变量。这个变量代表一个季节。我们还可以如下声明一个枚举变量：

enum season
{
    Summer,
    Spring,
    Winter,
    Autumn
} s;

枚举成员的价值观

枚举的所有元素都有一个值。默认情况下，第一个元素的值为 0，第二个元素的值为 1，依此类推。

让我们来看一个例子：

#include <stdio.h>

enum season
{
    Summer,
    Spring,
    Winter,
    Autumn
};

int main()
{
    enum season s;
    s = Spring;
    printf("%d\n", s);
    return 0;
}

在这里，我们首先定义了一个名为 Season 的枚举，并在主函数中声明了它的变量 s，如我们之前所见。Summer、Spring、Winter 和 Autumn 的值分别为 0、1、2 和 3。因此，通过编写 s = Spring，我们将变量 s 赋值为 1，因为 Spring 的值为 1。

我们还可以更改默认值，并将我们选择的任何值分配给枚举元素。一旦我们更改了任何枚举元素的默认值，其后所有元素的值也将相应地更改。一个例子将使这一点更清楚：

#include <stdio.h>

enum days
{
    sun,
    mon,
    tue = 5,
    wed,
    thurs,
    fri,
    sat
};

int main()
{
    enum days day;
    day = thurs;
    printf("%d\n", day);
    return 0;
}

默认值 sun 将为 0，mon 将为 1，tue 将为 2，依此类推。在上面的示例中，我们将 tue 的值定义为 5。因此，wed、thurs、fri 和 sat 的值将分别变为 6、7、8 和 9。对 sun 和 mon 的值将分别保持为 0 和 1 无效。因此，thurs 的值（即 7）将被打印出来。

让我们再看一个枚举的例子：

#include <stdio.h>

enum days
{
    sun,
    mon,
    tue,
    wed,
    thurs,
    fri,
    sat
};

int main()
{
    enum days day;
    day = thurs;
    printf("%d\n", day + 2);
    return 0;
}

在此示例中，thurs（即 4）的值分配给变量 day。由于我们正在打印 day + 2，即 6（= 4 + 2），因此输出为 6。

C语言的union

声明和使用结构的方式相同。像结构一样，它也用于存储不同类型的数据。

在探讨结构和联合之间的区别之前，让我们首先了解如何定义联合。

定义union

让我们看一下联合的语法：

union union_name
{
    数据类型 member-1;
    数据类型 member-2;
    数据类型 member-3;
    数据类型 member-4;
};

这不是结构的语法吗，除了我们写了关键词 union 来代替 struct 之外，这与结构的语法不同吗？

让我们以我们在结构中使用的相同示例为例。在这里，我们将 union 的名称称为 student，并将 name、roll_no 和 phone_number 用作其成员，如下所示：

union student
{
    int roll_no;
    char name[30];
    int phone_number;
};

union 变量声明

声明联合变量的方式与声明结构变量的方式相同。

同样，让我们以相同的示例为例，我们要存储三个学生的名册编号，姓名和电话号码。为此，我们将按照上面的定义定义一个名为 student 的联合，然后在主函数中声明其三个变量 p1、p2 和 p3（分别代表三个学生）。

union student
{
    int roll_no;
    char name[30];
    int phone_number;
};

main()
{
    union student p1, p2, p3;
}

还有另一种声明联合变量的方法，我们在定义联合时按如下方式声明它们：

union student
{
    int roll_no;
    char name[30];
    int phone_number;
} p1, p2, p3;

与结构类似，我们通过访问其姓名、roll_no 和电话号码来分配第一个学生的姓名、名次和电话号码（假设 p1），如下所示：

p1.roll_no = 1;

在这里，p1.roll_no 意味着 p1 的 roll_no。

总是使用 strcpy 为变量分配字符串值，因为我们为 p1（第一个学生）分配了名称 Brown：

strcpy(p1.name, "Brown");

到现在为止，您必须已经找到类似于结构的联合。现在让我们看一下两者之间的区别。

联合与结构之间的区别

在讨论差异之前，让我们先来看一个例子：

#include <stdio.h>

struct student1
{ //defining a union
    int roll_no;
    char name[40];
    int phone_number;
};

union student2
{
    int roll_no;
    char name[40];
    int phone_number;
};

int main()
{
    struct student1 s1;
    union student2 u1;
    printf("size of structure = %d\n", sizeof(s1));
    printf("size of union = %d\n", sizeof(u1));
    return 0;
}

谈论上面的示例，存储结构所需的内存量是其所有成员的内存大小的总和。在上面的示例中，变量 roll_no 和 phone_number 的内存大小将分别为 4 个字节（因为两者均为整数类型），而字符数组 name[40] 的内存大小将为 40 个字节（由于数组占用了内存）最多 40 个字符，并且 char 的大小为 1）。因此，该结构占用的内存将是 4 + 40 + 4 = 48 bytes。

现在进入联合，联合的内存大小等于其成员占据内存最大空间的大小。roll_no 和 phone_number 的大小分别为 4 个字节，name[40] 的大小为 40 个字节。因此，联合将占用 40 个字节的存储空间。

我们一次只能访问一个工会成员，因为我们在内存中只有一个位置，因此一次只能使用其中一个成员。所有其他成员将包含垃圾值（即会损坏）。对于可以同时访问所有成员变量的结构而言，情况并非如此，因为每个成员变量占用的存储空间不同。

现在让我们看一个联合的例子：

#include <stdio.h>
#include <string.h>

union student
{
    int roll_no;
    int phone_number;
    char name[30];
};

int main()
{
    union student p1;
    p1.roll_no = 1;
    p1.phone_number = 1234567822;
    strcpy(p1.name, "Brown");
    printf("roll_no : %d\n", p1.roll_no);
    printf("phone_number : %d\n", p1.phone_number);
    printf("name : %s\n", p1.name);
    return 0;
}

如您所见，名称按原样打印，垃圾值作为卷号和电话号码打印。让我们看看为什么会这样。

如您现在所知，我们一次只能访问一个工会成员，而其他成员则受到损坏。因此，当我们编写时 p1.roll_no = 1，访问了成员 roll_no 并为其分配了一个值 1。之后，通过写入 p1.phone_number = 1234567822，我们为成员 phone_number 分配了一个值。最后，我们为成员 name 分配了一个字符串值 Brown strcpy(p1.name, "Brown")，现在，其他两个成员 roll_no 和 phone_number 包含一个垃圾值。因此，name 的值按原样打印，输出中其他两个变量的值就是这两个变量的垃圾值。

让我们再看一个例子：

#include <stdio.h>
#include <string.h>

union student
{
    int roll_no;
    char name[30];
    int phone_number;
};

int main()
{
    union student p1;
    p1.roll_no = 1;
    printf("roll_no : %d\n", p1.roll_no);
    strcpy(p1.name, "Brown");
    printf("name : %s\n", p1.name);
    p1.phone_number = 1234567822;
    printf("phone_number : %d\n", p1.phone_number);
    return 0;
}

在这里，首先我们将 roll_no 的值分配为 1 并打印出来。因此，当前其他成员的值是一些垃圾值，而 roll_no 的值是 1，因此按原样打印。之后，我们给名称分配了一个字符串值 Brown，所以现在 roll_no 和 phone_number 包含垃圾值并且名称被打印出来。同样，我们打印了 phone_number。

C语言中的typedef

typedef 关键字用于为类型分配新名称。这只是为了防止我们编写更多内容。

例如，如果我们要声明一些 type 变量 unsigned int，则必须在程序中编写 unsigned int，这对于我们中的某些人可能非常忙。因此，我们可以使用 typedef 为 unsigned int 分配选择的新名称，该名称可以在我们想在程序中使用 unsigned int 的任何时间使用。

typedef current_name new_name;
typedef unsigned int uint;
uint i, j;

现在，我们可以在整个程序中编写 uint 而不是 unsigned int。上面的代码与编写相同：

unsigned int i, j;

让我们来看一个例子：

#include <stdio.h>

int main()
{
    typedef unsigned int ui;
    ui i = 5, j = 8;
    printf("i = %d\n", i);
    printf("j = %d\n", j);
    return 0;
}

因此，我们可以为任何数据类型分配一个新名称。

同样，我们也可以使用 typedef 为结构分配一个新名称，该结构是用户定义的数据类型，如下所示：

typedef struct structure_name
{
    数据类型 member-1;
    数据类型 member-2;
    数据类型 member-3;
    数据类型 member-4;
} type_name;

现在，在声明这种结构类型的变量的同时，我们可以 type_name 代替 struct structure_name 整个程序编写代码。

让我们以在 结构 主题中看到的名为 student 的结构为例：

#include <stdio.h>
#include <string.h>

typedef struct student
{
    int roll_no;
    char name[30];
    int phone_number;
} st;

int main()
{
    st p1, p2, p3;
    p1.roll_no = 1;
    strcpy(p1.name, "Brown");
    p1.phone_number = 123443;
    p2.roll_no = 2;
    strcpy(p2.name, "Sam");
    p2.phone_number = 1234567822;
    p3.roll_no = 3;
    strcpy(p3.name, "Addy");
    p3.phone_number = 1234567844;
    printf("First Student\n");
    printf("roll_no : %d\n", p1.roll_no);
    printf("name : %s\n", p1.name);
    printf("phone_number : %d\n", p1.phone_number);
    printf("Second Student\n");
    printf("roll_no : %d\n", p2.roll_no);
    printf("name : %s\n", p2.name);
    printf("phone_number : %d\n", p2.phone_number);
    printf("Third Student\n");
    printf("roll_no : %d\n", p3.roll_no);
    printf("name : %s\n", p3.name);
    printf("phone_number : %d\n", p3.phone_number);
    return 0;
}

在这里，整个示例与在 Structure 中所做的相同，唯一的区别是我们用 st 代替代替，struct student 即我们使用了新类型（名为 st）来声明该结构类型的变量（命名为 student）。

我们也可以结合使用 typedef 和联合。为此，所有内容都将与关键字关键字 union 代替 struct 的结构相同。

#include <stdio.h>
#include <string.h>

typedef union student
{
    int roll_no;
    int phone_number;
    char name[30];
} st;

int main()
{
    st p1, p2, p3;
    p1.roll_no = 1;
    p1.phone_number = 123443;
    strcpy(p1.name, "Brown");
    p2.roll_no = 2;
    p2.phone_number = 1234567822;
    strcpy(p2.name, "Sam");
    p3.roll_no = 3;
    p3.phone_number = 1234567844;
    strcpy(p3.name, "Addy");
    printf("First Student\n");
    printf("roll_no : %d\n", p1.roll_no);
    printf("phone_number : %d\n", p1.phone_number);
    printf("name : %s\n", p1.name);
    printf("Second Student\n");
    printf("roll_no : %d\n", p2.roll_no);
    printf("phone_number : %d\n", p2.phone_number);
    printf("name : %s\n", p2.name);
    printf("Third Student\n");
    printf("roll_no : %d\n", p3.roll_no);
    printf("phone_number : %d\n", p3.phone_number);
    printf("name : %s\n", p3.name);
    return 0;
}

C中的存储类

每个变量都有一个存储类，用于定义该变量的功能。它告诉编译器变量的存储位置，其初始值，作用域（可见性级别）和生存期（全局或局部）。

C 中有四个存储类：

• auto
• extern
• static
• register

让我们一一理解。

auto

默认情况下，在函数或块（块是一组代码的一部分，例如，用花括号括起来的语句构成代码块）中定义的变量属于自动存储类。这些变量也称为局部变量，因为它们是函数的局部变量，并且默认情况下为它们分配了一些垃圾值。由于这些变量是在函数内部声明的，因此只能在该函数内部访问。在声明这些变量时无需放置 auto，因为默认情况下它们是 auto。

虽然您在整个 C 教程中都使用了这些 auto（local）变量，但让我们看一个示例：

#include <stdio.h>

int sum(int n1, int n2)
{
    auto int s; //declaration of auto(local) variable
    s = n1 + n2;
    return s;
}

int main()
{
    int i = 2, j = 3, k;
    k = sum(i, j);
    printf("sum is : %d\n", k);
    return 0;
}

在此，变量 s 在函数 sum 内部声明，因此只能在函数内部使用。在声明时无需放置 auto。

extern

我们在变量之前编写 extern 关键字，以告诉编译器该变量在其他地方声明。基本上，通过在任何变量告诉我们该变量是在其他程序文件中声明的全局变量之前编写 extern 关键字。

现在让我们看看实际发生了什么。

您必须知道什么是全局变量。全局变量是在所有函数外部声明的变量。可以在整个程序中访问它，我们可以在任何函数中随时更改其值，如下所示：

#include <stdio.h>

int g;

void print()
{
    g = 10;
    printf("g = %d\n", g);
}

int main()
{
    g = 7;
    printf("g = %d\n", g);
    print();
    return 0;
}

在这里，g 是在所有功能之外定义的全局变量。在 main 函数中，将其值分配为 7，在 print 函数中将其值分配为 10。

在声明全局变量时，将像所有其他变量一样在内存中分配一些空间。我们可以像在上面的示例中一样，在声明它的同一程序文件中为其分配值。但是，如果我们要使用它或在任何其他程序文件中为其分配值，该怎么办。

我们可以使用 extern 关键字来做到这一点，如下所示。

firstfile.c：

int g = 0;

在第一个程序文件中 firstfile.c，我们声明了一个全局变量 g。

现在，我们将在头文件中将此变量 g 声明为 extern firstfile.h，然后将其包含在我们要使用此变量的第二个文件中。

firstfile.h：

extern int g;

现在在第二个程序文件中 secondfile.c，为了使用全局变量 g，我们需要通过写入在其中包含头文件 #include "firstfile.h"。在这里，我们为变量 g 分配了值 4，因此该程序中的 g 的值变为 4。

secondfile.c：

#include "firstfile.h"

main()
{
    g = 4;
    printf("%d", g);
}

static

初始化后声明为静态的变量将一直存在，直到程序结束。如果在函数内部声明了静态变量，则该静态变量将一直存在，直到程序结束，并且不会因为该函数的存在而被销毁（如 auto 中一样）。如果在程序中所有函数之外声明了静态变量，则只能在声明了该变量的程序中使用它，而对其他程序文件不可见（如 extern）。

让我们看一个静态变量的例子：

#include <stdio.h>

static int g = 5;

void fn()
{
    static int i = 0;
    printf("g = %d\t", g--);
    printf("i = %d\n", i++);
}

int main()
{
    while (g >= 2)
        fn();
    return 0;
}

在这里，g 和 i 是静态变量，其中 g 是全局变量，i 是局部变量。如果我们未 static 在声明 i 之前编写过代码，则每次将调用函数 fn() 时，每次都会将 i 声明为初始值 0 并作为函数 fn() 将退出，也将被摧毁。

register

它告诉编译器变量将被存储在寄存器中，而不是存储在内存（RAM）中。我们可以比普通变量更快地访问寄存器变量。并非所有定义为的寄存器 register 都将存储在寄存器中，因为它取决于实现和硬件的各种限制。

我们无法访问此类变量的地址，因为它们没有一个存储位置，通过以下示例可以清楚地看到这些位置：

#include <stdio.h>

int main()
{
    register int n = 20;
    int *ptr;
    ptr = &n;
    printf("address of n : %u", ptr);
    return 0;
}

什么是数组？什么是指针？

数组是相同类型的对象集合，可以用一个名称引用。

例如：

int scores[50];

它可以包含 50 场篮球赛的比分。

使用不同的索引值可以引用数组中的每个元素。scores[0] 是第一个分数，scores[49] 是最后一个分数。

如果每个月有 10 场比赛，就可以用多维数组：

scores[12][10];

如果一月开始比赛，则五月的第三场比赛用：

scores[4][2];

指针是一个变量，它的值是给定类型的另一个变量或常量的地址。

使用指针可以在不同的时间访问不同的变量，只要它们的类型相同即可。

数组和指针似乎完全不同，但它们有非常密切的关系，有时还可以互换。

下面看一个例子：

字符串是 char 类型的数组。如果用 scanf 输入一个字符：

char single = 0;
scanf("%c", &single);

具体代码：

#include <stdio.h>

int main(void)
{
    char single = 0;
    scanf("%c", &single);
    printf("%c\n", single);
    return 0;
}

在这里 scanf 需要用到取地址符 &，用于 single。因为 scanf 需要用到存储的变量的地址。

然而，如果读入的是字符串，可以这样：

#include <stdio.h>

int main(void)
{
    char multiple[10];
    scanf("%s", &multiple);
    printf("%s\n", multiple);
    return 0;
}

这里不需要使用 & 运算符，而使用数组名称，就像指针一样。

#include <stdio.h>

int main(void)
{
    char multiple[10];
    scanf("%s", multiple); //可以不需要取地址符 数组名本身就是地址
    printf("%s\n", multiple);
    return 0;
}

如果以这种方式使用数组名称，而没有带索引值，它就引用数组的第一个元素的地址。

但数组不是指针，它们有一个重要的区别：可以改变指针包含的地址，但不能改变数组名称引用的地址。

指针算术与数组类型

我们前面知道 char 类型是占一个字节。

所以当我们使用指针 p + 1 就去到下一个字节，下一个字节就读取下一个字节的字符。

#include <stdio.h>

int main(void)
{
    char multiple[10];
    scanf("%s", multiple); //可以不需要取地址符 数组名本身就是地址
    char *p = multiple; //&multiple[0]
    printf("%c\n", *p);
    printf("%c\n", *(p+1));
    return 0;
}

但是如果是其他类型，比如 long 类型不是占用一个字节，而是四个字节。

这时候，如果我们要读取下个元素，是否是 p+4？还是？

大家思考一下这个问题。

下面看这个例子：

#include <stdio.h>

int main(void)
{
    long multiple[] = {15L, 25L, 35L, 45L};
    long * p = multiple;

    for(int i = 0; i < sizeof(multiple)/sizeof(multiple[0]); i++)
    {
        printf("\n地址 p+%d (&multiple[%d]): %d   *(p+%d) 值: %d",
               i, i, p+i, i, *(p+i));
    }

    printf("\n    long类型占: %d bytes\n", sizeof(long));
    return 0;
}

上面代码，p 是 6422016，p+1 本来我们觉得应该是 6422017，但是它实际上是 6422020。

所以 p+1 比 p 是大了 4，而不是 1。

这里是编译器帮我们来计算，编译器根据指针类型 long，然后决定了是 4。

就是因为我们的指针是 long 类型指针 long * p，所以当我们 p+1 的时候，编译器知道是 long 类型，然后知道它 4 个字节，所以虽然是 p+1，但是编译器自动跳转四个字节。

多维数组与指针

前面我们讨论的是一维数组与指针的关系，二维或者多维数组是否相同？

其实某种程度上是相同的。

考虑之前的井字游戏中用到的数组：

char board[3][3] = {
    {'1','2','3'},
    {'4','5','6'},
    {'7','8','9'}
};

下面使用该数组来探讨一下：

#include <stdio.h>

int main(void)
{
    char board[3][3] = {
        {'1','2','3'},
        {'4','5','6'},
        {'7','8','9'}
    };

    printf("address of board        : %p\n", board);
    printf("address of board[0][0]  : %p\n", &board[0][0]);
    printf("but what is in board[0] : %p\n", board[0]);
    return 0;
}

我们可以看到，以上三个值是相同的。

声明一维数组 x[n1] 时，它告诉编译器它是一个有 n1 个元素的数组。

声明二维数组 y[n1][n2]，编译器就会创建一个大小为 n1 的数组，它的每个元素是一个大小为 n2 的数组。

声明二维数组时，就是创建一个数组的数组。

因此使用数组名+一个索引值访问这个二维数组时，例如 board[0] 就是引用一个子数组的地址。

仅使用二维数组名时，就是引用二维数组的开始地址。它也是第一个子数组的开始地址。

#include <stdio.h>

int main(void)
{
    char board[3][3] = {
        {'1','2','3'},
        {'4','5','6'},
        {'7','8','9'}
    };

    printf("value of board[0][0] : %c\n", board[0][0]);
    printf("value of *board[0]   : %c\n", *board[0]);
    printf("value of **board     : %c\n", **board);
    return 0;
}

使用 board 获取子数组的第一个元素需要两个间接运算符 **board。

如果只使用一个 *，只会得到子数组的第一个元素，即 board[0] 引用的地址。

也就是 *board 得到的是 board[0] 的地址。

#include <stdio.h>

int main(void)
{
    char board[3][3] =
    {
        {'1','2','3'}, //board[0] char b[] = {'1','2','3'}
        {'4','5','6'}, //board[1] char b1[] = {'4','5','6'}
        {'7','8','9'}  //board[2] char b2[] = {'7','8','9'}
    };
    //b 就是1的地址  b在这里 等同于 board[0]
    //在一维数组里面 b[0]是1 *b 也是1  *(b+1) 就是b[1]
    //把b替换为board[0]  *board[0] *(board[0]+1)
    printf("address of board        : %p\n", board);
    printf("address of board[0][0]  : %p\n", &board[0][0]);
    printf("but what is in board[0] : %p\n", board[0]);

    printf("value of board[0][0] : %c\n", board[0][0]);
    printf("value of *board[0]   : %c\n", *board[0]);
    printf("value of **board     : %c\n", **board);
    return 0;
}

下面例子用 for 循环进一步改进前一个例子：

#include <stdio.h>

int main(void)
{
    char board[3][3] = {
        {'1','2','3'},
        {'4','5','6'},
        {'7','8','9'}
    };

    /* List all elements of the array */
    for(int i = 0; i < 9; i++)
        printf(" board: %c\n", *(*board + i));
    return 0;
}

程序的输出如下：

可以看到，使用表达式 *(*board + i) 可以得到一个数组元素的值。

括号中的表达式 *board + i 会得到数组中偏移量为 i 的元素的地址。

board 其实是 char** 类型的地址值，取消对 board 的引用，也就是 *board，也就是 char*，也就是它还是一个指针，然后指针 +n 也就是获取后面的元素。比如 *board + 2 获取第三个元素的地址。

如果去掉括号，也就是：

printf("board:%c\n", **board + i);

则会输出下面：

虽然好像是一模一样，但是如果修改为如下：

#include <stdio.h>

int main(void)
{
    char board[3][3] = {
        {'9','8','7'},
        {'6','5','4'},
        {'3','2','1'}
    };

    /* List all elements of the array */
    for(int i = 0; i < 9; i++)
        printf(" board: %c\n", **board + i);
    return 0;
}

以上代码 **board 就是 '9'，然后 '9' + 1 就是 ascii 表中的下一个字符。

如果明白的同学可以回去复习一下 char 类型。

另外，如果表达式写成 **(board + 1) 这时候可能会导致错误。

因为 **(board + 0) 指向 board[0][0]，而 **(board + 1) 指向 board[1][0]，**(board + 2) 指向 board[2][0]。

为什么 board + 1 是 board[1][0] 而不是 board[0][1]？

原因是 board 是 char** 类型，它 +1 也就是一维数组 char[] 移动 1，而不是一个元素 char 移动 1。

#include <stdio.h>

int main(void)
{
    char board[3][3] = {
        {'9','8','7'},
        {'6','5','4'},
        {'3','2','1'}
    };

    /* List all elements of the array */
    for(int i = 0; i < 9; i++)
        printf(" board: %c\n", **(board + i));
    return 0;
}

三种写法记住：

• *(*board + i)：*board 本身就是一个 char 类型指针 char*，char 类型刚好占一个字节，+i 就自动跳到下一个元素
• **board + i：这个很好理解，**board 就是 '9'，+1 就跳到下一个 ascii 码了
• **(board + i)：board 本身是一个 char** 类型，也就是一维数组的指针，+i 就是跳过一个一维数组的跨度

*board 就是一个 char* 类型：

char *p = *board;
*(p+1)
*(p+2)
*(p+3)
*(p+4)

这里就回到前面章节的内容了。

前面用指针的表示法用数组名称引用二维数组，现在学习使用声明为指针的变量。

下面的例子使用多维数组和指针：

指针+一个数组，看这个指针是什么类型，如果是 char 就是跳过一个字节，如果是 long 就是四个字节。

#include <stdio.h>

int main(void)
{
    char board[3][3] = {
        {'1','2','3'},
        {'4','5','6'},
        {'7','8','9'}
    };

    char *pboard = *board;             /* A pointer to char */

    for(int i = 0; i < 9; i++)
        printf(" board: %c\n", *(pboard + i));  //pboard 是一个char*指针 +1 就是跳过一个字节
    return 0;
}

这里使用数组中第一个元素的地址初始化指针，然后用一般的指针算术运算遍历整个数组。

board 是 char** 类型，也就是指针的指针，是子数组 board[0] 的地址，board[0] 本身是一个一维数组。

所以当我们 board + i 就是跳过一个一维数组的字节长度。

**(board + i) 而不是第一个元素的地址。它必须是 char* 类型。

也可以用以下方式来初始化 pboard：

char *pboard = &board[0][0];

如果下面的写法则会报错，编译器可能会警告：

pboard = board;

因为 board 是两个 *，而 pboard 是一个 *。

可以使用下面几种方式访问二维数组的元素：

char board[3][3] = {
    {'9','8','7'},
    {'6','5','4'},
    {'3','2','1'}
};

board[0] 就是 {'9','8','7'}，是一个一维数组。

假如 char b3[] = {'9','8','7'}，这时候 board[0] 就是 b3。

以前 char* p = b3;，这里 p 就是 board[0]。

如果要访问 '8'，*(b3+1)。

所以 board[0] 就是二维数组里面的第一个一维数组的第一个元素的地址。

同样 board[1] 就是第二个一维数组的第一个元素的地址了，也就 {'6','5','4'} 的 6 的地址。

然后 board[2] 就是 3 的地址。

动态内存分配

指针是一个非常灵活且强大的编程工具，有非常广泛的应用。

大多数 C 程序都在某种程度上使用了指针。

C 语言还有一个功能：动态内存分配，它依赖指针的概念，为在代码中使用指针提供了很强的刺激机制，它允许在执行程序时动态分配内存。

只有使用指针，才能动态分配内存。

大多数产品程序都使用了动态内存分配。例如电子邮件客户端在检索电子邮件时，事先并不知道有多少封电子邮件，也不知道每封邮件需要多少内存。电子邮件客户端在运行期间会得到足够的内存，来管理电子邮件的数量和大小。

前面我们见过一个程序计算一组学生的平均分，当时它处理 10 个学生。

理想情况下，该程序应能处理任意多个学生，但事先不知道要处理多少个学生，所使用的内存也不会比指定的学生分数所需的内存多。

动态内存分配就可以实现这个功能，可以在执行时创建足够以容纳所需数据量的数组。

在程序的执行期间分配内存时，内存区域中的这个空间称为堆（heap）。

还有另一个内存区域，称为栈（stack），其中的内存分配给函数的参数和本地变量。在执行完该函数后，存储参数和本地变量的内存空间就会释放。堆中的内存是由程序员控制的。

如本章后面所述，在分配堆上的内存时，由程序员跟踪所分配的内存何时不再需要，并释放这些空间，以便可以重用它们。

前面第五章，可以利用变量指定数组的维度，在运行期间创建数组。

也可以在运行期间明确分配内存。

在运行期间分配内存的最简单的标准函数是 malloc 函数。

使用这个函数需要在程序中包含头文件 stdlib.h。malloc 函数需要指定要分配的内存字节数作为参数。

这个函数返回所分配内存的第一个字节的地址。所以需要使用指针来存储该函数的返回值。

例子：

int *pNumber = (int*)malloc(100);

这条语句请求 100 个字节的内存，并把这个内存块的地址赋予 pNumber。只要不修改它，任何时间使用这个变量 pNumber 它都会指向所分配的 100 个字节的第一个 int 的位置。这个内存块能够保持 25 个 int 值，每个 int 占 4 个字节。

上面语句 100 是假定 int 占 4 个字节。但是我们最好这样写，因为不是所有的系统 int 都是 4 个字节。

int *pNumber = (int*)malloc(25 * sizeof(int));

这样就保证可以存储 25 个 int 值了。

这里需要 int* 指针，所以需要强制类型转换。因为 malloc 可以为任何类型的数据分配内存。

这个函数本身不知道是什么类型，所以它返回一个 void 类型的指针，写成 void*。

类型 void* 可以指向任何类型的数据。然而不能去掉对 void 指针的引用，因为它指向未具体说明的对象。

可以请求任意数量的字节，字节数受制于计算机未用的内存以及 malloc 的运用场合。如果因某种原因而不能分配请求的内存，malloc 会返回一个 NULL 指针。这个指针等于 0。

所以我们最好先检查是否已分配，再使用它。

int *pNumber = (int*)malloc(25 * sizeof(int));
if(!pNumber)
{
    //其它操作
}

在动态分配内存时，应该总是在不需要该内存时释放它们。堆上分配的内存会在程序结束时自动释放，但最好在使用完这些内存后立即释放，甚至是在退出程序之前，也应立即释放。在比较复杂的情况下，很容易出现内存泄漏。当动态分配了一些内存时，没有保留对它们的引用，就会出现内存泄漏，此时无法释放内存。这常常发生在循环内部，由于没有释放不再需要的内存，程序会在每次循环迭代时使用越来越多的内存，最终占用所有内存。

当然，要释放动态分配的内存，必须能访问引用内存块的地址。要释放动态分配的内存，而该内存的地址存储在 pNumber 指针中，可以使用下面的语句：

free(pNumber);
pNumber = NULL;

free() 函数的形参是 void* 类型，所有指针类型都可以自动转换为这个类型，所以可以把任意类型的指针作为参数传送给这个函数。只要 pNumber 包含分配内存时返回的地址，就会释放所分配的整个内存块，以备以后使用。在指针指向的内存释放后，应总是把指针设置为 NULL。

警告：在释放指针指向的堆内存时，必须确保它不被另一个地址覆盖。

如果给 free() 函数传送一个空指针，该函数就什么也不做。应避免两次释放相同的内存区域，因为在这种情况下，free() 函数的操作是不确定的，因此也就无法预料。如果多个指针变量引用已分配的内存，就有可能两次释放相同的内存，所以要特别小心。

试试看：动态内存分配

下面使用指针来计算质数，将动态内存分配的概念应用于实践。质数是只能被 1 和这个数本身整除的整数。

查找质数的过程非常简单。首先，由观察得知，2、3 和 5 是前三个质数，因为它们不能被除了 1 以外更小的数整除。其他质数必定都是奇数（否则它们可以被 2 整除），所以要找出下一个质数，可以从最后一个质数开始，给它加 2。检查完这个数后，再给它加 2，继续检查。

检查一个数是否为质数，而不只是奇数，可以用这个数除以比它小的所有奇数。其实不需要这么麻烦。如果一个数不是质数，它必定能被比它小的质数整除。我们要按顺序查找质数，所以可以把已经找到的质数作为除数，确定所检查的数是否为质数。

这个程序将使用指针和动态内存分配：

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

int main(void)
{
    unsigned long *primes = NULL;       /* Pointer to primes storage area    */
    unsigned long trial = 0;            /* Integer to be tested              */

    bool found = false;                 /* Indicates when we find a prime    */
    size_t total = 0;                   /* Number of primes required         */
    size_t count = 0;                   /* Number of primes found            */

    printf("How many primes would you like - you'll get at least 4?  ");
    scanf("%u", &total);                /* Total is how many we need to find */
    total = total < 4U ? 4U : total;    /* Make sure it is at least 4        */

    /* Allocate sufficient memory to store the number of primes required */
    primes = (unsigned long *)malloc(total * sizeof(unsigned long));
    if(primes == NULL)
    {
        printf("\nNot enough memory. Hasta la Vista, baby.\n");
        return 1;
    }

    /* We know the first three primes     */
    /* so let's give the program a start. */
    *primes = 2UL;                      /* First prime                   */
    *(primes+1) = 3UL;                  /* Second prime                  */
    *(primes+2) = 5UL;                  /* Third prime                   */
    count = 3U;                         /* Number of primes stored       */
    trial = 5U;                         /* Set to the last prime we have */

    /* Find all the primes required */
    while(count < total)
    {
        trial += 2UL;                     /* Next value for checking       */

        /* Try dividing by each of the primes we have       */
        /* If any divide exactly - the number is not prime  */
        for(size_t i = 0; i < count; i++)
            if(!(found = (trial % *(primes+i))))
                break;                        /* Exit if no remainder          */

        if(found)                        /* we got one - if found is true */
            *(primes+count++) = trial;     /* Store it and increment count  */
    }

    /* Display primes 5-up */
    for(size_t i = 0; i < total; i++)
    {
        if(!(i % 5U))
            printf("\n");                   /* Newline after every 5         */
        printf("%12lu", *(primes+i));
    }
    printf("\n");                       /* Newline for any stragglers    */
    return 0;
}

在 <stdlib.h> 头文件中声明的 calloc() 函数与 malloc() 函数相比有两个优点。

第一，它把内存分配为给定大小的数组。

第二，它初始化了所分配的内存，所有的位都是 0。

函数需要两个参数：数组的元素个数和数组元素占用的字节数，这两个参数的类型都是 size_t。

该函数也不知道数组元素的类型，所以所分配区域的地址返回为 void* 类型。

下面的语句使用 calloc() 为包含 75 个 int 元素的数组分配内存：

int *pNumber = (int*)calloc(75, sizeof(int));

如果不能分配所请求的内存，返回值是 NULL，也可以检查分配内存的结果，这非常类似于 malloc()，但 calloc() 分配的内存区域都会初始化为 0。当然，可以让编译器执行类型转换：

int *pNumber = calloc(75, sizeof(int));

后面的代码省略了这个类型转换。

将上面的程序改为使用 calloc() 代替 malloc() 来分配需要的内存，只需要修改一条语句。其他代码不变：

primes = calloc((size_t)total, sizeof(unsigned long));
if (primes == NULL)
{
    printf("Not enough memory. It's the end I'm afraid.\n");
    return 1;
}

指针本质上也是一个变量，它也有类型。

我们以前讲的变量。

int age = 12;

这个变量存储一个整数，这个变量的名字叫 age。变量其实是内存中的一块小区域。通常是占 n 个字节。

一个字节是 8 个位，8 bit。一个 bit 存储 0 或 1。

指针是 C 语言中最强大的工具之一，它也是最容易令人困惑的主题，所以一定要在开始时正确理解其概念。

在前面讨论内存时，谈到计算机如何为声明的变量分配一块内存。

在程序中使用变量名引用这块内存，但是一旦编译执行程序，计算机就使用内存位置的地址来引用它。

例如

int number = 5;

这条语句会分配一块内存来存储一个整数，使用 number 名称可以访问这个整数。值 5 就存储在这块区域中。

计算机用一个地址引用这块区域。存储这个数据的地址取决于所使用的计算机、操作系统和编译器。

在源代码中，这个变量名是固定不变的，但是地址在不同的系统上是不同的。

可以存储地址的变量称为指针。存储在指针中的地址通常是另一个变量。

指针 pnumber 中的地址是 number 第一个字节的地址。

变量 number 是一个值为 99 的整数变量。存储在 pnumber 中地址是 number 第一个字节的地址。

知道变量 pnumber 是一个指针是不够的，更重要的是，编译器必须知道它所指的变量类型。没有这个信息，根本不可能知道它占用多少内存，或者如何处理它所指向的内存的内容。

char 类型占一个字节，long 类型占四个字节，因此每个指针都和某个变量类型相关联，也就是用于指向该类型的变量。

所以，如果指针的类型是 int，就是指向 int 类型的变量。

float 类型的指针，就是指向 float 类型的变量。

一般给类型的指针写成 type*

类型名 void 表示没有指定类型，所以 void* 类型的指针可以包含任意类型的数据项地址。

以下语句可以声明一个指向 int 类型变量的指针：

int *pnumber;

pnumber 变量的类型是 int *，它可以存储任意 int 类型变量的地址。

该语句还可以写作：

int* pnumber;

这条语句创建了 pnumber 变量，但是没有初始化它，未初始化的指针是非常危险的。

比未初始化的普通变量要危险很多，所以应总是在声明指针时对它进行初始化。

如果不指向变量，可以设为 NULL。

int *pnumber = NULL;

NULL 是在标准库中定义的一个常量，对于指针它表示 0。

NULL 是一个不指向任何内存位置的值。

这表示使用不指向任何对象的指针，不会意外覆盖内存。

NULL 在头文件 stddef.h、stdlib.h、stdio.h、string.h、time.h、wchar.h 和 locale.h 中定义。

只要编译器不能识别 NULL，就应在源文件中包含 stddef.h 头文件。

如果用已声明的变量地址初始化 pointer 变量，可以使用寻址运算符 &。

例如：

int number = 99;
int *pnumber = &number;

注意 number 的声明必须在 pnumber 之前。否则代码不能编译。编译器需要先分配好空间，才能使用 number 的地址初始化 pnumber 变量。

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int number = 99;
    //int *pNumber;//不安全
    //int *pNumber = NULL;//可以指向一个NULL
    int *pNumber = &number;
    return 0;
}

指针的声明没有什么特别之处。可以用相同的语句声明一般的变量和指针。

例如：

double value, *pval, fnum;

要注意如下问题，很多人很容易犯错。

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int number, *pNumber;
    pNumber = &number;
    int age = *pNumber;
    return 0;
}

间接运算符与指针访问

使用间接运算符 * 可以访问指针所指的变量值。

这个运算符也称为取消引用运算符，因为它用于取消对指针的引用。

假设声明以下的变量：

int number = 15;
int *pointer = &number;
int result = 0;

pointer 变量含有 number 变量的地址，所以可以在表达式中使用它计算 result 的新值。如下：

result = *pointer + 5;

表达式 *pointer 等于存储在 pointer 中的地址的值。这是存储在 number 中的值 15。

所以 result 是 15+5 等于 20。

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int number = 15;
    int *pointer = &number;
    int result = 0;
    //result = number +5;
    result = *pointer + 5;
    printf("%d", result);
    return 0;
}

以下例子将声明一个变量和一个指针，然后输出它们的地址和它们所含的值。

#include <stdio.h>

int main(void)
{
    int number = 0;                 /* A variable of type int initialized to  0 */
    int *pointer = NULL;            /* A pointer that can point to type int     */
    number = 10;
    printf("\nnumber的地址: %p", &number);            /* Output the address */
    printf("\nnumber的值: %d\n\n", number);           /* Output the value   */

    pointer = &number;              /* Store the address of number in pointer   */

    printf("pointer的地址: %p", &pointer);            /* Output the address */
    printf("\npointer的大小: %d bytes", sizeof(pointer)); /* Output the size   */
    printf("\npointer的值: %p", pointer);  /* Output the value (an address) */
    printf("\n*pointer指向的值: %d\n", *pointer);       /* Value at the address */
    return 0;
}

• 同时也是乘法符号，但是编译器不会混淆，因为出现的位置是不一样的，而且编译器是可以理解的。

可以通过指针 pnumber 访问 number 的内容，所以可以在算术语句中使用取消引用的指针。

例如：

*pnumber += 25;

上述语句将变量 pnumber 所指向的地址中的值增加 25。星号 * 表示访问 pnumber 变量所指向的内容。这里它是变量 number 的内容。

变量 pnumber 能存储任何 int 变量的地址。这表示可以用下面的语句改变 pnumber 的变量。

int value = 999;
pnumber = &value;

重复之前的语句：

*pnumber += 25;

该语句操作的新的变量 value。value 的新值是 1024。这表示指针可以包含同一类型的任意变量的地址。

所以，可以使用一个指针变量可以改变其它任何变量的值，只要它们的类型和指针相同。

#include <stdio.h>

int main(void)
{
    int value = 900;
    int *pnumber = NULL;
    int number = 90;
    pnumber = &number;
    printf("%d\n", *pnumber); //90
    *pnumber += 10;
    printf("%d\n", number); //100

    pnumber = &value;
    *pnumber += 10;
    printf("%d\n", value); //110? 910?
    printf("%d\n", *pnumber); //910
    return 0;
}

自己动手做一下下面的题目：

#include <stdio.h>

int main(void)
{
    long num1 = 0;
    long num2 = 0;
    long *pnum = NULL;

    pnum = &num1; //pnum的值是num1的地址
    *pnum = 2;   //num1：2
    ++num2;   //num2：1
    num2 += *pnum;   //num2：3

    pnum = &num2;  //pnum的值是num2的地址
    ++*pnum;   //num2：4                                    /* Increment num2 indirectly */

    printf("\nnum1 = %ld  num2 = %ld  *pnum = %ld  *pnum + num2 = %ld\n",
           num1, num2, *pnum, *pnum + num2); //2 4 4 8
    return 0;
}

指针与输入

下面例子演示指针如何用于键盘输入。

前面使用 scanf() 输入数值。使用 & 运算符获取接收输入的变量的地址，并用作传给函数的参数。有了一个含有地址的指针后，只需使用这个指针的名字作为参数。

下面是以前的写法：

#include <stdio.h>

int main(void)
{
    int value = 0;
    scanf("%d", &value);
    printf("\n%d", value);
    return 0;
}

看下面例子：

#include <stdio.h>

int main(void)
{
    int value = 0;
    int *pvalue = NULL;

    pvalue = &value;                    /* Set pointer to refer to value  */

    printf("Input an integer: ");
    scanf(" %d", pvalue);              /* Read into value via the pointer */

    printf("\nYou entered %d\n", value);      /* Output the value entered */
    return 0;
}

pvalue 和 &value 是相同的，用任何一个作为 scanf 的第二个参数都是可以的，它们都表示 value 的地址。

我们的代码：

#include <stdio.h>

int main(void)
{
    int value = 0;
    int *pValue = NULL;
    pValue = &value;
    scanf("%d", pValue);
    printf("\n%d", value);
    return 0;
}

假定创建如下指针：

int *pvalue = NULL;

如前面说的，NULL 是 C 语言中是特殊的常量。它相当于数字 0 的指针。

NULL 常常定义为 ((void*)0)。

给指针赋予 0 时，就等于将它设为 NULL。

所以编写如下语句：

int *pvalue = 0;

因为 NULL 等于 0，如果要测试指针 pvalue 是否是 NULL，可以编写如下语句：

if (!pvalue)
{
    //指针为空
}

当然也可以这样：

if (pvalue == NULL)
{
    //指针为空
}

我们的代码：

#include <stdio.h>

int main(void)
{
    int *pvalue = NULL;
    int *pv = 0;
    if (!pvalue)
    {
        //空指针
    }
    if (pvalue == NULL)
    {
        //空指针
    }
    return 0;
}

常量指针

声明指针时，可以使用 const 关键字指定，该指针指向的值不能改变。

看下面例子：

long value = 9999L;
const long *pvalue = &value;

这时候 pvalue 所指向的值声明为 const，编译器就会检查语句有没有试图修改 pvalue 指向的值。所以下面语句是错误的：

*pvalue = 8888L;

也就是不能通过 pvalue 的指针来修改它所指向的值。

但是可以通过 value 来修改。

下面语句是可以的：

value = 7777L;

虽然不能通过 pvalue 来修改它所指向的值。

但是 pvalue 本身保存的值（地址）是可以改变的。

比如下面：

long number = 8888L;
pvalue = &number;

这样 pvalue 的值又被改为了 number 的地址。仍然不能使用指针改变它指向的值。也就是如果希望：

*pvalue = 8888L;

这样，那也是不行的。

一句话总结：

指向常量的指针，可以改变指针中的地址，但是不能改变地址指向的值。

我们的代码：

#include <stdio.h>

int main(void)
{
    long value = 9999L;
    value = 123L;
    const long *pValue = &value;
    *pValue = 456L; //指针是const 不能通过它来修改指向的变量
    printf("%d", value);
    return 0;
}

我们的例子：

#include <stdio.h>

int main(void)
{
    long value = 9999L;
    value = 123L;
    const long *pValue = &value;
    //*pValue = 456L;//指针是const 不能通过它来修改指向的变量
    value = 456L;
    printf("%d", value);

    long number = 1000L;
    pValue = &number;
    //*pValue = 456L;//虽然指针指向了number 但是也是不能通过它来修改

    return 0;
}

当然，也可以使指针中存储的地址不能改变。

此时，在指针声明中使用 const 关键字的方式，但是有点不同。

下面语句可以使指针总是指向相同的对象：

int count = 43;
int *const pcount = &count; //定义一个常量指针

第二条语句声明并初始化了 pcount，指定该指针存储的地址不能改变。

编译器会检查代码是否无意中把指针指向其他地方，所以下面语句会在编译时生成一条错误信息。

int item = 34;
pcount = &item; //错误 尝试改变指针存储的地址值

但是使用 pcount 仍可以改变 pcount 指向的值：

*pcount = 235;

这条语句通过指针引用了存储在 count 中的值，并将其改为 235。

#include <stdio.h>

int main(void)
{
    long value = 9999L;

    long * const pValue = &value;
    *pValue = 100L;
    printf("%d", value);

    long number = 12L;
    pValue = &number; //出错 指针的值不能改变
    return 0;
}

当然还可以直接使用 count 来改变它的值。

可以创建一个常量指针，它指向一个常量值。也就是结合上一节课的。

int item = 25;
const int *const pitem = &item;

这时候 pitem 是一个指向常量的常量指针。所以所有的信息都固定不变。不能改变存储在 pitem 中的地址，也不能使用 pitem 改变它指向的内容。

但仍可以直接修改 item 的值。

如果希望所有的信息都固定不变，可以把 item 也指定为 const。

#include <stdio.h>

int main(void)
{
    long value = 9999L;

    const long * const pValue = &value;
    //*pValue = 100L; //不能改变指针指向的变量的值
    printf("%d", value);

    long number = 12L;
    //pValue = &number; //出错 指针的值不能改变

    printf("\n%d", *pValue);
    return 0;
}

指针命名规范

随着程序越来越大，就越难记住哪一个是一般变量，哪一个是指针，因此，最好使用 p 作为指针名的第一个字母。

如果严格遵守这个命名方法，那就很容易记住了。

#include <stdio.h>

int main(void)
{
    long value = 9999L;
    long * pValue = &value;

    *pValue = 100L;
    printf("%d", value);
    printf("\n%d", *pValue);

    long number = 111L;
    pValue = &number; //看到p前缀的变量 就知道这是一个指针
    return 0;
}

字符串常量的例子非常常见。字符串常量是放在一对双引号中的一串字符和符号。一对双引号之间的任何内容都会被编译器视为字符串，包括特殊字符和嵌入的空格。每次使用 printf 显示信息时，就将该信息定义成字符串常量了。以下是字符串的例子：

第二个字符串中带有换行符。第三个字符串输出双引号和斜线。

字符串的串就是一连串，所以字符串在内存中的存储是这样的：

上图中每个字符串的末尾都添加了代码值 0 的特殊字符，这个字符称为空字符，写为 \0。C 中的字符串总是由 \0 字符结束。所以字符串的长度永远都比字符串中的字符数多 1。

可以自己将 \0 字符添加到字符串的结尾，但是这样会使得字符串的末尾有两个 \0 字符。下面说明空字符 \0 是如何运作：

#include <stdio.h>

int main(void)
{
    printf("The character \0 is used to terminate a string.");
    return 0;
}

以上程序输出：

这不是期望的结果，因为它仅仅显示了字符串的第一部分。这个程序显示了前两个字符串就结束输出。因为在字符串中有 \0，printf 函数遇到第一个空字符 \0 就会停止输出。即使末尾有另外一个 \0 也永远不会执行它。

#include <stdio.h>

int main(void)
{
    printf("\\\\www.foxdevelop.com \\0\n\"Foxdevelop\"");
    return 0;
}

C 语言对变量存储字符串的语法没有特殊规定，而且 C 根本就没有字符串变量，也没有处理字符串的特殊运算符。但这不成问题，因为标准库提供了许多函数来处理字符串。整数 int 这些类型 C 语言提供 + - * 等运算符，但是字符串 C 语言没有提供类型也没有符号运算，不过标准库里面有人使用 C 语言写好了代码。比如假如希望 C 语言使用 + -，其实可以使用其他方式去实现，不需要写到这门语言里面。

之前说的 char 类型是用来存储字符的，字符串就是多个字符连起来，数组可以存储多个相同类型的数据。换个角度思考，就可以使用 char 类型的数组来保存字符串。这是字符串变量的最简单的方式：

char saying[20];

这个变量可以存储一个至多包含 19 个字符的字符串，因为必须给终止字符提供一个数组元素，也就是需要一个 \0。当然也可以使用该数组存储 20 个字符，但这样就不是一个字符串了。

也可以用以下的声明初始化前面的字符串变量：

char saying[] = "this is a string.";

这里没有明确定义数组的大小，编译器指定一个足以容纳这个字符串常量的数值。在这个例子中它是 18，其中 17 个元素用于存储字符串中的字符，再加上一个额外的终止字符 \0。当然可以指定数值，但要确保它一定正确。

也可以用一个字符串初始化 char 类型数组的部分元素：

char str[40] = "To be";

这里编译器会使用指定字符串的字符初始化 str[0] 到 str[4] 的前五个元素，而 str[5] 则是给 \0。数组的所有 40 个元素都会被分配空间，可以以任意方式使用。

初始化一个 char 数组，将它声明为常量，是处理标准信息的好方法：

const char message[] = "The end of the world is nigh.";

将 message 声明为常量，它就不会在程序中被更改。只要试图更改它，编译器都会产生错误信息。当标准信息在程序中的许多地方使用时，这种定义方法特别有用，可以防止在程序的其他部分意外地修改这种常量。当然，如果必须改变这条信息，就不应将它指定为 const。

要引用存储在数组中的字符串时，只需要使用数组名即可。例子：

printf("\n The message is：%s", message);

printf 会将第一个参数的 %s 的位置输出 message 数组中的连续的字符，直到遇到 \0 为止。这个例子将初始化两个字符串，然后确定每个字符串有多少个字符，不包含空字符：

#include <stdio.h>

int main(void)
{
    char str1[] = "To be or not to be";
    char str2[] = ",that is the question";
    int count = 0;
    while (str1[count] != '\0')
        count++;
    printf("\n字符串 \"%s\" 的长度是 %d 个字符.", str1, count);

    count = 0;
    while (str2[count] != '\0')
        count++;
    printf("\n字符串 \"%s\" 的长度是 %d 个字符.\n", str2, count);
    return 0;
}

\0 字符的 ASCII 码是 0，对应于布尔值的 false，其他 ASCII 码都不是 0。

可以使用 char 类型的二维数组存储字符串，数组的每一行都用来存储一个字符串，就可以存储一整串字符串，通过一个变量名引用它们，例如：

这个包含 3 行，每行 32 个字符。这样就相当于有三个字符串了。比如 sayings[0] 就是 “Manners maketh man.”，32 刚好是最长的字符串的长度包含 \0。

#include <stdio.h>

int main(void)
{
    char str1[3][32] = {"To be or not to be",
                        "www.foxdevelop.com",
                        "www.baidu.com"};
    printf("%c\n", str1[1][3]);
    printf("%s\n", str1[1]);

    return 0;
}

在字符串数组中，必须制定第二维的大小，也可以让编译器计算数组有多少个字符串。上面可以写成：

可以用下面代码输出以上三个字符串：

上面代码 sizeof(str1) 是整个二维数组的字节数，sizeof(str1[0]) 则是表示里面的一个字符串的长度，因为这三个字符串都是固定长度 32，所以只需要用第一个字符串就可以：

#include <stdio.h>

int main(void)
{
    char str1[][32] = {"To be or not to be",
                       "www.foxdevelop.com",
                       "www.baidu.com",
                       "www.taobao.com"};
    for(int i = 0; i < sizeof(str1) / sizeof(str1[0]); i++)
    {
        printf("%s\n", str1[i]);
    }

    return 0;
}

更改前面的例子，确定二维数组中字符串个数和每个字符串的长度：

#include <stdio.h>

int main(void)
{
    char str[][70] = {
        "Computers do what you tell them to do,not what you want them to do.",
        "When you put somthing in memory,remember where you put it.",
        "Never test for a condition you don't know what to do with."
    };
    unsigned int count = 0;
    unsigned int strCount = sizeof(str) / sizeof(str[0]);
    printf("一共有%u个字符串。\n", strCount);

    for(unsigned int i = 0; i < strCount; i++)
    {
        count = 0;
        while(str[i][count])
            ++count;
        printf("字符串：\"%s\"占%u个字符\n", str[i], count);
    }
    return 0;
}

前面说明了确定字符串长度的代码，但其实并不需要编写这样的代码。标准库提供了一个执行该操作的函，和许多处理字符串的其他函数。要使用他们，必须把 string.h 头文件包含在源文件中。

标准库提供的字符串处理函数集合并不安全，他们使代码包含错误的可能性很大，有时这些错误很难查找。标准库提供了处理字符串函数的可选版本，他们更安全更不容易出错，因为会检查数组的维度，确保空间足够。这些可选函数是以 _s 结尾。

很容易确定 C 编译器附带的标准库是否支持这些可选函数：

#include <stdio.h>
#define __STDC_WANT_LIB_EXT1__ 1
#include <string.h>

int main(void)
{
    #if defined __STDC_LIB_EXT1__
        printf("可选函数有定义\n");
    #else
        printf("可选函数没有有定义\n");
    #endif
    return 0;
}

但是发现编译器不支持 C11。点击 Settings -> Compiler，打开 Global compiler settings 界面，将 “Have g++ follow the C++11 ISO C++ language” 选项打上勾，最后点击 OK，可以设置编译器让它支持 C11。

strnlen 或者 strnlen_s 函数返回字符串的长度，它需要两个参数，一个是字符串的地址另外一个是数组的大小。该函数把字符串的长度返回为一个 size_t 类型的整数值。如果第一个参数是 NULL，就返回 0。如果第二个参数值的元素个数中，第一个参数指定的数组不包括 \0，就返回第二个参数值作为字符串的长度。例如：

以上是 strnlen_s，这是扩展方法但有些编译器不支持。这时候可以使用：

#include <string.h>
#include <stdio.h>

int main(void)
{
    char str[] = "foxdevelop.com";
    printf("%zd", strlen(&str));
}

以上没有使用扩展库，最后返回 14。

扩展库中的 strcpy_s 函数用法如下，它把一个字符串变量的内容赋予另外一个字符串。strcpy_s 三个参数：第一个是复制的目标，第二个是一个整数指定第一个参数的大小，第三个是源字符串。指定目标字符串的长度可以使函数避免覆盖目标字符串最后一个字符后面的内存。如果源字符串比目标字符串长就会发生这种情形。如果一切正常该函数就返回 0 否则返回非 0。

再看标准的复制函数 strcpy()，它会把第二个参数指定的字符串复制到第一个参数指定的位置上，不检查目标字符串的容量：

#include <stdio.h>

int main(void)
{
    char str[] = "foxdevelop.com";
    char str2[8];
    strcpy(str2, str);
    printf("%s", str2);
    return 0;
}

连接是把一个字符串连接到另一个字符串的尾部，这是很常见的需求。例如把两个或多个字符串合成一条信息。strcat_s() 函数需要三个参数，字符串 str1 和 str2 连接在一起，str2 追加到 str1 上。str1 后面的 \0 会被覆盖，然后再在后面添加一个 \0。如果一切正常就返回 0，如果 str1 不够大不能追加 str2 则返回非 0。

由于编译器不支持扩展库，所以只能使用 strcat：

#include <stdio.h>
#include <string.h>

int main(void)
{
    char name[] = "Foxdevelop";
    char str[20] = "foxdevelop.com";
    strcat(&str, &name);
    printf("%s", str);
    return 0;
}

如果是数值，比较两个数很好理解，比如 11 > 3。字符串库提供的函数还可以比较字符串，确定一个字符串是大于还是小于另外一个字符串。两个字符串的比较是基于它们的字符码。如果两个字符串相同则它们相等。要确定第一个字符串是小于还是大于第二个字符串，比较两个字符串中第一对不同的字符。例如如果第一个字符串中某字符的字符码小于第二个字符串中对应的字符，则第一个字符串就小于第二个字符串。

比较字符串没有可选函数，使用的标准函数是 strcmp(str1, str2)，比较两个字符串，返回一个小于、等于或大于 0 的 int 值，分别对应 str1 小于、等于和大于 str2：

#include <stdio.h>

int main(void)
{
    char str1[] = "foxdevelop.cam";
    char str2[] = "foxdevelop.cn";
    int res = strcmp(str1, str2);
    printf("%d", res);
    return 0;
}

strncmp 函数用来比较两个字符串的前 n 个字符，它比 strcmp 多了第三个参数，第三个参数类型是 size_t 用来指定比较的字符数。如果要处理的字符串中表示零件号或序列号的前十个字符，就可以使用这个函数：

#include <stdio.h>

int main(void)
{
    char str1[] = "foxdevelop.cam";
    char str2[] = "foxdevelop.cn";
    int res = strncmp(str1, str2, 6);
    printf("%d", res);
    return 0;
}

头文件 string.h 声明了几个字符串搜索函数，但是在探讨它们之前，先了解一下下一章的主题——指针，这里需要这些基础知识以理解如何使用字符串搜索函数。

指针的概念

C 提供一个非常有用的变量类型叫做指针。指针是含有地址的变量，它含有内存中另一个包含数值的位置的引用。内存有一个编号，每个字节有个编号从 0 开始。函数 scanf 就是使用了地址。下面的第二条语句就定义了指针 pNumber：

int Number = 25;
int *pNumber = &Number;

然后就可以使用 *pNumber 来得到 Number 里面的值。* 是取消引用运算符，其作用是访问指针指定的地址中存储的数据：

#include <stdio.h>

int main(void)
{
    int Number = 25;
    int *pNumber = &Number;
    printf("%d\n", Number);
    printf("%d\n", *pNumber);
    printf("%p\n", pNumber);
    return 0;
}

函数 strchr() 在字符串中搜索给定的字符。它的第一个参数是要搜索的字符串，是 char 数组的地址。第二个参数是要查找的字符。这个函数会从字符串的开头开始搜索，返回在字符串中找到的第一个给定字符的地址。这是一个在内存中的地址，其类型是 char *。所以要存储这个返回值，必须创建一个能存储字符串地址的变量。如果没有找到给定的字符，函数就会返回 NULL。

#include <stdio.h>

int main(void)
{
    char str[] = "foxdevelop.com";
    char ch = 'm';
    char *pch = strchr(str, ch);
    if(pch)
    {
        printf("%p\n", pch);
        printf("%c\n", *pch);
    }
    else
    {
        printf("no found");
    }

    return 0;
}

也可以写成：

#include <stdio.h>

int main(void)
{
    char str[] = "foxdevelop.com";
    char ch = 'm';
    char *pch = strchr(str, ch);
    if(pch)
    {
        printf("%s\n", pch);
    }
    else
    {
        printf("no found");
    }

    return 0;
}

NULL 指针值转换为 bool 值是 false，非 NULL 是 true。所以可以使用 if 来判断是否找到字符。

strstr 函数是所有搜索函数中最有用的函数，它查找一个字符串中的子字符串，返回找到的第一个子字符串的位置指针。同样如果找不到匹配的子字符串就返回 NULL：

#include <stdio.h>

int main(void)
{
    char text[] = "foxdevelop.com";
    char word[] = "mn";
    char *pFound = NULL;
    pFound = strstr(text, word);
    printf("%s", pFound);

    return 0;
}

#include <stdio.h>
#include <string.h>

int main(void)
{
    char str1[] = "This string contains the holy grail.";
    char str2[] = "the holy grail";
    char str3[] = "the holy grill";

    if(strstr(str1, str2) == NULL)
        printf("\n\"%s\" was not found.", str2);
    else
        printf("\n\"%s\" was found in \"%s\"", str2, str1);

    if(strstr(str1, str3) == NULL)
        printf("\n\"%s\" was not found.", str3);
    else
        printf("\nWe shouldn't get to here!");
    return 0;
}

C 库函数 char *strtok(char *str, const char *delim) 分解字符串 str 为一组字符串，delim 为分隔符。该函数返回被分解的第一个子字符串，如果没有可检索的字符串则返回一个空指针：

#include <string.h>
#include <stdio.h>

int main(void)
{
    char str[80] = "This is - www.baidu.com - website";
    const char s[2] = "-";
    char *token;

    token = strtok(str, s);

    while(token != NULL)
    {
        printf("%s\n", token);
        token = strtok(NULL, s);
    }

    return 0;
}

当 strtok() 在参数 s 的字符串中发现参数 delim 中包含的分割字符时，则会将该字符改为 \0 字符。在第一次调用时 strtok() 必需给予参数 s 字符串，往后的调用则将参数 s 设置成 NULL。每次调用成功则返回指向被分割出片段的指针。

下面例子判断从键盘输入的一个字符串中有多少个数字、字母和标点符号：

#include <stdio.h>
#include <ctype.h>

int main(void)
{
    char buffer[80];
    int i = 0;
    int num_letters = 0;
    int num_digits = 0;

    printf("\nEnter an interesting string of less than 80 characters:\n");
    gets(buffer);

    while(buffer[i] != '\0')
    {
        if(isalpha(buffer[i]))
            num_letters++;
        if(isdigit(buffer[i++]))
            num_digits++;
    }
    printf("\nYour string contained %d letters and %d digits.\n",
           num_letters, num_digits);
    return 0;
}

头文件 stdlib.h 声明了一些将字符串转换成数值的函数。这些函数会忽略前导空白：

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    char str[] = "10";
    int num = atoi(str);
    printf("%d", num * 10);
    return 0;
}

练习 1：计算倒数及倒数总和

#include <stdio.h>

int main(void)
{
    double numbers[5] = {0.0};
    double rnums[5] = {0.0};
    double sum = 0.0;

    for(int i = 0; i < 5; i++)
    {
        printf("%d>", i + 1);
        scanf("%lf", &numbers[i]);
        rnums[i] = 1.0 / numbers[i];
        sum += rnums[i];
    }

    for(int i = 0; i < 5; i++)
    {
        printf("%lf\n", rnums[i]);
    }
    printf("倒数总和:%lf\n", sum);

    return 0;
}

练习 2：数列求和

#include <stdio.h>

int main(void)
{
    double numbers[100] = {0.0};
    for(int i = 2; i <= 200; i += 2)
    {
        numbers[i / 2 - 1] = 1.0 / (i * (i + 1) * (i + 2));
    }

    double res = 0.0;
    for(int i = 0; i < 100; i++)
    {
        if(i % 2 == 0)
        {
            res += numbers[i];
        }
        else
        {
            res -= numbers[i];
        }
    }
    res = res * 4.0 + 3.0;
    printf("%lf\n", res);

    return 0;
}

练习 3：二维数组计算并输出

#include <stdio.h>

int main(void)
{
    double data[11][5];

    /* 初始化数组 */
    int row = 0;
    for(double d = 2.0; d <= 3.0; d += 0.1)
    {
        data[row][0] = d;
        data[row][1] = 1.0 / d;
        data[row][2] = d * d;
        data[row][3] = d * d * d;
        data[row][4] = d * d * d * d;
        row++;
    }

    /* 输出标题 */
    printf("%-6s %-10s %-10s %-10s %-10s\n",
           "x", "1/x", "x^2", "x^3", "x^4");

    /* 输出每一行 */
    for(int i = 0; i < 11; i++)
    {
        printf("%-6.1f %-10.4f %-10.4f %-10.4f %-10.4f\n",
               data[i][0], data[i][1], data[i][2], data[i][3], data[i][4]);
    }

    return 0;
}

练习 4：计算多个班级学生的平均分

这个程序支持任意多个班级、任意多个学生。输入时先输入班级数，再依次输入每个班级的学生数，然后输入每个学生的成绩。程序会输出每个学生的平均分以及该班级的平均分。

#include <stdio.h>

int main(void)
{
    int classCount = 0;
    printf("请输入班级数量: ");
    scanf("%d", &classCount);

    for(int c = 0; c < classCount; c++)
    {
        int studentCount = 0;
        printf("\n请输入第 %d 个班级的学生数量: ", c + 1);
        scanf("%d", &studentCount);

        double scores[studentCount];
        double classSum = 0.0;

        printf("请输入第 %d 个班级 %d 名学生的成绩:\n", c + 1, studentCount);
        for(int s = 0; s < studentCount; s++)
        {
            printf("  学生 %d: ", s + 1);
            scanf("%lf", &scores[s]);
            classSum += scores[s];
        }

        /* 输出该班每个学生的成绩和平均分 */
        printf("\n第 %d 个班级学生成绩:\n", c + 1);
        for(int s = 0; s < studentCount; s++)
        {
            printf("  学生 %d 成绩: %.1f, 个人平均分: %.1f\n",
                   s + 1, scores[s], scores[s]);
        }

        /* 输出班级平均分 */
        printf("第 %d 个班级的平均分: %.2f\n\n", c + 1, classSum / studentCount);
    }

    return 0;
}

说明

下面我们来编写一个游戏，让两个人在计算机上玩井字游戏。

游戏是一个 3×3 的方格，两个人轮流在方格中输入标记 X 或 O，谁先使 3 个标记连成水平、垂直或者对角线，谁就是赢家。

实现思路：

1. 使用三行三列的二维数组存储标记
2. 玩家标识为 1 和 2，编号 1 的玩家先玩，轮流输入
3. 用 1~9 标记九个格子，玩家输入方格数字
4. 从方格数字计算行列索引：行 = (choice – 1) / 3，列 = (choice – 1) % 3
5. 每次轮完后检查是否有玩家获胜
6. 游戏在有人获胜或轮完 9 次后结束

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

int main(void)
{
    int board[3][3] = {0};               /* 3x3棋盘，0表示空 */
    int player = 1;                      /* 当前玩家 1或2 */
    int choice = 0;                      /* 玩家选择 1-9 */
    int row = 0, col = 0;                /* 行列索引 */
    int turns = 0;                       /* 已进行的回合数 */
    int winner = 0;                      /* 获胜者 0表示无 */

    printf("井字游戏 (Tic-Tac-Toe)\n");
    printf("玩家1用 X，玩家2用 O\n");
    printf("格子编号 1-9，布局如下：\n");
    printf(" 1 | 2 | 3 \n");
    printf("---+---+---\n");
    printf(" 4 | 5 | 6 \n");
    printf("---+---+---\n");
    printf(" 7 | 8 | 9 \n\n");

    while(turns < 9 && winner == 0)
    {
        /* 显示当前棋盘 */
        printf("\n");
        for(int i = 0; i < 3; i++)
        {
            for(int j = 0; j < 3; j++)
            {
                if(board[i][j] == 0)
                    printf("   ");
                else if(board[i][j] == 1)
                    printf(" X ");
                else
                    printf(" O ");
                if(j < 2) printf("|");
            }
            printf("\n");
            if(i < 2) printf("---+---+---\n");
        }

        /* 当前玩家输入 */
        printf("\n玩家%d (%c) 请选择格子 (1-9): ",
               player, player == 1 ? 'X' : 'O');
        scanf("%d", &choice);

        /* 验证输入 */
        if(choice < 1 || choice > 9)
        {
            printf("无效选择，请选择1-9之间的数字！\n");
            continue;
        }

        row = (choice - 1) / 3;
        col = (choice - 1) % 3;

        if(board[row][col] != 0)
        {
            printf("该格子已被占用，请重新选择！\n");
            continue;
        }

        /* 放置标记 */
        board[row][col] = player;
        turns++;

        /* 检查获胜 */
        /* 检查行 */
        for(int i = 0; i < 3; i++)
        {
            if(board[i][0] == player && board[i][1] == player && board[i][2] == player)
                winner = player;
        }
        /* 检查列 */
        for(int j = 0; j < 3; j++)
        {
            if(board[0][j] == player && board[1][j] == player && board[2][j] == player)
                winner = player;
        }
        /* 检查对角线 */
        if(board[0][0] == player && board[1][1] == player && board[2][2] == player)
            winner = player;
        if(board[0][2] == player && board[1][1] == player && board[2][0] == player)
            winner = player;

        /* 切换玩家 */
        if(winner == 0)
            player = (player == 1) ? 2 : 1;
    }

    /* 显示最终棋盘 */
    printf("\n最终棋盘：\n");
    for(int i = 0; i < 3; i++)
    {
        for(int j = 0; j < 3; j++)
        {
            if(board[i][j] == 0)
                printf("   ");
            else if(board[i][j] == 1)
                printf(" X ");
            else
                printf(" O ");
            if(j < 2) printf("|");
        }
        printf("\n");
        if(i < 2) printf("---+---+---\n");
    }

    if(winner != 0)
        printf("\n恭喜玩家%d (%c) 获胜！\n", winner, winner == 1 ? 'X' : 'O');
    else
        printf("\n平局！\n");

    return 0;
}

井字游戏（Tic-Tac-Toe）

步骤 1：添加主游戏循环和显示棋盘

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int player = 0;                       /* 当前玩家号码 1或者2 */
    int winner = 0;                       /* 赢了的玩家号码 */
    char board[3][3] = {
        {'1','2','3'},
        {'4','5','6'},
        {'7','8','9'}
    };

    /* 至多需要输入九次 */
    for(unsigned int i = 0; i < 9 && winner == 0; i++)
    {
        printf("\n");
        printf(" %c | %c | %c \n", board[0][0], board[0][1], board[0][2]);
        printf("---+---+---\n");
        printf(" %c | %c | %c \n", board[1][0], board[1][1], board[1][2]);
        printf("---+---+---\n");
        printf(" %c | %c | %c \n", board[2][0], board[2][1], board[2][2]);

        player = i % 2 + 1;              /* 切换玩家 */
        /* 玩家选择 */
    }

    /* 输出游戏结果 */
    return 0;
}

步骤 2：让玩家选择方格并验证有效性

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int player = 0;                       /* 当前玩家号码 1或者2 */
    int winner = 0;                       /* 赢了的玩家号码 */
    int choice = 0;                       /* 选择的方格标记 */
    unsigned int row = 0;                 /* 行的索引 */
    unsigned int column = 0;              /* 列的索引 */

    char board[3][3] = {
        {'1','2','3'},
        {'4','5','6'},
        {'7','8','9'}
    };

    /* 至多需要输入九次 */
    for(unsigned int i = 0; i < 9 && winner == 0; i++)
    {
        printf("\n");
        printf(" %c | %c | %c \n", board[0][0], board[0][1], board[0][2]);
        printf("---+---+---\n");
        printf(" %c | %c | %c \n", board[1][0], board[1][1], board[1][2]);
        printf("---+---+---\n");
        printf(" %c | %c | %c \n", board[2][0], board[2][1], board[2][2]);

        player = i % 2 + 1;              /* 切换玩家 */

        do
        {
            printf("玩家%d,请选择要填写的有效标记，之后在该标记会填充%c：", player, player == 1 ? 'X' : 'O');
            scanf("%d", &choice);
            row = --choice / 3;
            column = choice % 3;
        }
        while(choice < 0 || choice > 8 || board[row][column] > '9'); /* board[row][column]>'9' 表示已经填充了X或者O */

        board[row][column] = (player == 1) ? 'X' : 'O';
    }

    /* 输出游戏结果 */
    return 0;
}

步骤 3：添加检查获胜逻辑

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int player = 0;                       /* 当前玩家号码 1或者2 */
    int winner = 0;                       /* 赢了的玩家号码 */
    int choice = 0;                       /* 选择的方格标记 */
    unsigned int row = 0;                 /* 行的索引 */
    unsigned int column = 0;              /* 列的索引 */

    char board[3][3] = {
        {'1','2','3'},
        {'4','5','6'},
        {'7','8','9'}
    };

    /* 至多需要输入九次 */
    for(unsigned int i = 0; i < 9 && winner == 0; i++)
    {
        printf("\n");
        printf(" %c | %c | %c \n", board[0][0], board[0][1], board[0][2]);
        printf("---+---+---\n");
        printf(" %c | %c | %c \n", board[1][0], board[1][1], board[1][2]);
        printf("---+---+---\n");
        printf(" %c | %c | %c \n", board[2][0], board[2][1], board[2][2]);

        player = i % 2 + 1;              /* 切换玩家 */

        do
        {
            printf("玩家%d,请选择要填写的有效标记，之后在该标记会填充%c：", player, player == 1 ? 'X' : 'O');
            scanf("%d", &choice);
            row = --choice / 3;
            column = choice % 3;
        }
        while(choice < 0 || choice > 8 || board[row][column] > '9');

        board[row][column] = (player == 1) ? 'X' : 'O';

        /* 检查有没有胜出 */
        if((board[0][0] == board[1][1] && board[1][1] == board[2][2])
           ||
           (board[0][2] == board[1][1] && board[1][1] == board[2][0]))
        {
            winner = player;
        }
        else
        {
            for(int i = 0; i <= 2; i++)
            {
                if((board[i][0] == board[i][1] && board[i][1] == board[i][2])
                   ||
                   (board[0][i] == board[1][i] && board[2][i] == board[1][i]))
                {
                    winner = player;
                    break;
                }
            }
        }
    }

    /* 输出游戏结果 */
    return 0;
}

步骤 4：显示最终棋盘和比赛结果

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int player = 0;                       /* 当前玩家号码 1或者2 */
    int winner = 0;                       /* 赢了的玩家号码 */
    int choice = 0;                       /* 选择的方格标记 */
    unsigned int row = 0;                 /* 行的索引 */
    unsigned int column = 0;              /* 列的索引 */

    char board[3][3] =
    {
        {'1','2','3'},
        {'4','5','6'},
        {'7','8','9'}
    };

    /* 至多需要输入九次 */
    for(unsigned int i = 0; i < 9 && winner == 0; i++)
    {
        printf("\n");
        printf(" %c | %c | %c \n", board[0][0], board[0][1], board[0][2]);
        printf("---+---+---\n");
        printf(" %c | %c | %c \n", board[1][0], board[1][1], board[1][2]);
        printf("---+---+---\n");
        printf(" %c | %c | %c \n", board[2][0], board[2][1], board[2][2]);

        player = i % 2 + 1;              /* 切换玩家 */

        do
        {
            printf("玩家%d,请选择要填写的有效标记，之后在该标记会填充%c：", player, player == 1 ? 'X' : 'O');
            scanf("%d", &choice);
            row = --choice / 3;
            column = choice % 3;
        }
        while(choice < 0 || choice > 8 || board[row][column] > '9');

        board[row][column] = (player == 1) ? 'X' : 'O';

        /* 检查有没有胜出 */
        if((board[0][0] == board[1][1] && board[1][1] == board[2][2])
                ||
                (board[0][2] == board[1][1] && board[1][1] == board[2][0]))
        {
            winner = player;
        }
        else
        {
            for(int i = 0; i <= 2; i++)
            {
                if((board[i][0] == board[i][1] && board[i][1] == board[i][2])
                        ||
                        (board[0][i] == board[1][i] && board[2][i] == board[1][i]))
                {
                    winner = player;
                    break;
                }
            }
        }
    }

    /* 输出最终棋盘 */
    printf("\n");
    printf(" %c | %c | %c \n", board[0][0], board[0][1], board[0][2]);
    printf("---+---+---\n");
    printf(" %c | %c | %c \n", board[1][0], board[1][1], board[1][2]);
    printf("---+---+---\n");
    printf(" %c | %c | %c \n", board[2][0], board[2][1], board[2][2]);

    if(winner > 0)
    {
        printf("玩家%d赢了", player);
    }
    else
    {
        printf("本局平手");
    }

    return 0;
}

我们经常需要在程序中存储某种类型的大量数据值。例如编写一个程序，追踪一只篮球队的成绩，就要存储一个赛季各场分数和各个球员得分。我们可以使用前面学过的知识为每个分数使用不同的变量。然而，如果一个赛季有非常多的赛事，这会非常频繁，因为有球赛的每个球员都需要许多变量。这显然不理想。

理想情况应该把这些变量集中在一个名称下面，这样就不需要定义多个变量了。

计算平均分的问题

我们通过一个例子来了解数组。这个例子是计算某班学生的平均分数。假设该班有十个学生。计算一组数字的平均值，要将它们全加起来，再除以数字的个数。

#include <stdio.h>

int main(void)
{
    int number = 0;                      /* 存储输入的分数*/
    int count = 10;                      /* 学生的个数 */
    long sum = 0L;                       /* 总分          */
    float average = 0.0f;                /* 平均分*/

    /* 读十个数的平均数 */
    for(int i = 0; i < count; i ++)
    {
        printf("输入一个学生的成绩: ");
        scanf("%d", &number);              /* 读取一个数 */
        sum += number;                     /* 累加到sum*/
    }

    average = (float)sum / count;          /* 计算平均数 */

    printf("\n输入的十个数字的平均值是: %f\n", average);
    return 0;
}

这个程序只对平均值感兴趣，所以累加输入的数然后输出平均值。如果要将其开发为更复杂的程序，需要输入一些数值，再输出每个人的分数，最后输出平均分，上面的代码就无法实现了，因为 number 每次都被覆盖了，不能再次使用。

如何存储所有的分数，可以声明十个整数，但是这样不能用 for 循环输入，而且必须添加代码逐个读入，太麻烦了。

#include <stdio.h>

int main(void)
{
    int number0 = 0, number1 = 0, number2 = 0, number3 = 0, number4 = 0;
    int number5 = 0, number6 = 0, number7 = 0, number8 = 0, number9 = 0;

    long sum = 0L;          /* Sum of the numbers     */
    float average = 0.0f;   /* Average of the numbers */

    /* Read the ten numbers to be averaged */
    printf("输入一到五个数字,\n");
    printf("每个数字用空格隔开，输入完成按回车键.\n");
    scanf("%d%d%d%d%d", &number0, &number1, &number2, &number3, &number4);
    printf("输入后面五个数字,\n");
    printf("每个数字用空格隔开，输入完成按回车键.\n");
    scanf("%d%d%d%d%d", &number5, &number6, &number7, &number8, &number9);

    /* Now we have the ten numbers, we can calculate the average */
    sum = number0 + number1 + number2 + number3 + number4 +
          number5 + number6 + number7 + number8 + number9;
    average = (float)sum / 10.0f;

    printf("\n平均数是: %f\n", average);
    return 0;
}

数组的概念

数组是一组数目固定、类型相同的数据项，数组中的数据项称为元素。数组中的元素都是 int、long 或者其他类型。

下面是数组声明，非常类似于声明一个含有单一数值的正常变量，但要在名称后面的方括号中放置一个数：

long numbers[10];

方括号中的数字定义了要存放在数组中的元素个数，称为数组维。存储在数组中的每个数据项都用相同的名称访问，在这个例子中，该名称就是 numbers。要选择某个元素，可以在数组名称后的方括号内使用索引值。索引值从 0 开始，最后一个是 9。所以第一个元素就是 numbers[0]，第二个是 numbers[1]，最后一个是 numbers[9]。

索引值从 0 开始，不是 1。这一点大家一定要牢记。很多初学者在这个地方犯错。

如果访问的时候索引超过这个数组的合法范围，比如上面如果访问 numbers[10]，这个时候就可能程序不能正常运行。编译器检查不出这种错误，所以程序仍可以编译，但是执行有问题。有些时候甚至会覆盖重要信息，导致电脑锁死，需要重启计算机。所以大家要注意避免这个问题。

此外，定义的时候 long numbers[10] 这个地方的 10 并不是索引的意思，而是表示这个数组有十个元素。这点与直接访问比如 numbers[10] 的 10 是不同的概念。long numbers[10] 是声明，numbers[10] 是操作某个元素，当然在这里会超出了范围。

#include <stdio.h>

int main(void)
{
    long numbers[10];
    printf("%ld", numbers[10]); //访问了第十一个元素 可能会访问到一些垃圾数据

    return 0;
}

下面使用数组知识来解决平均分的问题：

#include <stdio.h>

int main(void)
{
    int numbers[10];                     /* 声明有十个元素的数组*/
    int count = 10;                      /* 读取数据数量 */
    long sum = 0L;                       /* 存储总数          */
    float average = 0.0f;                /* 平均数*/

    printf("\n输入十个数:\n");       /* 提示输入 */

    /* 读取十个数 */
    for(int i = 0; i < count; i ++)
    {
        printf("%2d> ", i + 1);
        scanf("%d", &numbers[i]);          /* 读取十个数到数组里的十个元素 */
        sum += numbers[i];                 /* 累加 */
    }

    for(int i = 0; i < count; i++)
    {
        printf("\n序号：%d 分数：%d", i + 1, numbers[i]);
    }

    average = (float)sum / count;          /* 计算平均数*/

    printf("\n十个数的平均数是: %f\n", average);
    return 0;
}

内存地址与寻址运算符

寻址运算符 & 输出其操作数的内存地址。前面使用了寻址运算符 &，它广泛用在 scanf() 函数。& 放在变量前面，scanf 需要用到这个变量的地址，scanf 内部可以利用这个地址去修改对应的变量的值。

#include <stdio.h>

int main(void)
{
    /* 定义一些整数变量 */
    long a = 1L;
    long b = 2L;
    long c = 3L;

    /* 声明一些浮点变量 */
    double d = 4.0;
    double e = 5.0;
    double f = 6.0;

    printf("long类型的变量占用%u个字节。", sizeof(long));
    printf("\n这是一些long类型变量的地址:");
    printf("\na的地址是：%p，\nb的地址是：%p", &a, &b);
    printf("\nc的地址是：%p", &c);
    printf("\n\ndouble类型的变量占用%d字节。", sizeof(double));
    printf("\n这是一些double类型变量的地址：");
    printf("\nd的地址是：%p，\ne的地址是：%p", &d, &e);
    printf("\nf的地址是：%p\n", &f);
    return 0;
}

%u 是显示 sizeof 生成的值，它是无符号的整数。%p 是一个新的格式说明符，用来输出一个内存地址，其值为十六进制。内存地址一般是 32 位或者 64 位，地址的大小取决于引用的最大内存量。

声明一个包含 4 个元素的数组：

long number[4];

获取数组元素地址的方式类似普通变量：

#include <stdio.h>

int main(void)
{
    int value = 0;
    printf("\n%p", &value);

    long number[4];
    printf("\n%p\n", &number[2]);

    int data[5];
    for(int i = 0; i < 5; i++)
    {
        data[i] = 12 * (i + 1);
        printf("data[%d] 地址是：%p 值是：%d\n", i, &data[i], data[i]);
    }

    return 0;
}

数组初始化

为了安全起见，预先确定元素的初始值。可以使用大括号并且用逗号隔开，来给数组的元素初始化：

double values[5] = {1.5, 2.5, 3.5, 4.5, 5.5};

前三个元素的值就是 1.5、2.5、3.5，后面两个元素初始化值为 0。

如果没有给元素提供初值，编译器会给它们提供初值 0，所以初值提供了一种把整个数组初始化为 0 的简单方式，只需要给一个元素提供 0：

double values[5] = {0.0};

这样整个数组都初始化为 0.0。

如果初始值超过元素个数，有些编译器就会报错。

可以不指定数组的大小，让编译器从该列值中推断出元素的个数：

int primes[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

以上数组的长度就是 10。

#include <stdio.h>

int main(void)
{
    double numbers[] = {0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5};
    printf("%.2lf\n", numbers[3]);

    return 0;
}

sizeof 运算符

sizeof 可以计算指定类型的变量所占的字节数：

printf("%zu", sizeof(long));

sizeof 也可以用于数组：

double values[5] = {1.5, 2.5, 3.5, 4.5, 5.5};
printf("%zu", sizeof values);

也可以使用表达式 sizeof values[0] 来计算数组中一个元素所占的字节数。可以通过如下运算来求出数组中的元素的数目：

size_t elementCount = sizeof values / sizeof values[0];

在使用循环处理中的所有元素时，可以使用 sizeof：

#include <stdio.h>

int main(void)
{
    printf("%zu\n", sizeof(double));
    double numbers[] = {0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5};
    printf("%zu\n", sizeof numbers);
    printf("数组的元素个数：%u", sizeof numbers / sizeof(double));

    for(int i = 0; i < sizeof numbers / sizeof(double); i++)
    {
        printf("\n%.1lf", numbers[i]);
    }
    return 0;
}

多维数组

一个数组里面可以存储多个相同类型的数据，这个我们叫做一维数组。比如 float arr[5]。下面介绍二维数组：

float carrots[25][50];
float numbers[3][5];

虽然在内存中存储实际上还是顺序存储在内存中，但是我们可以把它想象成三行五列的表格。

二维数组的初始化类似于一维数组，区别是把每一行的初始值放在大括号中 {}，再把所有行放在一堆大括号中。如果指定的初始值少于一行的元素，这些值会从每行的第一个元素开始，依序赋予各个元素，剩下未指定初值的元素则初始化为 0。

int numbers[3][4] = {0};

三维数组可以理解为我们有四块地，每块地 10 行 20 列：

double beans[4][10][20];

要处理多维数组中的所有元素，需要一个嵌套循环，嵌套的层数就是数组的维数：

#include <stdio.h>

int main(void)
{
    int numbers3[3][3][5] =
    {
        {
            {1, 2, 3, 4, 5},
            {1, 2, 3, 4, 5},
            {1, 2, 3, 4, 5}
        },
        {
            {1, 2, 3, 4, 5},
            {1, 2, 3, 4, 5},
            {1, 2, 3, 4, 5}
        },
        {
            {1, 2, 3, 4, 5},
            {1, 2, 3, 4, 5},
            {1, 2, 3, 4, 5}
        }
    };

    int sum = 0;
    for(int i = 0; i < 3; i++)
    {
        for(int j = 0; j < 3; j++)
        {
            for(int k = 0; k < 5; k++)
            {
                sum += numbers3[i][j][k];
            }
        }
    }

    printf("%d", sum);
    return 0;
}

使用 sizeof 可以确定多维数组中每一维的元素个数：

#include <stdio.h>

int main(void)
{
    int numbers3[3][3][5] =
    {
        {
            {1, 2, 3, 4, 5},
            {1, 2, 3, 4, 5},
            {1, 2, 3, 4, 5}
        },
        {
            {1, 2, 3, 4, 5},
            {1, 2, 3, 4, 5},
            {1, 2, 3, 4, 5}
        },
        {
            {1, 2, 3, 4, 5},
            {1, 2, 3, 4, 5},
            {1, 2, 3, 4, 5}
        }
    };

    int sum = 0;
    for(int i = 0; i < sizeof(numbers3) / sizeof(numbers3[0]); i++)
    {
        for(int j = 0; j < sizeof(numbers3[0]) / sizeof(numbers3[0][0]); j++)
        {
            for(int k = 0; k < sizeof(numbers3[0][0]) / sizeof(numbers3[0][0][0]); k++)
            {
                sum += numbers3[i][j][k];
            }
        }
    }

    printf("%d", sum);
    return 0;
}

变长数组

前面的所有数组都在代码中指定了固定的长度，也可以定义其长度在程序运行期间确定。

#include <stdio.h>

int main(void)
{
    size_t len = 0;
    printf("请输入数组长度:");
    scanf("%zd", &len);
    float numbers[len];

    numbers[3] = 1.2f;
    printf("%f", numbers[3]);

    return 0;
}

也可以在执行期间确定二维或多维数组：

#include <stdio.h>

int main(void)
{
    size_t len = 0;
    printf("请输入数组长度:");
    scanf("%zd", &len);

    size_t len2 = 0;
    printf("请输入数组长度:");
    scanf("%zd", &len2);

    float numbers[len][len2];

    numbers[3][2] = 1.2f;
    printf("%f", numbers[3][2]);

    return 0;
}

下面的代码可以检查编译器是否支持变长数组：

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    #ifdef __STDC_NO_VLA__
        printf("不支持");
        exit(1);
    #endif

    return 0;
}

使用变长数组计算平均分：

#include <stdio.h>

int main(void)
{
    size_t len = 0;
    printf("请输入学生个数:");
    scanf("%zd", &len);

    int grades[len];
    long sum = 0L;
    float average = 0.0f;

    printf("输入学生分数\n");

    for(size_t i = 0; i < len; ++i)
    {
        printf("%2zd>", i + 1);
        scanf("%d", &grades[i]);
        sum += grades[i];
    }

    printf("分数\n");

    for(size_t i = 0; i < len; ++i)
    {
        printf("grades[%2zd]=%3d", i, grades[i]);

        if((i + 1) % 5 == 0)
            printf("\n");
    }

    average = (float)sum / len;
    printf("\n %zd 个学生的平均分是 : %.2f\n", len, average);

    return 0;
}

编写一个简单的 simon 游戏，这是一个记忆测试游戏。计算机会在屏幕将一串数字显示很短时间，玩家必须在数字消失之前记住他们，然后输入这串数字。每次过关后，计算机会显示更长一串数字，让玩家继续玩下去，玩家尽可能使这个过程重复更多次数。

分析

程序的逻辑很简单，程序必须产生一连串 0~9 的整数，使它们在屏幕上显示一秒钟，之后删除它们。

解决方案

步骤 1：确定代码基本功能块，包括游戏的主循环

#include <stdio.h>                     /* 使用 input 和 output   */
#include <ctype.h>                     /* 使用 toupper() function */
#include <stdbool.h>                   /* 使用 bool, true, false  */
#include <stdlib.h>                    /* 使用 rand() 和 srand() */
#include <time.h>                      /* 使用 time() 和 clock() */

int main(void)
{
    /* 记录是否要玩另一个游戏 */
    char another_game = 'Y';

    /* 如果输入正确的序列，则为true，否则为false */
    int correct = false;

    /* 成功输入的序列数          */
    int counter = 0;

    int sequence_length = 0;     /* 序列中的位数        */
    time_t seed = 0;             /* 随机数序列的种子值 */
    int number = 0;              /* 存储输入数字*/

    time_t now = 0;            /* 存储随机值的当前时间种子  */
    int time_taken = 0;        /* 游戏时间（秒） */

    /* 描述游戏是如何进行的 */
    printf("\n准备玩简单的Simon游戏, ");
    printf("观察屏幕上的数字序列.");
    printf("\n小心观察，因为数字只显示出来几秒");
    printf("\n计算机将删除它们，然后提示您输入相同的序列.");
    printf("\n当你这样做时，你必须在数字之间加空格. \n");
    printf("\n祝你好运！\n按回车键开始\n");
    scanf("%c", &another_game);

    /* 一个外循环迭代就是一个游戏 */
    do
    {
        correct = true;         /* 默认情况下，表示输入的顺序正确 */
        counter = 0;            /* 初始化成功尝试次数的计数*/
        sequence_length = 2;    /* 数字序列的初始长度*/
        time_taken = clock();  /* 在游戏开始时记录当前时间*/

        /* 只要序列输入正确，内环就继续 */
        while(correct)
        {
            /* 每三次成功尝试，增加序列长度 */
            sequence_length += counter++ % 3 == 0;

            /* 将seed设置为自1970年1月1日以来的秒数  */
            seed = time(NULL);

            now = clock();                  /* 记录序列的开始时间  */

            /* 生成数字序列并显示数字 */
            srand((unsigned int)seed);      /* 初始化随机序列 */
            for(int i = 1; i <= sequence_length; i++)
                printf("%d ", rand() % 10);    /* 输出随机数字          */

            /* 等一秒 */
            for( ; clock() - now < CLOCKS_PER_SEC; );

            /* 现在重写数字序列 */
            printf("\r");                   /* 转到行首 */
            for(int i = 1; i <= sequence_length; i++)
                printf("  ");                 /* 输出空白 覆盖 */

            if(counter == 1)           /* 只输出第一次尝试的消息 */
                printf("\n现在输入序列-不要忘记空格\n");
            else
                printf("\r");                /* 回到行首 */

            /* 对照原始数字检查输入序列 */
            srand((unsigned int)seed);     /* 重新启动随机序列    */
            for(int i = 1; i <= sequence_length; i++)
            {
                scanf("%d", &number);         /* 读取输入数字         */
                if(number != rand() % 10)     /* 与随机数比较 */
                {
                    correct = false;            /* 输入错误             */
                    break;                      /* 无需进一步检查... */
                }
            }
            printf("%s\n", correct ? "对的!" : "错的!");
        }

        /* 计算玩游戏的总时间（秒）*/
        time_taken = (clock() - time_taken) / CLOCKS_PER_SEC;

        /* 输出游戏分数 */
        printf("\n\n 你的分数是 %d", --counter * 100 / time_taken);

        fflush(stdin);

        /* 检查是否需要新游戏*/
        printf("\n你想再玩一次吗 (y/n)? ");
        scanf("%c", &another_game);

    }
    while(toupper(another_game) == 'Y');
    return 0;
}

程序分解：游戏循环控制

1. 首先完成游戏是否继续玩，输入 y 则继续，输入 n 则结束。

#include <stdio.h>
#include <ctype.h>

int main(void)
{
    char isPlayAgain = 'Y';
    do
    {
        printf("\n玩了一次游戏");

        fflush(stdin); //清空输入缓冲区，通常是为了确保不影响后面的数据读取
        printf("\n你想再玩一次吗 (y/n)? ");
        scanf("%c", &isPlayAgain);
    }
    while(tolower(isPlayAgain) == 'y');
    printf("\n游戏结束");

    return 0;
}

Code::Blocks 语法纠错功能（红色波浪线）

菜单栏 Plugins（插件）下拉找到 Manage Plugins，点开找到 SpellChecker，将它设置为 Disable 即可。

程序分解：Simon 游戏逐步实现

1. 游戏循环控制

#include <stdio.h>
#include <ctype.h>

int main(void)
{
    char isPlayAgain = 'Y';
    do
    {
        printf("\n玩了一次游戏");

        fflush(stdin); //清空输入缓冲区，通常是为了确保不影响后面的数据读取
        printf("\n你想再玩一次吗 (y/n)? ");
        scanf("%c", &isPlayAgain);
    }
    while(tolower(isPlayAgain) == 'y');
    printf("\n游戏结束");

    return 0;
}

2. 输出随机序列

#include <stdio.h>
#include <ctype.h>
#include <time.h>

int main(void)
{
    time_t seed = 0; //随机数序列的种子值
    char isPlayAgain = 'Y';
    int seqLength = 2; //一开始数字序列长度为2 后面 根据猜对情况 每次递增1
    do
    {
        //将seed设置为自1970年1月1日以来的秒数 存储起来后面有用
        seed = time(NULL);

        srand((unsigned int)seed); //初始化随机序列

        //输出随机数字
        for(int i = 1; i <= seqLength; i++)
        {
            printf("%d ", rand() % 10); //只输出1到9
        }

        fflush(stdin);
        printf("\n你想再玩一次吗 (y/n)? ");
        scanf("%c", &isPlayAgain);
    }
    while(tolower(isPlayAgain) == 'y');

    return 0;
}

3. 显示一秒后隐藏序列

#include <stdio.h>
#include <ctype.h>
#include <time.h>

int main(void)
{
    time_t seed = 0;
    char isPlayAgain = 'Y';
    int seqLength = 2;
    time_t now = 0;

    do
    {
        seed = time(NULL);
        srand((unsigned int)seed);
        now = clock();

        for(int i = 1; i <= seqLength; i++)
        {
            printf("%d ", rand() % 10);
        }

        //等一秒
        for( ; clock() - now < CLOCKS_PER_SEC; );

        //现在重写数字序列
        printf("\r");
        for(int i = 1; i <= seqLength; i++)
        {
            printf("  ");
        }

        fflush(stdin);
        printf("\n你想再玩一次吗 (y/n)? ");
        scanf("%c", &isPlayAgain);
    }
    while(tolower(isPlayAgain) == 'y');

    return 0;
}

4. 随机数种子复用验证

#include <stdio.h>
#include <time.h>

int main(void)
{
    time_t seed = time(NULL);

    srand((unsigned int)seed);

    printf("第一次输出\n");
    for(int i = 1; i <= 5; i++)
    {
        printf("%d ", rand() % 10);
    }

    printf("\n");

    srand((unsigned int)seed);
    printf("第二次输出\n");
    for(int i = 1; i <= 5; i++)
    {
        printf("%d ", rand() % 10);
    }
    printf("\n");

    return 0;
}

5. 检查用户输入

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

int main(void)
{
    time_t seed = 0;
    char isPlayAgain = 'Y';
    int seqLength = 2;
    time_t now = 0;
    int number = 0;
    int correct = true;

    do
    {
        seed = time(NULL);
        srand((unsigned int)seed);
        now = clock();

        for(int i = 1; i <= seqLength; i++)
        {
            printf("%d ", rand() % 10);
        }

        for( ; clock() - now < CLOCKS_PER_SEC; );

        printf("\r");
        for(int i = 1; i <= seqLength; i++)
        {
            printf("  ");
        }
        printf("\r");

        //对照原始数字检查输入序列
        srand((unsigned int)seed);
        for(int i = 1; i <= seqLength; i++)
        {
            scanf("%d", &number);
            if(number != rand() % 10)
            {
                correct = false;
                break;
            }
        }
        printf("%s\n", correct ? "对的!" : "错的!");

        fflush(stdin);
        printf("\n你想再玩一次吗 (y/n)? ");
        scanf("%c", &isPlayAgain);
    }
    while(tolower(isPlayAgain) == 'y');

    return 0;
}

6. 加入内层循环，答错才退出

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

int main(void)
{
    time_t seed = 0;
    char isPlayAgain = 'Y';
    int seqLength = 2;
    time_t now = 0;
    int number = 0;
    int correct = true;

    do
    {
        while(correct)
        {
            seed = time(NULL);
            srand((unsigned int)seed);
            now = clock();

            for(int i = 1; i <= seqLength; i++)
            {
                printf("%d ", rand() % 10);
            }

            for( ; clock() - now < CLOCKS_PER_SEC; );

            printf("\r");
            for(int i = 1; i <= seqLength; i++)
            {
                printf("  ");
            }
            printf("\r");

            srand((unsigned int)seed);
            for(int i = 1; i <= seqLength; i++)
            {
                scanf("%d", &number);
                if(number != rand() % 10)
                {
                    correct = false;
                    break;
                }
            }
            printf("%s\n", correct ? "对的!" : "错的!");
        }

        fflush(stdin);
        printf("\n你想再玩一次吗 (y/n)? ");
        scanf("%c", &isPlayAgain);
    }
    while(tolower(isPlayAgain) == 'y');

    return 0;
}

7. 每答对三次递增序列长度

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

int main(void)
{
    time_t seed = 0;
    char isPlayAgain = 'Y';
    int seqLength = 2;
    time_t now = 0;
    int number = 0;
    int correct = true;
    int counter = 0;

    do
    {
        while(correct)
        {
            if(counter > 0 && counter % 3 == 0)
            {
                seqLength++;
            }

            seed = time(NULL);
            srand((unsigned int)seed);
            now = clock();

            for(int i = 1; i <= seqLength; i++)
            {
                printf("%d ", rand() % 10);
            }

            for( ; clock() - now < CLOCKS_PER_SEC; );

            printf("\r");
            for(int i = 1; i <= seqLength; i++)
            {
                printf("  ");
            }
            printf("\r");

            srand((unsigned int)seed);
            for(int i = 1; i <= seqLength; i++)
            {
                scanf("%d", &number);
                if(number != rand() % 10)
                {
                    correct = false;
                    break;
                }
            }
            printf("%s\n", correct ? "对的!" : "错的!");

            if(correct)
            {
                counter++;
            }
        }

        fflush(stdin);
        printf("\n你想再玩一次吗 (y/n)? ");
        scanf("%c", &isPlayAgain);
    }
    while(tolower(isPlayAgain) == 'y');

    return 0;
}

8. 计算分数

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

int main(void)
{
    time_t seed = 0;
    char isPlayAgain = 'Y';
    time_t now = 0;
    int number = 0;

    do
    {
        int seqLength = 2;
        int correct = true;
        int counter = 0;

        int timeStart = clock();
        while(correct)
        {
            if(counter > 0 && counter % 3 == 0)
            {
                seqLength++;
            }

            seed = time(NULL);
            srand((unsigned int)seed);
            now = clock();

            for(int i = 1; i <= seqLength; i++)
            {
                printf("%d ", rand() % 10);
            }

            for( ; clock() - now < CLOCKS_PER_SEC; );

            printf("\r");
            for(int i = 1; i <= seqLength; i++)
            {
                printf("  ");
            }
            printf("\r");

            srand((unsigned int)seed);
            for(int i = 1; i <= seqLength; i++)
            {
                scanf("%d", &number);
                if(number != rand() % 10)
                {
                    correct = false;
                    break;
                }
            }
            printf("%s\n", correct ? "对的!" : "错的!");

            if(correct)
            {
                counter++;
            }
        }

        int timeSpan = (clock() - timeStart) / CLOCKS_PER_SEC;
        printf("\n\n 你的分数是 %d", counter * 100 / timeSpan);

        fflush(stdin);
        printf("\n你想再玩一次吗 (y/n)? ");
        scanf("%c", &isPlayAgain);
    }
    while(tolower(isPlayAgain) == 'y');

    return 0;
}

练习题

练习 1：乘法表

#include <stdio.h>

int main(void)
{
    int size = 0;
    printf("请输入乘法表的大小: ");
    scanf("%d", &size);

    for(int i = 1; i <= size; i++)
    {
        for(int j = 1; j <= size; j++)
        {
            printf("%d\t", i * j);
        }
        printf("\n");
    }

    return 0;
}

练习 2：输出可打印字符（0~127）

#include <stdio.h>
#include <ctype.h>

int main(void)
{
    for(int code = 0; code <= 127; code++)
    {
        if(isgraph(code))
        {
            printf("code: %3d  ->  %c\n", code, (char)code);
        }
    }
    return 0;
}

练习 3：空白字符输出名称

#include <stdio.h>
#include <ctype.h>

int main(void)
{
    for(int code = 0; code <= 127; code++)
    {
        if(isgraph(code))
        {
            printf("code: %3d  ->  %c\n", code, (char)code);
        }
        else if(code == '\n')
        {
            printf("code: %3d  ->  newline\n", code);
        }
        else if(code == '\t')
        {
            printf("code: %3d  ->  tab\n", code);
        }
        else if(code == ' ')
        {
            printf("code: %3d  ->  space\n", code);
        }
    }
    return 0;
}

练习 4：修改猜谜游戏（基于 rand 值域）

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main(void)
{
    int chosen = 0;
    int guess = 0;
    int limit = RAND_MAX / 100; //利用rand()整个值域来确定随机数值

    srand(time(NULL));
    chosen = rand() % limit + 1;

    printf("猜一个 1 到 %d 之间的数字: ", limit);
    while(1)
    {
        scanf("%d", &guess);
        if(guess == chosen)
        {
            printf("猜中了!\n");
            break;
        }
        else if(guess < chosen)
        {
            printf("太小了，再试: ");
        }
        else
        {
            printf("太大了，再试: ");
        }
    }
    return 0;
}

练习 5：猜谜游戏允许继续玩

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <ctype.h>

int main(void)
{
    char playAgain = 'Y';

    while(toupper(playAgain) == 'Y')
    {
        int chosen = 0;
        int guess = 0;
        int limit = 20;

        srand(time(NULL));
        chosen = rand() % limit + 1;

        printf("\n猜一个 1 到 %d 之间的数字: ", limit);
        while(1)
        {
            scanf("%d", &guess);
            if(guess == chosen)
            {
                printf("猜中了!\n");
                break;
            }
            else
            {
                printf("错了，再试一次 (输入0放弃本轮): ");
                if(guess == 0)
                {
                    printf("正确答案是 %d\n", chosen);
                    break;
                }
            }
        }

        printf("继续玩下一轮? (Y/N): ");
        scanf(" %c", &playAgain);
    }

    return 0;
}

有时候不希望结束循环，但要跳出目前的迭代，继续执行下一个迭代。循环体内的 continue 语句就有这个作用，它可以编写为：

continue;

下面是 continue 的例子。

break 会直接退出整个循环：

#include <stdio.h>

int main(void)
{
    for(int i = 1; i <= 10; i++)
    {
        if(i == 5)
        {
            break;
        }
        printf("%d\n", i);
    }

    return 0;
}

以上代码输出：1 2 3 4，当 i 等于 5 时执行 break，整个循环终止。

如果是 continue：

#include <stdio.h>

int main(void)
{
    for(int i = 1; i <= 10; i++)
    {
        if(i == 5)
        {
            continue;
        }
        printf("%d\n", i);
    }

    return 0;
}

以上代码输出：1 2 3 4 6 7 8 9 10，当 i 等于 5 时执行 continue，跳过本次迭代中 continue 后面的语句（即 printf），直接进入下一次循环。

continue 是退出本次循环，然后进入到下一个循环；而 break 则是退出整个循环，后面的都不执行了。

比如原来是 12345，转换后是 54321。

算法如下：

把这个数 12345，设 r = 0。

• 12345 % 10 得 1234 余 5，然后让 r * 10 + 5 保存到变量 r
• 1234 % 10 得 123 余 4，然后让 r * 10 + 4 得 54 保存到 r
• 123 % 10 得 12 余 3，然后让 r * 10 + 3 得 543
• 12 % 10 得 1 余 2，然后让 r * 10 + 2 得 5432
• 1 % 10 得 0 余 1，然后让 r * 10 + 1 得 54321

当商为 0 的时候就停止循环。

#include <stdio.h>

int main(void)
{
    int number = 0;                      /* The number to be reversed */
    int rebmun = 0;                      /* The reversed number       */
    int temp = 0;                        /* Working storage           */

    /* Get the value to be reversed */
    printf("\n输入一个正整数: ");
    scanf(" %d", &number);

    temp = number;                       /* Copy to working storage  */

    /* Reverse the number stored in temp */
    do
    {
        rebmun = 10 * rebmun + temp % 10;    /* Add the rightmost digit    */
        temp = temp / 10;                    /* Remove the rightmost digit */
    }
    while (temp);                        /* Continue while temp > 0   */

    printf("\n这个数 %d 翻转后是 %d \n",
            number, rebmun );
    return 0;
}

这个程序 do-while 是最适合的，因为任何数都至少有一位数字。用取模运算符 % 除以 10 的余数，可以得到最右边的数字。

任何非零整数都会转换为 true，布尔值 false 对应 0。

#include <stdio.h>

int main(void)
{
    int number = 0;
    printf("\n输入一个正整数: ");
    scanf("%d", &number);

    int r = 0;
    int s = 0;
    do
    {
        s = number / 10;
        r = r * 10 + number % 10;
        number = s;
    } while(number != 0);

    printf("%d", r);

    return 0;
}