c语言考试知识点总结

知识点：

1：所有的 C 语言程序都需要包含 main() 函数。 代码从 main() 函数开始执行。

2：/* ... */ 用于注释说明。

注释：

C 语言有两种注释方式：

1：// 单行注释：这种注释可以单独占一行。

/* 单行注释 */

2：多行注释：

多行注释

/* */ 这种格式的注释可以单行或多行。

您不能在注释内嵌套注释，注释也不能出现在字符串或字符值中。

3：printf() 用于格式化输出到屏幕。printf() 函数在 "stdio.h" 头文件中声明。

格式输出函数：printf（格式字符串，表达式列表）

格式字符串包含：（1）普通字符（原样输出）（2）占位符（对应表示式的值）

格式输入函数：scanf（格式字符串，地址列表）

格式字符串包含：（1）普通字符（原样输入），一般不要有普通字符（2）占位符（对应表示式的值）

逻辑判断值：

程序设计需要逻辑运算，但c语言没有逻辑类型，任何类型的值都可视为逻辑值

非0表示为真，0表示为假

当表达式为真时（关系、逻辑表达式），其值为1，为假时，其值为0

If（e！=0）等价于if（e）

If（e==0）等价于if（！e）

C 语言把任何非零和非空的值假定为 true，把零或 null 假定为 false。

4：include<stdio.h>：

stdio.h 是一个头文件 (标准输入输出头文件) , #include 是一个预处理命令，用来引入头文件。当编译器遇到 printf() 函数时，如果没有找到 stdio.h 头文件，会发生编译错误。

5:一个 C 语言程序，可以是 3 行，也可以是数百万行，它可以写在一个或多个扩展名为 ".c" 的文本文件中，例如，hello.c。您可以使用 "vi"、"vim" 或任何其他文本编辑器来编写您的 C 语言程序。

语句中断：

6:return 0; 语句用于表示退出程序, 终止 main() 函数，并返回值 0;

7:continue：跳出当前循环的代码，强迫开始下一次循环

8:break：当break出现在一次循环时，循环会立刻终止且程序流将继续执行紧接着循环的下一条语句。

Return：退出函数，如果退出后还有循环，则继续执行

在一个程序中可以有多个return

Return后放表达式为值

9:C 程序主要包括以下部分：

预处理器指令

函数

变量

语句 & 表达式

注释

10:程序的错误：语法错误、逻辑错误

11：分号 ;在 C 程序中，分号是语句结束符。每个语句必须以分号结束。它表明一个逻辑实体的结束。

13：标识符

C 标识符是用来标识变量、函数，或任何其他用户自定义项目的名称。

一个标识符以字母 A-Z 或 a-z 或下划线 _ 开始，后跟零个或多个字母、下划线和数字（0-9）。

C 标识符内不允许出现标点字符，比如 @、$ 和 %。C 是区分大小写的编程语言。

不能使用保留字作为标识符

14：关键字：

auto 声明自动变量

break 跳出当前循环

case 开关语句分支

char 声明字符型变量或函数返回值类型

const 定义常量，如果一个变量被 const 修饰，那么它的值就不能再被改变

continue 结束当前循环，开始下一轮循环

default 开关语句中的"其它"分支

do 循环语句的循环体

double 声明双精度浮点型变量或函数返回值类型

else 条件语句否定分支（与 if 连用）

enum 声明枚举类型

extern 声明变量或函数是在其它文件或本文件的其他位置定义

float 声明浮点型变量或函数返回值类型

for 一种循环语句

goto 无条件跳转语句

if 条件语句

int 声明整型变量或函数

long 声明长整型变量或函数返回值类型

register 声明寄存器变量

return 子程序返回语句（可以带参数，也可不带参数）

short 声明短整型变量或函数

signed 声明有符号类型变量或函数

sizeof 计算数据类型或变量长度（即所占字节数）

static 声明静态变量

struct 声明结构体类型

switch 用于开关语句

typedef 用以给数据类型取别名

unsigned 声明无符号类型变量或函数

union 声明共用体类型

void 声明函数无返回值或无参数，声明无类型指针

volatile 说明变量在程序执行中可被隐含地改变

while 循环语句的循环条件

C99 新增关键字

_Bool _Complex _Imaginary inline restrict

C11 新增关键字

_Alignas _Alignof _Atomic _Generic _Noreturn

_Static_assert _Thread_local

15：C 中的空格

只包含空格的行，被称为空白行，可能带有注释，C 编译器会完全忽略它。

在 C 中，空格用于描述空白符、制表符、换行符和注释。

空格分隔语句的各个部分，让编译器能识别语句中的某个元素（比如 int）在哪里结束，下一个元素在哪里开始。

16：数据类型：

序号 类型与描述

1 基本类型：

它们是算术类型，包括两种类型：整数类型和浮点类型。

2 枚举类型：

它们也是算术类型，被用来定义在程序中只能赋予其一定的离散整数值的变量。

3 void 类型：

类型说明符 void 表明没有可用的值。

4 派生类型：

它们包括：指针类型、数组类型、结构类型、共用体类型和函数类型。

整数类型

下表列出了关于标准整数类型的存储大小和值范围的细节：

类型 存储大小 值范围

char 1 字节 -128 到 127 或 0 到 255

unsigned char 1 字节 0 到 255

signed char 1 字节 -128 到 127

int 2 或 4 字节 -32,768 到 32,767 或 -2,147,483,648 到 2,147,483,647

unsigned int 2 或 4 字节 0 到 65,535 或 0 到 4,294,967,295

short 2 字节 -32,768 到 32,767

unsigned short 2 字节 0 到 65,535

Long 4 字节 -2,147,483,648 到 2,147,483,647

unsigned long 4 字节 0 到 4,294,967,295

注意，各种类型的存储大小与系统位数有关，但目前通用的以64位系统为主。

浮点类型

下表列出了关于标准浮点类型的存储大小、值范围和精度的细节：

类型 存储大小 值范围 精度

float 4 字节 1.2E-38 到 3.4E+38 6 位有效位

double 8 字节 2.3E-308 到 1.7E+308 15 位有效位

long double 16 字节 3.4E-4932 到 1.1E+4932 19 位有效位

void 类型

void 类型指定没有可用的值。它通常用于以下三种情况下：

序号 类型与描述

1 函数返回为空

C 中有各种函数都不返回值，或者您可以说它们返回空。不返回值的函数的返回类型为空。例如 void exit (int status);

2 函数参数为空

C 中有各种函数不接受任何参数。不带参数的函数可以接受一个 void。例如 int rand(void);

3 指针指向 void

类型为 void * 的指针代表对象的地址，而不是类型。例如，内存分配函数 void *malloc( size_t size ); 返回指向 void 的指针，可以转换为任何数据类型。

17：变量：

变量的名称可以由字母、数字和下划线字符组成。它必须以字母或下划线开头。大写字母和小写字母是不同的

类型描述

char 通常是一个字节（八位）, 这是一个整数类型。

int 整型，4 个字节，取值范围 -2147483648 到 2147483647。

float 单精度浮点值。单精度是这样的格式，1位符号，8位指数，23位小数。

double 双精度浮点值。双精度是1位符号，11位指数，52位小数。

void 表示类型的缺失。

C 中的变量声明

变量声明向编译器保证变量以指定的类型和名称存在，这样编译器在不需要知道变量完整细节的情况下也能继续进一步的编译。变量声明只在编译时有它的意义，在程序连接时编译器需要实际的变量声明。

变量的声明有两种情况：

1、一种是需要建立存储空间的。例如：int a 在声明的时候就已经建立了存储空间。

2、另一种是不需要建立存储空间的，通过使用extern关键字声明变量名而不定义它。例如：extern int a 其中变量 a 可以在别的文件中定义的。

除非有extern关键字，否则都是变量的定义。

引用：如果需要在一个源文件中引用另外一个源文件中定义的变量，我们只需在引用的文件中将变量加上 extern 关键字的声明即可。

先定义后使用

给变量赋值的方法：

1：用scanf方法赋值

2：初始化变量：定义的同时给变量一个初始值

18：常量

常量是固定值，在程序执行期间不会改变。这些固定的值，又叫做字面量。

常量可以是任何的基本数据类型。

常量的值在定义后不能进行修改。

整数常量

整数常量可以是十进制、八进制或十六进制的常量。

前缀指定基数：

0x 或 0X 表示十六进制，

0 表示八进制

不带前缀则默认表示十进制。

整数常量也可以带一个后缀，后缀是 U 和 L 的组合，U 表示无符号整数（unsigned），L 表示长整数（long）。

后缀可以是大写，也可以是小写，U 和 L 的顺序任意。

下面列举几个整数常量的实例：

212 /* 合法的 */

215u /* 合法的 */

0xFeeL /* 合法的 */

078 /* 非法的：8 不是八进制的数字 */

032UU /* 非法的：不能重复后缀 */

以下是各种类型的整数常量的实例：

85 /* 十进制 */

0213 /* 八进制 */

0x4b /* 十六进制 */

30 /* 整数 */

30u /* 无符号整数 */

30l /* 长整数 */

30ul /* 无符号长整数 */

浮点常量

浮点常量由整数部分、小数点、小数部分和指数部分组成。

当使用小数形式表示时，必须包含整数部分、小数部分，或同时包含两者。

当使用指数形式表示时，必须包含小数点、指数，或同时包含两者。带符号的指数是用 e 或 E 引入的。

字符常量

字符常量是括在单引号中，例如，'x' 可以存储在 char 类型的简单变量中。

字符常量可以是一个普通的字符（例如 'x'）、一个转义序列（例如 '\t'），或一个通用的字符（例如 '\u02C0'）。

下表列出了一些这样的转义序列码：

转义序列 含义

\\ \ 字符

\' ' 字符

\" " 字符

\? ? 字符

\a 警报铃声

\b 退格键

\f 换页符

\n 换行符

\r 回车

\t 水平制表符

\v 垂直制表符

\ooo 一到三位的八进制数

\xhh . . . 一个或多个数字的十六进制数

字符串常量

字符串字面值或常量是括在双引号 "" 中的。一个字符串包含类似于字符常量的字符：

普通的字符、转义序列和通用的字符。

使用空格做分隔符，把一个很长的字符串常量进行分行。

定义常量

在 C 中，有两种简单的定义常量的方式：

1：使用 #define 预处理器。#define identifier value

2：使用 const 关键字。 const 前缀声明指定类型的常量 const type variable = value;

注意：常量定义为大写字母形式，是一个很好的编程习惯。

19：C 存储类

存储类定义 C 程序中变量/函数的范围（可见性）和生命周期。这些说明符放置在它们所修饰的类型之前。下面列出 C 程序中可用的存储类

auto
register
static
extern

1：auto 存储类

auto 存储类是所有局部变量默认的存储类。

{

int mount;

auto int month;

}

上面的实例定义了两个带有相同存储类的变量，auto 只能用在函数内，即 auto 只能修饰局部变量。

2：register 存储类

register 存储类用于定义存储在寄存器中而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小（通常是一个字），且不能对它应用一元的 '&' 运算符（因为它没有内存位置）。

{

register int miles;

}

寄存器只用于需要快速访问的变量，比如计数器。还应注意的是，定义 'register' 并不意味着变量将被存储在寄存器中，它意味着变量可能存储在寄存器中，这取决于硬件和实现的限制。

3：static 存储类

static 存储类指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。

static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。

全局声明的一个 static 变量或方法可以被任何函数或方法调用，只要这些方法出现在跟 static 变量或方法同一个文件中。

4：count 作为全局变量可以在函数内使用，thingy 使用 static 修饰后，不会在每次调用时重置。

5：extern 存储类

extern 存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当您使用 extern 时，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置。

当您有多个文件且定义了一个可以在其他文件中使用的全局变量或函数时，可以在其他文件中使用 extern 来得到已定义的变量或函数的引用。可以这么理解，extern 是用来在另一个文件中声明一个全局变量或函数。

extern 修饰符通常用于当有两个或多个文件共享相同的全局变量或函数的时候

20：C 运算符

1：算数运算符：

运算符 描述实例

+ 把两个操作数相加 A + B 将得到 30

- 从第一个操作数中减去第二个操作数 A - B 将得到 -10

* 把两个操作数相乘 A * B 将得到 200

/ 分子除以分母 B / A 将得到 2

% 取模运算符，整除后的余数 B % A 将得到 0

++ 自增运算符，整数值增加 1 A++ 将得到 11

-- 自减运算符，整数值减少 1 A-- 将得到 9

2：关系运算符

下表显示了 C 语言支持的所有关系运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：

运算符 描述实例

== 检查两个操作数的值是否相等，如果相等则条件为真。 (A == B) 为假。

!= 检查两个操作数的值是否相等，如果不相等则条件为真。 (A != B) 为真。

> 检查左操作数的值是否大于右操作数的值，如果是则条件为真。 (A > B) 为假。

< 检查左操作数的值是否小于右操作数的值，如果是则条件为真。 (A < B) 为真。

>= 检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。 (A >= B) 为假。

<= 检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。 (A <= B) 为真。

3：逻辑运算符

下表显示了 C 语言支持的所有关系逻辑运算符。假设变量 A 的值为 1，变量 B 的值为 0，则：

运算符 描述实例

&& 称为逻辑与运算符。如果两个操作数都非零，则条件为真。 (A && B) 为假。

|| 称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。 (A || B) 为真。

! 称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 !(A && B) 为真。

4：位运算符

位运算符作用于位，并逐位执行操作。&、 | 和 ^ 的真值表如下所示：

p	q	p & q	p \| q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

运算符 描述实例

1：&

按位与操作，按二进制位进行"与"运算。运算规则：

0&0=0;

0&1=0;

1&0=0;

1&1=1; (A & B) 将得到 12，即为 0000 1100

2：|

按位或运算符，按二进制位进行"或"运算。运算规则：

0|0=0;

0|1=1;

1|0=1;

1|1=1; (A | B) 将得到 61，即为 0011 1101

3：^

异或运算符，按二进制位进行"异或"运算。运算规则：

0^0=0;

0^1=1;

1^0=1;

1^1=0; (A ^ B) 将得到 49，即为 0011 0001

4：~

取反运算符，按二进制位进行"取反"运算。运算规则：

~1=-2;

~0=-1; (~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。

5：<< 二进制左移运算符。将一个运算对象的各二进制位全部左移若干位（左边的二进制位丢弃，右边补0）。 A << 2 将得到 240，即为 1111 0000

6：>> 二进制右移运算符。将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃。 A >> 2 将得到 15，即为 0000 1111

赋值运算符

下表列出了 C 语言支持的赋值运算符：

运算符 描述实例

= 简单的赋值运算符，把右边操作数的值赋给左边操作数 C = A + B 将把 A + B 的值赋给 C

+= 加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数

C += A 相当于 C = C + A

-= 减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数

C -= A 相当于 C = C - A

*= 乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数

C *= A 相当于 C = C * A

/= 除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数

C /= A 相当于 C = C / A

%= 求模且赋值运算符，求两个操作数的模赋值给左边操作数 C %= A 相当于 C = C % A

<<= 左移且赋值运算符 C <<= 2 等同于 C = C << 2

>>= 右移且赋值运算符 C >>= 2 等同于 C = C >> 2

&= 按位与且赋值运算符 C &= 2 等同于 C = C & 2

^= 按位异或且赋值运算符 C ^= 2 等同于 C = C ^ 2

|= 按位或且赋值运算符 C |= 2 等同于 C = C | 2

杂项运算符 ? sizeof & 三元

运算符 描述实例

sizeof() 返回变量类型的大小。

& 返回变量的地址。 &a; 将给出变量的实际地址。

* 指向一个变量。 *a; 将指向一个变量。

? : 条件表达式 如果条件为真 ? 则值为 X : 否则值为 Y

优先级：

类别 运算符 结合性

后缀 () [] -> . ++ - - 从左到右

一元 + - ! ~ ++ - - (type)* & sizeof 从右到左

乘除 * / % 从左到右

加减 + - 从左到右

移位 << >> 从左到右

关系 < <= > >= 从左到右

相等 == != 从左到右

位与 AND & 从左到右

位异或 XOR ^ 从左到右

位或 OR | 从左到右

逻辑与 AND && 从左到右

逻辑或 OR || 从左到右

条件 ?: 从右到左

赋值 = += -= *= /= %=>>= <<= &= ^= |= 从右到左

逗号 , 从左到右

21：判断（选择）：也可以用三元运算符代替

C 语言提供了以下类型的判断语句。点击链接查看每个语句的细节。

if 语句 一个 if 语句由一个布尔表达式后跟一个或多个语句组成。
if...else 语句 一个 if 语句后可跟一个可选的 else 语句，else 语句在布尔表达式为假时执行。
嵌套 if 语句 您可以在一个 if 或 else if 语句内使用另一个 if 或 else if 语句。
If语句允许空语句：即；前无任何东西，只有冒号
二义性：else规定与最近的if结合构成if....else语句（嵌套才会出现）
switch 语句 一个 switch 语句允许测试一个变量等于多个值时的情况。
嵌套 switch 语句 您可以在一个 switch 语句内使用另一个 switch 语句。

22：循环

一般情况下，语句是按顺序执行的：

函数中的第一个语句先执行，接着是第二个语句。

while 循环：当给定条件为真时，重复语句或语句组。它会在执行循环主体之前测试条件。
While有可能不执行循环
for 循环：多次执行一个语句序列，简化管理循环变量的代码。
do...while 循环：除了它是在循环主体结尾测试条件外，其他与 while 语句类似。
方法体至少执行一次
嵌套循环 您可以在 while、for 或 do..while 循环内使用一个或多个循环

循环控制语句

break 语句 终止循环或 switch 语句，程序流将继续执行紧接着循环或 switch 的下一条语句(CASH)。

continue 语句 告诉一个循环体立刻停止本次循环迭代，重新开始下次循环迭代。

goto 语句 将控制转移到被标记的语句。但是不建议在程序中使用 goto 语句

无限循环

如果条件永远不为假，则循环将变成无限循环。

for 循环在传统意义上可用于实现无限循环。由于构成循环的三个表达式中任何一个都不是必需的，将某些条件表达式留空来构成一个无限循环。

当条件表达式不存在时，它被假设为真。您也可以设置一个初始值和增量表达式，但是一般情况下，C 程序员偏向于使用 for(;;) 结构来表示一个无限循环。

注意：您可以按 Ctrl + C 键终止一个无限循环。

23：函数：

函数是一组一起执行一个任务的语句。

每个 C 程序都至少有一个函数，即主函数 main() ，所有简单的程序都可以定义其他额外的函数。

函数声明告诉编译器函数的名称、返回类型和参数。

函数定义提供了函数的实际主体。

定义函数：一个函数头和一个函数主体组成：

返回类型：一个函数可以返回一个值。

return_type 是函数返回的值的数据类型。有些函数执行所需的操作而不返回值，在这种情况下，return_type 是关键字 void。

函数名称：这是函数的实际名称。函数名和参数列表一起构成了函数签名。

参数：参数就像是占位符。当函数被调用时，您向参数传递一个值，这个值被称为实际参数。参数列表包括函数参数的类型、顺序、数量。参数是可选的，也就是说，函数可能不包含参数。

函数主体：函数主体包含一组定义函数执行任务的语句。

函数声明会告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。

函数声明包括以下几个部分：

return_type function_name( parameter list );

int max(int num1, int num2);

在函数声明中，参数的名称并不重要，只有参数的类型是必需的，因此下面也是有效的声明：

int max(int, int);

当您在一个源文件中定义函数且在另一个文件中调用函数时，函数声明是必需的。在这种情况下，您应该在调用函数的文件顶部声明函数。

调用函数:过程定义：

创建 C 函数时，会定义函数做什么，然后通过调用函数来完成已定义的任务。

当程序调用函数时，程序控制权会转移给被调用的函数。被调用的函数执行已定义的任务，当函数的返回语句被执行时，或到达函数的结束括号时，会把程序控制权交还给主程序。

调用函数时，传递所需参数，如果函数返回一个值，则可以存储返回值。

函数参数

如果函数要使用参数，则必须声明接受参数值的变量。这些变量称为函数的形式参数。

形式参数就像函数内的其他局部变量，在进入函数时被创建，退出函数时被销毁。

当调用函数时，有两种向函数传递参数的方式：

1：传值调用：该方法把参数的实际值复制给函数的形式参数。在这种情况下，修改函数内的形式参数不会影响实际参数。

2：引用调用：通过指针传递方式，形参为指向实参地址的指针，当对形参的指向操作时，就相当于对实参本身进行的操作。

默认情况下，C 使用传值调用来传递参数。一般来说，这意味着函数内的代码不能改变用于调用函数的实际参数。

24：变量的作用区域：

任何一种编程中，作用域是程序中定义的变量所存在的区域，超过该区域变量就不能被访问。C 语言中有三个地方可以声明变量：

在函数或块内部的局部变量
在所有函数外部的全局变量
在形式参数的函数参数定义中

局部变量

在某个函数或块的内部声明的变量称为局部变量。
它们只能被该函数或该代码块内部的语句使用。
局部变量在函数外部是不可知的。

全局变量

全局变量是定义在函数外部，通常是在程序的顶部。

全局变量在整个程序生命周期内都是有效的，在任意的函数内部能访问全局变量。

全局变量可以被任何函数访问====全局变量在声明后整个程序中都是可用的。

在程序中，局部变量和全局变量的名称可以相同，但是在函数内，如果两个名字相同，会使用局部变量值，全局变量不会被使用。

形式参数

函数的参数，形式参数，被当作该函数内的局部变量，如果与全局变量同名它们会优先使用。

全局变量与局部变量在内存中的区别：

全局变量保存在内存的全局存储区中，占用静态的存储单元；

局部变量保存在栈中，只有在所在函数被调用时才动态地为变量分配存储单元。

初始化局部变量和全局变量

当局部变量被定义时，系统不会对其初始化，您必须自行对其初始化。

定义全局变量时，系统会自动对其初始化，如下所示：

25：C 数组

C 语言支持数组数据结构，它可以存储一个固定大小的相同类型元素的顺序集合。数组是用来存储一系列数据，但它往往被认为是一系列相同类型的变量。

数组的声明并不是声明一个个单独的变量，比如 runoob0、runoob1、...、runoob99，而是声明一个数组变量，比如 runoob，然后使用 runoob[0]、runoob[1]、...、runoob[99] 来代表一个个单独的变量。

所有的数组都是由连续的内存位置组成。最低的地址对应第一个元素，最高的地址对应最后一个元素。

C 中的数组

数组中的特定元素可以通过索引访问，第一个索引值为 0。

声明数组

在 C 中要声明一个数组，需要指定元素的类型和元素的数量，如下所示：

type arrayName [ arraySize ];

这叫做一维数组。arraySize 必须是一个大于零的整数常量，type 可以是任意有效的 C 数据类型。例如，要声明一个类型为 double 的包含 10 个元素的数组 balance，声明语句如下：

double balance[10];

现在 balance 是一个可用的数组，可以容纳 10 个类型为 double 的数字。

初始化数组

在 C 中，您可以逐个初始化数组，也可以使用一个初始化语句，如下所示：

double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};

大括号 { } 之间的值的数目不能大于我们在数组声明时在方括号 [ ] 中指定的元素数目。

如果您省略掉了数组的大小，数组的大小则为初始化时元素的个数。因此，如果：

double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0};

您将创建一个数组，它与前一个实例中所创建的数组是完全相同的。下面是一个为数组中某个元素赋值的实例：

balance[4] = 50.0;

上述的语句把数组中第五个元素的值赋为 50.0。所有的数组都是以 0 作为它们第一个元素的索引，也被称为基索引，数组的最后一个索引是数组的总大小减去 1。以下是上面所讨论的数组的的图形表示：

数组表示

下图是一个长度为 10 的数组，第一个元素的索引值为 0，第九个元素 runoob 的索引值为 8:

访问数组元素

数组元素可以通过数组名称加索引进行访问。元素的索引是放在方括号内，跟在数组名称的后边。例如：

double salary = balance[9];

上面的语句将把数组中第 10 个元素的值赋给 salary 变量。下面的实例使用了上述的三个概念，即，声明数组、数组赋值、访问数组：

实例

#include <stdio.h>

int main ()

{

int n[ 10 ]; /* n 是一个包含 10 个整数的数组 */

int i,j;

/* 初始化数组元素 */

for ( i = 0; i < 10; i++ )

{

n[ i ] = i + 100; /* 设置元素 i 为 i + 100 */

}

/* 输出数组中每个元素的值 */

for (j = 0; j < 10; j++ )

{

printf("Element[%d] = %d\n", j, n[j] );

}

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

Element[0] = 100

Element[1] = 101

Element[2] = 102

Element[3] = 103

Element[4] = 104

Element[5] = 105

Element[6] = 106

Element[7] = 107

Element[8] = 108

Element[9] = 109

C 中数组详解

在 C 中，数组是非常重要的，我们需要了解更多有关数组的细节。下面列出了 C 程序员必须清楚的一些与数组相关的重要

多维数组

C 数组 C 数组

C 语言支持多维数组。多维数组声明的一般形式如下：

type name[size1][size2]...[sizeN];

例如，下面的声明创建了一个三维 5 . 10 . 4 整型数组：

int threedim[5][10][4];

二维数组

多维数组最简单的形式是二维数组。一个二维数组，在本质上，是一个一维数组的列表。声明一个 x 行 y 列的二维整型数组，形式如下：

type arrayName [ x ][ y ];

其中，type 可以是任意有效的 C 数据类型，arrayName 是一个有效的 C 标识符。一个二维数组可以被认为是一个带有 x 行和 y 列的表格。下面是一个二维数组，包含 3 行和 4 列：

int x[3][4];C 中的二维数组

因此，数组中的每个元素是使用形式为 a[ i , j ] 的元素名称来标识的，其中 a 是数组名称，i 和 j 是唯一标识 a 中每个元素的下标。

初始化二维数组

多维数组可以通过在括号内为每行指定值来进行初始化。下面是一个带有 3 行 4 列的数组。

int a[3][4] = {

{0, 1, 2, 3} , /* 初始化索引号为 0 的行 */

{4, 5, 6, 7} , /* 初始化索引号为 1 的行 */

{8, 9, 10, 11} /* 初始化索引号为 2 的行 */

};

内部嵌套的括号是可选的，下面的初始化与上面是等同的：

int a[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11};

访问二维数组元素

二维数组中的元素是通过使用下标（即数组的行索引和列索引）来访问的。例如：

int val = a[2][3];

上面的语句将获取数组中第 3 行第 4 个元素。您可以通过上面的示意图来进行验证。让我们来看看下面的程序，我们将使用嵌套循环来处理二维数组：

实例

#include <stdio.h>

int main ()

{

/* 一个带有 5 行 2 列的数组 */

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

int i, j;

/* 输出数组中每个元素的值 */

for ( i = 0; i < 5; i++ )

{

for ( j = 0; j < 2; j++ )

{

printf("a[%d][%d] = %d\n", i,j, a[i][j] );

}

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

a[0][0] = 0

a[0][1] = 0

a[1][0] = 1

a[1][1] = 2

a[2][0] = 2

a[2][1] = 4

a[3][0] = 3

a[3][1] = 6

a[4][0] = 4

a[4][1] = 8

如上所述，您可以创建任意维度的数组，但是一般情况下，我们创建的数组是一维数组和二维数组。

C 传递数组给函数

C 数组 C 数组

如果您想要在函数中传递一个一维数组作为参数，您必须以下面三种方式来声明函数形式参数，这三种声明方式的结果是一样的，因为每种方式都会告诉编译器将要接收一个整型指针。同样地，您也可以传递一个多维数组作为形式参数。

方式 1

形式参数是一个指针（您可以在下一章中学习到有关指针的知识）：

void myFunction(int *param)

{

}

方式 2

形式参数是一个已定义大小的数组：

void myFunction(int param[10])

{

}

方式 3

形式参数是一个未定义大小的数组：

void myFunction(int param[])

{

}

实例

现在，让我们来看下面这个函数，它把数组作为参数，同时还传递了另一个参数，根据所传的参数，会返回数组中元素的平均值：

double getAverage(int arr[], int size)

{

int i;

double avg;

double sum;

for (i = 0; i < size; ++i)

{

sum += arr[i];

}

avg = sum / size;

return avg;

}

现在，让我们调用上面的函数，如下所示：

实例

#include <stdio.h>

/* 函数声明 */

double getAverage(int arr[], int size);

int main ()

{

/* 带有 5 个元素的整型数组 */

int balance[5] = {1000, 2, 3, 17, 50};

double avg;

/* 传递一个指向数组的指针作为参数 */

avg = getAverage( balance, 5 ) ;

/* 输出返回值 */

printf( "平均值是： %f ", avg );

return 0;

}

double getAverage(int arr[], int size)

{

int i;

double avg;

double sum=0;

for (i = 0; i < size; ++i)

{

sum += arr[i];

}

avg = sum / size;

return avg;

}

当上面的代码被编译和执行时，它会产生下列结果：

平均值是： 214.400000

您可以看到，就函数而言，数组的长度是无关紧要的，因为 C 不会对形式参数执行边界检查。

C 从函数返回数组

C 语言不允许返回一个完整的数组作为函数的参数。但是，您可以通过指定不带索引的数组名来返回一个指向数组的指针。我们将在下一章中讲解有关指针的知识，您可以先跳过本章，等了解了 C 指针的概念之后，再来学习本章的内容。

如果您想要从函数返回一个一维数组，您必须声明一个返回指针的函数，如下：

int * myFunction()

{

}

另外，C 不支持在函数外返回局部变量的地址，除非定义局部变量为 static 变量。

现在，让我们来看下面的函数，它会生成 10 个随机数，并使用数组来返回它们，具体如下：

实例

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

/* 要生成和返回随机数的函数 */

int * getRandom( )

{

static int r[10];

int i;

/* 设置种子 */

srand( (unsigned)time( NULL ) );

for ( i = 0; i < 10; ++i)

{

r[i] = rand();

printf( "r[%d] = %d\n", i, r[i]);

}

return r;

}

/* 要调用上面定义函数的主函数 */

int main ()

{

/* 一个指向整数的指针 */

int *p;

int i;

p = getRandom();

for ( i = 0; i < 10; i++ )

{

printf( "*(p + %d) : %d\n", i, *(p + i));

}

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

r[0] = 313959809

r[1] = 1759055877

r[2] = 1113101911

r[3] = 2133832223

r[4] = 2073354073

r[5] = 167288147

r[6] = 1827471542

r[7] = 834791014

r[8] = 1901409888

r[9] = 1990469526

*(p + 0) : 313959809

*(p + 1) : 1759055877

*(p + 2) : 1113101911

*(p + 3) : 2133832223

*(p + 4) : 2073354073

*(p + 5) : 167288147

*(p + 6) : 1827471542

*(p + 7) : 834791014

*(p + 8) : 1901409888

*(p + 9) : 1990469526

C 指向数组的指针

C 数组 C 数组

您可以先跳过本章，等了解了 C 指针的概念之后，再来学习本章的内容。

如果您对 C 语言中指针的概念有所了解，那么就可以开始本章的学习。数组名是一个指向数组中第一个元素的常量指针。因此，在下面的声明中：

double balance[50];

balance 是一个指向 &balance[0] 的指针，即数组 balance 的第一个元素的地址。因此，下面的程序片段把 p 赋值为 balance 的第一个元素的地址：

double *p;

double balance[10];

p = balance;

使用数组名作为常量指针是合法的，反之亦然。因此，*(balance + 4) 是一种访问 balance[4] 数据的合法方式。

一旦您把第一个元素的地址存储在 p 中，您就可以使用 *p、*(p+1)、*(p+2) 等来访问数组元素。下面的实例演示了上面讨论到的这些概念：

实例

#include <stdio.h>

int main ()

{

/* 带有 5 个元素的整型数组 */

double balance[5] = {1000.0, 2.0, 3.4, 17.0, 50.0};

double *p;

int i;

p = balance;

/* 输出数组中每个元素的值 */

printf( "使用指针的数组值\n");

for ( i = 0; i < 5; i++ )

{

printf("*(p + %d) : %f\n", i, *(p + i) );

}

printf( "使用 balance 作为地址的数组值\n");

for ( i = 0; i < 5; i++ )

{

printf("*(balance + %d) : %f\n", i, *(balance + i) );

}

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

使用指针的数组值

*(p + 0) : 1000.000000

*(p + 1) : 2.000000

*(p + 2) : 3.400000

*(p + 3) : 17.000000

*(p + 4) : 50.000000

使用 balance 作为地址的数组值

*(balance + 0) : 1000.000000

*(balance + 1) : 2.000000

*(balance + 2) : 3.400000

*(balance + 3) : 17.000000

*(balance + 4) : 50.000000

在上面的实例中，p 是一个指向 double 型的指针，这意味着它可以存储一个 double 类型的变量。一旦我们有了 p 中的地址，*p 将给出存储在 p 中相应地址的值，正如上面实例中所演示的。

26：C enum(枚举)：可以代替define定义：枚举可用for循环代替

枚举是 C 语言中的一种基本数据类型，它可以让数据更简洁，更易读。

枚举语法定义格式为：

enum　枚举名　{枚举元素1,枚举元素2,……};

这个看起来代码量就比较多，接下来我们看看使用枚举的方式：

enum DAY

{

MON=1, TUE, WED, THU, FRI, SAT, SUN

};

注意：第一个枚举成员的默认值为整型的 0，后续枚举成员的值在前一个成员上加 1。我们在这个实例中把第一个枚举成员的值定义为 1，第二个就为 2，以此类推。

可以在定义枚举类型时改变枚举元素的值：

enum season {spring, summer=3, autumn, winter};

没有指定值的枚举元素，其值为前一元素加 1。也就说 spring 的值为 0，summer 的值为 3，autumn 的值为 4，winter 的值为 5

1、先定义枚举类型，再定义枚举变量

enum DAY

{

MON=1, TUE, WED, THU, FRI, SAT, SUN

};

enum DAY day;

2、定义枚举类型的同时定义枚举变量

enum DAY

{

MON=1, TUE, WED, THU, FRI, SAT, SUN

} day;

3、省略枚举名称，直接定义枚举变量

enum

{

MON=1, TUE, WED, THU, FRI, SAT, SUN

} day;

实例

#include <stdio.h>

enum DAY

{

MON=1, TUE, WED, THU, FRI, SAT, SUN

};

int main()

{

enum DAY day;

day = WED;

printf("%d",day);

return 0;

}

以上实例输出结果为：3

在C 语言中，枚举类型是被当做 int 或者 unsigned int 类型来处理的，所以按照 C 语言规范是没有办法遍历枚举类型的。

不过在一些特殊的情况下，枚举类型必须连续是可以实现有条件的遍历。

以下实例使用 for 来遍历枚举的元素：

实例

#include <stdio.h>

enum DAY

{

MON=1, TUE, WED, THU, FRI, SAT, SUN

} day;

int main()

{

// 遍历枚举元素

for (day = MON; day <= SUN; day++) {

printf("枚举元素：%d \n", day);

}

以上实例输出结果为：

枚举元素：1

枚举元素：2

枚举元素：3

枚举元素：4

枚举元素：5

枚举元素：6

枚举元素：7

以下枚举类型不连续，这种枚举无法遍历。

enum

{

ENUM_0,

ENUM_10 = 10,

ENUM_11

};

枚举在 switch 中的使用：

#include <stdio.h>

#include <stdlib.h>

int main()

{

enum color { red=1, green, blue };

enum color favorite_color;

/* 用户输入数字来选择颜色 */

printf("请输入你喜欢的颜色: (1. red, 2. green, 3. blue): ");

scanf("%u", &favorite_color);

/* 输出结果 */

switch (favorite_color)

{

case red:

printf("你喜欢的颜色是红色");

break;

case green:

printf("你喜欢的颜色是绿色");

break;

case blue:

printf("你喜欢的颜色是蓝色");

break;

default:

printf("你没有选择你喜欢的颜色");

}

return 0;

}

以上实例输出结果为：

请输入你喜欢的颜色: (1. red, 2. green, 3. blue): 1

你喜欢的颜色是红色

将整数转换为枚举

以下实例将整数转换为枚举：

实例

#include <stdio.h>

#include <stdlib.h>

int main()

{

enum day

{

saturday,

sunday,

monday,

tuesday,

wednesday,

thursday,

friday

} workday;

int a = 1;

enum day weekend;

weekend = ( enum day ) a; //类型转换

//weekend = a; //错误

printf("weekend:%d",weekend);

return 0;

}

以上实例输出结果为：

weekend:1

27：C 指针

每一个变量都有一个内存位置，每一个内存位置都定义了可使用 & 运算符访问的地址，它表示了在内存中的一个地址。

请看下面的实例，它将输出定义的变量地址：

实例

#include <stdio.h>

int main ()

{

int var_runoob = 10;

int *p; // 定义指针变量

p = &var_runoob;

printf("var_runoob 变量的地址： %p\n", p);

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

var_runoob 变量的地址： 0x7ffeeaae08d8

1：什么是指针？

指针也就是内存地址，指针变量是用来存放内存地址的变量。就像其他变量或常量一样，您必须在使用指针存储其他变量地址之前，对其进行声明。

指针变量声明的一般形式为：

type *var_name;

在这里，type 是指针的基类型，它必须是一个有效的 C 数据类型，var_name 是指针变量的名称。用来声明指针的星号 * 与乘法中使用的星号是相同的。但是，在这个语句中，星号是用来指定一个变量是指针。以下是有效的指针声明：

int *ip; /* 一个整型的指针 */

double *dp; /* 一个 double 型的指针 */

float *fp; /* 一个浮点型的指针 */

char *ch; /* 一个字符型的指针 */

所有实际数据类型，不管是整型、浮点型、字符型，还是其他的数据类型，对应指针的值的类型都是一样的，都是一个代表内存地址的长的十六进制数。

不同数据类型的指针之间唯一的不同是，指针所指向的变量或常量的数据类型不同。

如何使用指针？

使用指针时会频繁进行以下几个操作：定义一个指针变量、把变量地址赋值给指针、访问指针变量中可用地址的值。这些是通过使用一元运算符 * 来返回位于操作数所指定地址的变量的值。

实例

#include <stdio.h>

int main ()

{

int var = 20; /* 实际变量的声明 */

int *ip; /* 指针变量的声明 */

ip = &var; /* 在指针变量中存储 var 的地址 */

printf("var 变量的地址: %p\n", &var );

/* 在指针变量中存储的地址 */

printf("ip 变量存储的地址: %p\n", ip );

/* 使用指针访问值 */

printf("*ip 变量的值: %d\n", *ip );

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

var 变量的地址: 0x7ffeeef168d8

ip 变量存储的地址: 0x7ffeeef168d8

*ip 变量的值: 20

C 中的 NULL 指针

在变量声明的时候，如果没有确切的地址可以赋值，为指针变量赋一个 NULL 值是一个良好的编程习惯。

赋为 NULL 值的指针被称为空指针。

NULL 指针是一个定义在标准库中的值为零的常量。

实例

#include <stdio.h>

int main ()

{

int *ptr = NULL;

printf("ptr 的地址是 %p\n", ptr );

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

ptr 的地址是 0x0

在大多数的操作系统上，程序不允许访问地址为 0 的内存，因为该内存是操作系统保留的。然而，内存地址 0 有特别重要的意义，它表明该指针不指向一个可访问的内存位置。但按照惯例，如果指针包含空值（零值），则假定它不指向任何东西。

如需检查一个空指针，您可以使用 if 语句，如下所示：

if(ptr) /* 如果 p 非空，则完成 */

if(!ptr) /* 如果 p 为空，则完成 */

28：C 指针详解

概念描述

指针的算术运算 可以对指针进行四种算术运算：++、--、+、-

指针数组 可以定义用来存储指针的数组。

指向指针的指针 C 允许指向指针的指针。

传递指针给函数 通过引用或地址传递参数，使传递的参数在调用函数中被改变。

从函数返回指针 C 允许函数返回指针到局部变量、静态变量和动态内存分配。

1：C 指针的算术运算

C 指针是一个用数值表示的地址。四种算术运算：++、--、+、-。

概括一下：

指针的每一次递增，它其实会指向下一个元素的存储单元。
指针的每一次递减，它都会指向前一个元素的存储单元。
指针在递增和递减时跳跃的字节数取决于指针所指向变量数据类型长度，比如 int 就是 4 个字节。

1：递增一个指针

实例

#include <stdio.h>

const int MAX = 3;

int main ()

{

int var[] = {10, 100, 200};

int i, *ptr;

/* 指针中的数组地址 */

ptr = var;

for ( i = 0; i < MAX; i++)

{

printf("存储地址：var[%d] = %p\n", i, ptr );

printf("存储值：var[%d] = %d\n", i, *ptr );

/* 指向下一个位置 */

ptr++;

}

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

存储地址：var[0] = e4a298cc

存储值：var[0] = 10

存储地址：var[1] = e4a298d0

存储值：var[1] = 100

存储地址：var[2] = e4a298d4

存储值：var[2] = 200

2：递减一个指针

同样地，对指针进行递减运算，即把值减去其数据类型的字节数

实例

#include <stdio.h>

const int MAX = 3;

int main ()

{

int var[] = {10, 100, 200};

int i, *ptr;

/* 指针中最后一个元素的地址 */

ptr = &var[MAX-1];

for ( i = MAX; i > 0; i--)

{

printf("存储地址：var[%d] = %p\n", i-1, ptr );

printf("存储值：var[%d] = %d\n", i-1, *ptr )；

/* 指向下一个位置 */

ptr--;

}

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

存储地址：var[2] = 518a0ae4

存储值：var[2] = 200

存储地址：var[1] = 518a0ae0

存储值：var[1] = 100

存储地址：var[0] = 518a0adc

存储值：var[0] = 10

3：指针的比较

指针可以用关系运算符进行比较，如 ==、< 和 >。

下面的程序修改了上面的实例，只要变量指针所指向的地址小于或等于数组的最后一个元素的地址 &var[MAX - 1]，则把变量指针进行递增：

实例

#include <stdio.h>

const int MAX = 3;

int main ()

{

int var[] = {10, 100, 200};

int i, *ptr;

/* 指针中第一个元素的地址 */

ptr = var;

i = 0;

while ( ptr <= &var[MAX - 1] )

{

printf("存储地址：var[%d] = %p\n", i, ptr );

printf("存储值：var[%d] = %d\n", i, *ptr );

/* 指向上一个位置 */

ptr++;

i++;

}

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

存储地址：var[0] = 0x7ffeee2368cc

存储值：var[0] = 10

存储地址：var[1] = 0x7ffeee2368d0

存储值：var[1] = 100

存储地址：var[2] = 0x7ffeee2368d4

存储值：var[2] = 200

28：C 指针数组

在我们讲解指针数组的概念之前，先让我们来看一个实例，它用到了一个由 3 个整数组成的数组：

实例

#include <stdio.h>

const int MAX = 3；

int main ()

{

int var[] = {10, 100, 200};

int i;

for (i = 0; i < MAX; i++)

{

printf("Value of var[%d] = %d\n", i, var[i] );

}

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

Value of var[0] = 10

Value of var[1] = 100

Value of var[2] = 200

可能有一种情况，我们想要让数组存储指向 int 或 char 或其他数据类型的指针。下面是一个指向整数的指针数组的声明：

int *ptr[MAX];

在这里，把 ptr 声明为一个数组，由 MAX 个整数指针组成。因此，ptr 中的每个元素，都是一个指向 int 值的指针。下面的实例用到了三个整数，它们将存储在一个指针数组中，

实例

#include <stdio.h>

const int MAX = 3;

int main ()

{

int var[] = {10, 100, 200};

int i, *ptr[MAX];

for ( i = 0; i < MAX; i++)

{

ptr[i] = &var[i]; /* 赋值为整数的地址 */

}

for ( i = 0; i < MAX; i++)

{

printf("Value of var[%d] = %d\n", i, *ptr[i] );

}

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

Value of var[0] = 10

Value of var[1] = 100

Value of var[2] = 200

您也可以用一个指向字符的指针数组来存储一个字符串列表，如下：

实例

#include <stdio.h>

const int MAX = 4;

int main ()

{

const char *names[] = {

"Zara Ali",

"Hina Ali",

"Nuha Ali",

"Sara Ali",

};

int i = 0；

for ( i = 0; i < MAX; i++)

{

printf("Value of names[%d] = %s\n", i, names[i] );

}

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

Value of names[0] = Zara Ali

Value of names[1] = Hina Ali

Value of names[2] = Nuha Ali

Value of names[3] = Sara Ali

29：C 指向指针的指针

指向指针的指针是一种多级间接寻址的形式，或者说是一个指针链。

通常，一个指针包含一个变量的地址。

当我们定义一个指向指针的指针时，第一个指针包含了第二个指针的地址，第二个指针指向包含实际值的位置。

一个指向指针的指针变量必须如下声明，即在变量名前放置两个星号。

int **var;

当一个目标值被一个指针间接指向到另一个指针时，访问这个值需要使用两个星号运算符，

实例

#include <stdio.h>

int main ()

{

int V;

int *Pt1;

int **Pt2;

V = 100;

/* 获取 V 的地址 */

Pt1 = &V;

/* 使用运算符 & 获取 Pt1 的地址 */

Pt2 = &Pt1;

/* 使用 pptr 获取值 */

printf("var = %d\n", V );

printf("Pt1 = %p\n", Pt1 );

printf("*Pt1 = %d\n", *Pt1 );

printf("Pt2 = %p\n", Pt2 );

printf("**Pt2 = %d\n", **Pt2);

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

var = 100

Pt1 = 0x7ffee2d5e8d8

*Pt1 = 100

Pt2 = 0x7ffee2d5e8d0

**Pt2 = 100

30：C 传递指针给函数

C 语言允许您传递指针给函数，只需要简单地声明函数参数为指针类型即可。

下面的实例中，我们传递一个无符号的 long 型指针给函数，并在函数内改变这个值：

实例

#include <stdio.h>

#include <time.h>

void getSeconds(unsigned long *par);

int main ()

{

unsigned long sec;

getSeconds( &sec );

/* 输出实际值 */

printf("Number of seconds: %ld\n", sec );

return 0;

}

void getSeconds(unsigned long *par)

{

/* 获取当前的秒数 */

*par = time( NULL );

return;

}

当上面的代码被编译和执行时，它会产生下列结果：

Number of seconds :1294450468

能接受指针作为参数的函数，也能接受数组作为参数，如下所示：

实例

#include <stdio.h>

/* 函数声明 */

double getAverage(int *arr, int size);

int main ()

{

/* 带有 5 个元素的整型数组 */

int balance[5] = {1000, 2, 3, 17, 50};

double avg;

/* 传递一个指向数组的指针作为参数 */

avg = getAverage( balance, 5 ) ;

/* 输出返回值 */

printf("Average value is: %f\n", avg );

return 0;

}

double getAverage(int *arr, int size)

{

int i, sum = 0;

double avg;

for (i = 0; i < size; ++i)

{

sum += arr[i];

}

avg = (double)sum / size;

return avg;

}

当上面的代码被编译和执行时，它会产生下列结果：

Average value is: 214.40000

31：C 从函数返回指针

C 允许您从函数返回指针。必须声明一个返回指针的函数，

int * myFunction()

{

}

另外，C 语言不支持在调用函数时返回局部变量的地址，除非定义局部变量为 static 变量。

现在，让我们来看下面的函数，它会生成 10 个随机数，并使用表示指针的数组名（即第一个数组元素的地址）来返回它们，具体如下：

实例

#include <stdio.h>

#include <time.h>

#include <stdlib.h>

/* 要生成和返回随机数的函数 */

int * getRandom( )

{

static int r[10];

int i;

/* 设置种子 */

srand( (unsigned)time( NULL ) );

for ( i = 0; i < 10; ++i)

{

r[i] = rand();

printf("%d\n", r[i] );

}

return r;

}

/* 要调用上面定义函数的主函数 */

int main ()

{

/* 一个指向整数的指针 */

int *p;

int i;

p = getRandom();

for ( i = 0; i < 10; i++ )

{

printf("*(p + [%d]) : %d\n", i, *(p + i) );

}

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

1523198053

1187214107

1108300978

430494959

1421301276

930971084

123250484

106932140

1604461820

149169022

*(p + [0]) : 1523198053

*(p + [1]) : 1187214107

*(p + [2]) : 1108300978

*(p + [3]) : 430494959

*(p + [4]) : 1421301276

*(p + [5]) : 930971084

*(p + [6]) : 123250484

*(p + [7]) : 106932140

*(p + [8]) : 1604461820

*(p + [9]) : 149169022

32：函数指针

函数指针是指向函数的指针变量。

通常我们说的指针变量是指向一个整型、字符型或数组等变量，而函数指针是指向函数。

函数指针可以像一般函数一样，用于调用函数、传递参数。

函数指针变量的声明：

typedef int (*fun_ptr)(int,int); // 声明一个指向同样参数、返回值的函数指针类型

实例

以下实例声明了函数指针变量 p，指向函数 max：

#include <stdio.h>

int max(int x, int y)

{

return x > y ? x : y;

}

int main(void)

{

/* p 是函数指针 */

int (* p)(int, int) = & max; // &可以省略

int a, b, c, d;

printf("请输入三个数字:");

scanf("%d %d %d", & a, & b, & c);

/* 与直接调用函数等价，d = max(max(a, b), c) */

d = p(p(a, b), c);

printf("最大的数字是: %d\n", d);

return 0;

}

编译执行，输出结果如下：

请输入三个数字:1 2 3

最大的数字是: 3

回调函数

函数指针作为某个函数的参数

函数指针变量可以作为某个函数的参数来使用的，回调函数就是一个通过函数指针调用的函数。

简单讲：回调函数是由别人的函数执行时调用你实现的函数。

你到一个商店买东西，刚好你要的东西没有货，于是你在店员那里留下了你的电话，过了几天店里有货了，店员就打了你的电话，然后你接到电话后就到店里去取了货。在这个例子里，你的电话号码就叫回调函数，你把电话留给店员就叫登记回调函数，店里后来有货了叫做触发了回调关联的事件，店员给你打电话叫做调用回调函数，你到店里去取货叫做响应回调事件。

实例

实例中 populate_array() 函数定义了三个参数，其中第三个参数是函数的指针，通过该函数来设置数组的值。

实例中我们定义了回调函数 getNextRandomValue()，它返回一个随机值，它作为一个函数指针传递给 populate_array() 函数。

populate_array() 将调用 10 次回调函数，并将回调函数的返回值赋值给数组。

实例

#include <stdlib.h>

#include <stdio.h>

void populate_array(int *array, size_t arraySize, int (*getNextValue)(void))

{

for (size_t i=0; i<arraySize; i++)

array[i] = getNextValue();

}

// 获取随机值

int getNextRandomValue(void)

{

return rand();

}

int main(void)

{

int myarray[10];

/* getNextRandomValue 不能加括号，否则无法编译，因为加上括号之后相当于传入此参数时传入了 int , 而不是函数指针*/

populate_array(myarray, 10, getNextRandomValue);

for(int i = 0; i < 10; i++) {

printf("%d ", myarray[i]);

}

printf("\n");

return 0;

}

编译执行，输出结果如下：

16807 282475249 1622650073 984943658 1144108930 470211272 101027544 1457850878 1458777923 2007237709

32：C 字符串

在 C 语言中，字符串实际上是使用空字符 \0 结尾的一维字符数组。因此，\0 是用于标记字符串的结束。

空字符（Null character）又称结束符，缩写 NUL，是一个数值为 0 的控制字符，\0 是转义字符，意思是告诉编译器，这不是字符 0，而是空字符。

下面的声明和初始化创建了一个 RUNOOB 字符串。由于在数组的末尾存储了空字符 \0，所以字符数组的大小比单词 RUNOOB 的字符数多一个。

char site[7] = {'R', 'U', 'N', 'O', 'O', 'B', '\0'};

依据数组初始化规则，您可以把上面的语句写成以下语句：

char site[] = "RUNOOB";

让我们尝试输出上面的字符串：

实例

#include <stdio.h>

int main ()

{

char site[7] = {'R', 'U', 'N', 'O', 'O', 'B', '\0'};

printf("菜鸟教程: %s\n", site );

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

菜鸟教程: RUNOOB

C 中有大量操作字符串的函数：

序号函数目的

1 strcpy(s1, s2); 复制字符串 s2 到字符串 s1。

2 strcat(s1, s2); 连接字符串 s2 到字符串 s1 的末尾。

3 strlen(s1); 返回字符串 s1 的长度。

4 strcmp(s1, s2); 如果 s1 和 s2 是相同的，则返回 0；如果 s1<s2 则返回小于 0；如果 s1>s2 则返回大于 0。

5 strchr(s1, ch); 返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置。

6 strstr(s1, s2); 返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置。

下面的实例使用了上述的一些函数：

实例

#include <stdio.h>

#include <string.h>

int main ()

{

char str1[14] = "runoob";

char str2[14] = "google";

char str3[14];

int len ;

/* 复制 str1 到 str3 */

strcpy(str3, str1);

printf("strcpy( str3, str1) : %s\n", str3 );

/* 连接 str1 和 str2 */

strcat( str1, str2);

printf("strcat( str1, str2): %s\n", str1 );

/* 连接后，str1 的总长度 */

len = strlen(str1);

printf("strlen(str1) : %d\n", len );

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

strcpy( str3, str1) : runoob

strcat( str1, str2): runoobgoogle

strlen(str1) : 12

33：C 结构体

C 数组允许定义可存储相同类型数据项的变量

结构是 C 编程中另一种用户自定义的可用的数据类型，它允许您存储不同类型的数据项。

结构用于表示一条记录

Title

Author

Subject

Book ID

定义结构，您必须使用 struct 语句。struct 语句定义了一个包含多个成员的新的数据类型，struct 语句的格式如下：

struct tag {

member-list

...

} variable-list ;

tag 是结构体标签。

member-list 是标准的变量定义，比如 int i; 或者 float f，或者其他有效的变量定义。

variable-list 结构变量，定义在结构的末尾，最后一个分号之前，您可以指定一个或多个结构变量。

下面是声明 Book 结构的方式：

struct Books

{

char title[50];

char author[50];

char subject[100];

int book_id;

} book;

在一般情况下，tag、member-list、variable-list 这 3 部分至少要出现 2 个。以下为实例：

//此声明声明了拥有3个成员的结构体，分别为整型的a，字符型的b和双精度的c

//同时又声明了结构体变量s1

//这个结构体并没有标明其标签

struct

{

int a;

char b;

double c;

} s1;

//此声明声明了拥有3个成员的结构体，分别为整型的a，字符型的b和双精度的c

//结构体的标签被命名为SIMPLE,没有声明变量

struct SIMPLE

{

int a;

char b;

double c;

};

//用SIMPLE标签的结构体，另外声明了变量t1、t2、t3

struct SIMPLE t1, t2[20], *t3;

//也可以用typedef创建新类型

typedef struct

{

int a;

char b;

double c;

} Simple2;

//现在可以用Simple2作为类型声明新的结构体变量

Simple2 u1, u2[20], *u3;

在上面的声明中，第一个和第二声明被编译器当作两个完全不同的类型，即使他们的成员列表是一样的，如果令 t3=&s1，则是非法的。

结构体的成员可以包含其他结构体，也可以包含指向自己结构体类型的指针，而通常这种指针的应用是为了实现一些更高级的数据结构如链表和树等。

//此结构体的声明包含了其他的结构体

struct COMPLEX

{

char string[100];

struct SIMPLE a;

};

//此结构体的声明包含了指向自己类型的指针

struct NODE

{

char string[100];

struct NODE *next_node;

};

如果两个结构体互相包含，则需要对其中一个结构体进行不完整声明，如下所示：

struct B; //对结构体B进行不完整声明

//结构体A中包含指向结构体B的指针

struct A

{

struct B *partner;

//other members;

};

//结构体B中包含指向结构体A的指针，在A声明完后，B也随之进行声明

struct B

{

struct A *partner;

//other members;

};

结构体变量的初始化

和其它类型变量一样，对结构体变量可以在定义时指定初始值。

实例

#include <stdio.h>

struct Books

{

char title[50];

char author[50];

char subject[100];

int book_id;

} book = {"C 语言", "RUNOOB", "编程语言", 123456};

int main()

{

printf("title : %s\nauthor: %s\nsubject: %s\nbook_id: %d\n", book.title, book.author, book.subject, book.book_id);

}

执行输出结果为：

title : C 语言

author: RUNOOB

subject: 编程语言

book_id: 123456

访问结构成员

为了访问结构的成员，我们使用成员访问运算符（.）。成员访问运算符是结构变量名称和我们要访问的结构成员之间的一个句号。您可以使用 struct 关键字来定义结构类型的变量。下面的实例演示了结构的用法：

实例

#include <stdio.h>

#include <string.h>

struct Books

{

char title[50];

char author[50];

char subject[100];

int book_id;

};

int main( )

{

struct Books Book1; /* 声明 Book1，类型为 Books */

struct Books Book2; /* 声明 Book2，类型为 Books */

/* Book1 详述 */

strcpy( Book1.title, "C Programming");

strcpy( Book1.author, "Nuha Ali");

strcpy( Book1.subject, "C Programming Tutorial");

Book1.book_id = 6495407;

/* Book2 详述 */

strcpy( Book2.title, "Telecom Billing");

strcpy( Book2.author, "Zara Ali");

strcpy( Book2.subject, "Telecom Billing Tutorial");

Book2.book_id = 6495700;

/* 输出 Book1 信息 */

printf( "Book 1 title : %s\n", Book1.title);

printf( "Book 1 author : %s\n", Book1.author);

printf( "Book 1 subject : %s\n", Book1.subject);

printf( "Book 1 book_id : %d\n", Book1.book_id);

/* 输出 Book2 信息 */

printf( "Book 2 title : %s\n", Book2.title);

printf( "Book 2 author : %s\n", Book2.author);

printf( "Book 2 subject : %s\n", Book2.subject);

printf( "Book 2 book_id : %d\n", Book2.book_id);

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

Book 1 title : C Programming

Book 1 author : Nuha Ali

Book 1 subject : C Programming Tutorial

Book 1 book_id : 6495407

Book 2 title : Telecom Billing

Book 2 author : Zara Ali

Book 2 subject : Telecom Billing Tutorial

Book 2 book_id : 6495700

结构作为函数参数

您可以把结构作为函数参数，传参方式与其他类型的变量或指针类似。您可以使用上面实例中的方式来访问结构变量：

实例

#include <stdio.h>

#include <string.h>

struct Books

{

char title[50];

char author[50];

char subject[100];

int book_id;

};

/* 函数声明 */

void printBook( struct Books book );

int main( )

{

struct Books Book1; /* 声明 Book1，类型为 Books */

struct Books Book2; /* 声明 Book2，类型为 Books */

/* Book1 详述 */

strcpy( Book1.title, "C Programming");

strcpy( Book1.author, "Nuha Ali");

strcpy( Book1.subject, "C Programming Tutorial");

Book1.book_id = 6495407;

/* Book2 详述 */

strcpy( Book2.title, "Telecom Billing");

strcpy( Book2.author, "Zara Ali");

strcpy( Book2.subject, "Telecom Billing Tutorial");

Book2.book_id = 6495700;

/* 输出 Book1 信息 */

printBook( Book1 );

/* 输出 Book2 信息 */

printBook( Book2 );

return 0;

}

void printBook( struct Books book )

{

printf( "Book title : %s\n", book.title);

printf( "Book author : %s\n", book.author);

printf( "Book subject : %s\n", book.subject);

printf( "Book book_id : %d\n", book.book_id);

}

当上面的代码被编译和执行时，它会产生下列结果：

Book title : C Programming

Book author : Nuha Ali

Book subject : C Programming Tutorial

Book book_id : 6495407

Book title : Telecom Billing

Book author : Zara Ali

Book subject : Telecom Billing Tutorial

Book book_id : 6495700

34：指向结构的指针

您可以定义指向结构的指针，方式与定义指向其他类型变量的指针相似，如下所示：

struct Books *struct_pointer;

定义的指针变量中存储结构变量的地址。

为了查找结构变量的地址，请把 & 运算符放在结构名称的前面，如下所示：

struct_pointer = &Book1;

为了使用指向该结构的指针访问结构的成员，您必须使用 -> 运算符，如下所示：

struct_pointer->title;

让我们使用结构指针来重写上面的实例，这将有助于您理解结构指针的概念：

实例

#include <stdio.h>

#include <string.h>

struct Books

{

char title[50];

char author[50];

char subject[100];

int book_id;

};

/* 函数声明 */

void printBook( struct Books *book );

int main( )

{

struct Books Book1; /* 声明 Book1，类型为 Books */

struct Books Book2; /* 声明 Book2，类型为 Books */

/* Book1 详述 */

strcpy( Book1.title, "C Programming");

strcpy( Book1.author, "Nuha Ali");

strcpy( Book1.subject, "C Programming Tutorial");

Book1.book_id = 6495407;

/* Book2 详述 */

strcpy( Book2.title, "Telecom Billing");

strcpy( Book2.author, "Zara Ali");

strcpy( Book2.subject, "Telecom Billing Tutorial");

Book2.book_id = 6495700;

/* 通过传 Book1 的地址来输出 Book1 信息 */

printBook( &Book1 );

/* 通过传 Book2 的地址来输出 Book2 信息 */

printBook( &Book2 );

return 0;

}

void printBook( struct Books *book )

{

printf( "Book title : %s\n", book->title);

printf( "Book author : %s\n", book->author);

printf( "Book subject : %s\n", book->subject);

printf( "Book book_id : %d\n", book->book_id);

}

当上面的代码被编译和执行时，它会产生下列结果：

Book title : C Programming

Book author : Nuha Ali

Book subject : C Programming Tutorial

Book book_id : 6495407

Book title : Telecom Billing

Book author : Zara Ali

Book subject : Telecom Billing Tutorial

Book book_id : 6495700

35：C 共用体

共用体是一种特殊的数据类型，允许您在相同的内存位置存储不同的数据类型。

您可以定义一个带有多成员的共用体，但是任何时候只能有一个成员带有值。共用体提供了一种使用相同的内存位置的有效方式。

定义共用体

为了定义共用体，您必须使用 union 语句，方式与定义结构类似。union 语句定义了一个新的数据类型，带有多个成员。

union 语句的格式如下：

union [union tag]

{

member definition;

...

member definition;

} [one or more union variables];

union tag 是可选的，每个 member definition 是标准的变量定义，比如 int i; 或者 float f; 或者其他有效的变量定义。在共用体定义的末尾，最后一个分号之前，您可以指定一个或多个共用体变量，这是可选的。

下面定义一个名为 Data 的共用体类型，有三个成员 i、f 和 str：

union Data

{

int i;

float f;

char str[20];

} data;

现在，Data 类型的变量可以存储一个整数、一个浮点数，或者一个字符串。这意味着一个变量（相同的内存位置）可以存储多个多种类型的数据。您可以根据需要在一个共用体内使用任何内置的或者用户自定义的数据类型。

共用体占用的内存应足够存储共用体中最大的成员。例如，在上面的实例中，Data 将占用 20 个字节的内存空间，因为在各个成员中，字符串所占用的空间是最大的。下面的实例将显示上面的共用体占用的总内存大小：

实例

#include <stdio.h>

#include <string.h>

union Data

{

int i;

float f;

char str[20];

};

int main( )

{

union Data data;

printf( "Memory size occupied by data : %d\n", sizeof(data));

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

Memory size occupied by data : 20

35：访问共用体成员

为了访问共用体的成员，我们使用成员访问运算符（.）。

成员访问运算符是共用体变量名称和我们要访问的共用体成员之间的一个句号。

您可以使用 union 关键字来定义共用体类型的变量。下面的实例演示了共用体的用法：

实例

#include <stdio.h>

#include <string.h>

union Data

{

int i;

float f;

char str[20];

};

int main( )

{

union Data data;

data.i = 10;

data.f = 220.5;

strcpy( data.str, "C Programming");

printf( "data.i : %d\n", data.i);

printf( "data.f : %f\n", data.f);

printf( "data.str : %s\n", data.str);

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

data.i : 1917853763

data.f : 4122360580327794860452759994368.000000

data.str : C Programming

在这里，我们可以看到共用体的 i 和 f 成员的值有损坏，因为最后赋给变量的值占用了内存位置，这也是 str 成员能够完好输出的原因。

现在让我们再来看一个相同的实例，这次我们在同一时间只使用一个变量，这也演示了使用共用体的主要目的：

实例

#include <stdio.h>

#include <string.h>

union Data

{

int i;

float f;

char str[20];

};

int main( )

{

union Data data;

data.i = 10;

printf( "data.i : %d\n", data.i);

data.f = 220.5;

printf( "data.f : %f\n", data.f);

strcpy( data.str, "C Programming");

printf( "data.str : %s\n", data.str);

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

data.i : 10

data.f : 220.500000

data.str : C Programming

在这里，所有的成员都能完好输出，因为同一时间只用到一个成员。

36：C 位域

如果程序的结构中包含多个开关量，只有 TRUE/FALSE 变量，如下：

struct

{

unsigned int widthValidated;

unsigned int heightValidated;

} status;

这种结构需要 8 字节的内存空间，但在实际上，在每个变量中，我们只存储 0 或 1。

在这种情况下，C 语言提供了一种更好的利用内存空间的方式。

如果您在结构内使用这样的变量，您可以定义变量的宽度来告诉编译器，您将只使用这些字节。

struct

{

unsigned int widthValidated : 1;

unsigned int heightValidated : 1;

} status;

上面的结构中，status 变量将占用 4 个字节的内存空间，但是只有 2 位被用来存储值。如果您用了 32 个变量，每一个变量宽度为 1 位，那么 status 结构将使用 4 个字节，但只要您再多用一个变量，如果使用了 33 个变量，那么它将分配内存的下一段来存储第 33 个变量，这个时候就开始使用 8 个字节。让我们看看下面的实例来理解这个概念：

实例

#include <stdio.h>

#include <string.h>

/* 定义简单的结构 */

struct

{

unsigned int widthValidated;

unsigned int heightValidated;

} status1;

/* 定义位域结构 */

struct

{

unsigned int widthValidated : 1;

unsigned int heightValidated : 1;

} status2;

int main( )

{

printf( "Memory size occupied by status1 : %d\n", sizeof(status1));

printf( "Memory size occupied by status2 : %d\n", sizeof(status2));

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

Memory size occupied by status1 : 8

Memory size occupied by status2 : 4

37：位域声明

在存放一个开关量时，只有 0 和 1 两种状态，用 1 位二进位即可。

为了节省存储空间，并使处理简便，C 语言又提供了一种数据结构，称为"位域"或"位段"。

所谓"位域"是把一个字节中的二进位划分为几个不同的区域，并说明每个区域的位数。

每个域有一个域名，允许在程序中按域名进行操作。

这样就可以把几个不同的对象用一个字节的二进制位域来表示。

典型的实例：

用 1 位二进位存放一个开关量时，只有 0 和 1 两种状态。

读取外部文件格式——可以读取非标准的文件格式。

例如：9 位的整数。

38：位域的定义和位域变量的说明

位域定义与结构定义相仿，其形式为：

struct 位域结构名

{

位域列表

};

其中位域列表的形式为：

type [member_name] : width ;

下面是有关位域中变量元素的描述：

元素描述

type 只能为 int(整型)，unsigned int(无符号整型)，signed int(有符号整型) 三种类型，决定了如何解释位域的值。

member_name 位域的名称。

width 位域中位的数量。

宽度必须小于或等于指定类型的位宽度。

带有预定义宽度的变量被称为位域。

位域可以存储多于 1 位的数，例如，需要一个变量来存储从 0 到 7 的值，您可以定义一个宽度为 3 位的位域，如下：

struct

{

unsigned int age : 3;

} Age;

上面的结构定义指示 C 编译器，age 变量将只使用 3 位来存储这个值，如果您试图使用超过 3 位，则无法完成。

struct bs{

int a:8;

int b:2;

int c:6;

}data;

data 为 bs 变量，共占两个字节。其中位域 a 占 8 位，位域 b 占 2 位，位域 c 占 6 位。

让我们再来看一个实例：

struct packed_struct {

unsigned int f1:1;

unsigned int f2:1;

unsigned int f3:1;

unsigned int f4:1;

unsigned int type:4;

unsigned int my_int:9;

} pack;

在这里，packed_struct 包含了 6 个成员：四个 1 位的标识符 f1..f4、一个 4 位的 type 和一个 9 位的 my_int。

让我们来看下面的实例：

实例

#include <stdio.h>

#include <string.h>

struct

{

unsigned int age : 3;

} Age;

int main( )

{

Age.age = 4;

printf( "Sizeof( Age ) : %d\n", sizeof(Age) );

printf( "Age.age : %d\n", Age.age );

Age.age = 7;

printf( "Age.age : %d\n", Age.age );

Age.age = 8; // 二进制表示为 1000 有四位，超出

printf( "Age.age : %d\n", Age.age );

return 0;

}

当上面的代码被编译时，它会带有警告，当上面的代码被执行时，它会产生下列结果：

Sizeof( Age ) : 4

Age.age : 4

Age.age : 7

Age.age : 0

对于位域的定义尚有以下几点说明：

一个位域存储在同一个字节中，如一个字节所剩空间不够存放另一位域时，则会从下一单元起存放该位域。也可以有意使某位域从下一单元开始。例如：

struct bs{

unsigned a:4;

unsigned :4; /* 空域 */

unsigned b:4; /* 从下一单元开始存放 */

unsigned c:4

}

在这个位域定义中，a 占第一字节的 4 位，后 4 位填 0 表示不使用，b 从第二字节开始，占用 4 位，c 占用 4 位。

位域的宽度不能超过它所依附的数据类型的长度，成员变量都是有类型的，这个类型限制了成员变量的最大长度，: 后面的数字不能超过这个长度。

位域可以是无名位域，这时它只用来作填充或调整位置。无名的位域是不能使用的。

例如：

struct k{

int a:1;

int :2; /* 该 2 位不能使用 */

int b:3;

int c:2;

};

从以上分析可以看出，位域在本质上就是一种结构类型，不过其成员是按二进位分配的。

40：位域的使用

位域的使用和结构成员的使用相同，其一般形式为：

位域变量名.位域名
位域变量名->位域名

位域允许用各种格式输出。

请看下面的实例：

实例

#include <stdio.h>

int main(){

struct bs{

unsigned a:1;

unsigned b:3;

unsigned c:4;

} bit,*pbit;

bit.a=1; /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */

bit.b=7; /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */

bit.c=15; /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */

printf("%d,%d,%d\n",bit.a,bit.b,bit.c); /* 以整型量格式输出三个域的内容 */

pbit=&bit; /* 把位域变量 bit 的地址送给指针变量 pbit */

pbit->a=0; /* 用指针方式给位域 a 重新赋值，赋为 0 */

pbit->b&=3; /* 使用了复合的位运算符 "&="，相当于：pbit->b=pbit->b&3，位域 b 中原有值为 7，与 3 作按位与运算的结果为 3（111&011=011，十进制值为 3） */

pbit->c|=1; /* 使用了复合位运算符"|="，相当于：pbit->c=pbit->c|1，其结果为 15 */

printf("%d,%d,%d\n",pbit->a,pbit->b,pbit->c); /* 用指针方式输出了这三个域的值 */

}

上例程序中定义了位域结构 bs，三个位域为 a、b、c。说明了 bs 类型的变量 bit 和指向 bs 类型的指针变量 pbit。这表示位域也是可以使用指针的。

41：C typedef

C 语言提供了 typedef 关键字，您可以使用它来为类型取一个新的名字。下面的实例为单字节数字定义了一个术语 BYTE：

typedef unsigned char BYTE;

在这个类型定义之后，标识符 BYTE 可作为类型 unsigned char 的缩写，例如：

BYTE b1, b2;

按照惯例，定义时会大写字母，以便提醒用户类型名称是一个象征性的缩写，但您也可以使用小写字母，如下：

typedef unsigned char byte;

您也可以使用 typedef 来为用户自定义的数据类型取一个新的名字。例如，您可以对结构体使用 typedef 来定义一个新的数据类型名字，然后使用这个新的数据类型来直接定义结构变量，如下：

实例

#include <stdio.h>

#include <string.h>

typedef struct Books

{

char title[50];

char author[50];

char subject[100];

int book_id;

} Book;

int main( )

{

Book book;

strcpy( book.title, "C 教程");

strcpy( book.author, "Runoob");

strcpy( book.subject, "编程语言");

book.book_id = 12345;

printf( "书标题 : %s\n", book.title);

printf( "书作者 : %s\n", book.author);

printf( "书类目 : %s\n", book.subject);

printf( "书 ID : %d\n", book.book_id);

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

书标题 : C 教程

书作者 : Runoob

书类目 : 编程语言

书 ID : 12345

42：typedef vs #define

#define 是 C 指令，用于为各种数据类型定义别名，与 typedef 类似，但是它们有以下几点不同：

typedef 仅限于为类型定义符号名称，

#define 不仅可以为类型定义别名，也能为数值定义别名，比如您可以定义 1 为 ONE。

typedef 是由编译器执行解释的，#define 语句是由预编译器进行处理的。

下面是 #define 的最简单的用法：

实例

#include <stdio.h>

#define TRUE 1

#define FALSE 0

int main( )

{

printf( "TRUE 的值: %d\n", TRUE);

printf( "FALSE 的值: %d\n", FALSE);

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

TRUE 的值: 1

FALSE 的值: 0

C 输入 & 输出

输入可以是以文件的形式或从命令行中进行。C 语言提供了一系列内置的函数来读取给定的输入，并根据需要填充到程序中。

当我们提到输出时，这意味着要在屏幕上、打印机上或任意文件中显示一些数据。C 语言提供了一系列内置的函数来输出数据到计算机屏幕上和保存数据到文本文件或二进制文件中。

43：标准文件

C 语言把所有的设备都当作文件。所以设备（比如显示器）被处理的方式与文件相同。以下三个文件会在程序执行时自动打开，以便访问键盘和屏幕。

标准文件 文件指针 设备

标准输入 stdin 键盘

标准输出 stdout 屏幕

标准错误 stderr 您的屏幕

文件指针是访问文件的方式

C 语言中的 I/O (输入/输出) 通常使用 printf() 和 scanf() 两个函数。

scanf() 函数用于从标准输入（键盘）读取并格式化， printf() 函数发送格式化输出到标准输出（屏幕）。

实例

#include <stdio.h> // 执行 printf() 函数需要该库

int main()

{

printf("菜鸟教程"); //显示引号中的内容

return 0;

}

编译以上程序，输出结果为：

菜鸟教程

实例解析：

所有的 C 语言程序都需要包含 main() 函数。代码从 main() 函数开始执行。

printf() 用于格式化输出到屏幕。printf() 函数在 "stdio.h" 头文件中声明。

stdio.h 是一个头文件 (标准输入输出头文件) and #include 是一个预处理命令，用来引入头文件。当编译器遇到 printf() 函数时，如果没有找到 stdio.h 头文件，会发生编译错误。

return 0; 语句用于表示退出程序。

%d 格式化输出整数

#include <stdio.h>

int main()

{

int testInteger = 5;

printf("Number = %d", testInteger);

return 0;

}

编译以上程序，输出结果为：

Number = 5

在 printf() 函数的引号中使用 "%d" (整型) 来匹配整型变量 testInteger 并输出到屏幕。

%f 格式化输出浮点型数据

#include <stdio.h>

int main()

{

float f;

printf("Enter a number: ");

// %f 匹配浮点型数据

scanf("%f",&f);

printf("Value = %f", f);

return 0;

}

getchar() & putchar() 函数

int getchar(void) 函数从屏幕读取下一个可用的字符，并把它返回为一个整数。这个函数在同一个时间内只会读取一个单一的字符。您可以在循环内使用这个方法，以便从屏幕上读取多个字符。

int putchar(int c) 函数把字符输出到屏幕上，并返回相同的字符。这个函数在同一个时间内只会输出一个单一的字符。您可以在循环内使用这个方法，以便在屏幕上输出多个字符。

请看下面的实例：

实例

#include <stdio.h>

int main( )

{

int c;

printf( "Enter a value :");

c = getchar( );

printf( "\nYou entered: ");

putchar( c );

printf( "\n");

return 0;

}

当上面的代码被编译和执行时，它会等待您输入一些文本，当您输入一个文本并按下回车键时，程序会继续并只会读取一个单一的字符，显示如下：

$./a.out

Enter a value :runoob

You entered: r

gets() & puts() 函数

char *gets(char *s) 函数从 stdin 读取一行到 s 所指向的缓冲区，直到一个终止符或 EOF。

int puts(const char *s) 函数把字符串 s 和一个尾随的换行符写入到 stdout。

实例

#include <stdio.h>

int main( )

{

char str[100];

printf( "Enter a value :");

gets( str );

printf( "\nYou entered: ");

puts( str );

return 0;

}

当上面的代码被编译和执行时，它会等待您输入一些文本，当您输入一个文本并按下回车键时，程序会继续并读取一整行直到该行结束，显示如下：

$./a.out

Enter a value :runoob

You entered: runoob

scanf() 和 printf() 函数

int scanf(const char *format, ...) 函数从标准输入流 stdin 读取输入，并根据提供的 format 来浏览输入。

int printf(const char *format, ...) 函数把输出写入到标准输出流 stdout ，并根据提供的格式产生输出。

format 可以是一个简单的常量字符串，但是您可以分别指定 %s、%d、%c、%f 等来输出或读取字符串、整数、字符或浮点数。

现在让我们通过下面这个简单的实例来加深理解：

实例

#include <stdio.h>

int main( ) {

char str[100];

int i;

printf( "Enter a value :");

scanf("%s %d", str, &i);

printf( "\nYou entered: %s %d ", str, i);

printf("\n");

return 0;

}

当上面的代码被编译和执行时，它会等待您输入一些文本，当您输入一个文本并按下回车键时，程序会继续并读取输入，显示如下：

$./a.out

Enter a value :runoob 123

You entered: runoob 123

在这里，应当指出的是，scanf() 期待输入的格式与您给出的 %s 和 %d 相同，这意味着您必须提供有效的输入，比如 "string integer"，如果您提供的是 "string string" 或 "integer integer"，它会被认为是错误的输入。另外，在读取字符串时，只要遇到一个空格，scanf() 就会停止读取，所以 "this is test" 对 scanf() 来说是三个字符串。

44：C 文件读写

如何创建、打开、关闭文本文件或二进制文件。

一个文件，无论它是文本文件还是二进制文件，都是代表了一系列的字节。C 语言不仅提供了访问顶层的函数，也提供了底层（OS）调用来处理存储设备上的文件。

打开文件

您可以使用 fopen( ) 函数来创建一个新的文件或者打开一个已有的文件，这个调用会初始化类型 FILE 的一个对象，类型 FILE 包含了所有用来控制流的必要的信息。下面是这个函数调用的原型：

FILE *fopen( const char *filename, const char *mode );

在这里，filename 是字符串，用来命名文件，访问模式 mode 的值可以是下列值中的一个：

模式描述

r 打开一个已有的文本文件，允许读取文件。

w 打开一个文本文件，允许写入文件。如果文件不存在，则会创建一个新文件。在这里，您的程序会从文件的开头写入内容。如果文件存在，则该会被截断为零长度，重新写入。

a 打开一个文本文件，以追加模式写入文件。如果文件不存在，则会创建一个新文件。在这里，您的程序会在已有的文件内容中追加内容。

r+ 打开一个文本文件，允许读写文件。

w+ 打开一个文本文件，允许读写文件。如果文件已存在，则文件会被截断为零长度，如果文件不存在，则会创建一个新文件。

a+ 打开一个文本文件，允许读写文件。如果文件不存在，则会创建一个新文件。读取会从文件的开头开始，写入则只能是追加模式。

如果处理的是二进制文件，则需使用下面的访问模式来取代上面的访问模式：

"rb", "wb", "ab", "rb+", "r+b", "wb+", "w+b", "ab+", "a+b"

关闭文件

为了关闭文件，请使用 fclose( ) 函数。函数的原型如下：

int fclose( FILE *fp );

如果成功关闭文件，fclose( ) 函数返回零，如果关闭文件时发生错误，函数返回 EOF。这个函数实际上，会清空缓冲区中的数据，关闭文件，并释放用于该文件的所有内存。EOF 是一个定义在头文件 stdio.h 中的常量。

C 标准库提供了各种函数来按字符或者以固定长度字符串的形式读写文件。

写入文件

下面是把字符写入到流中的最简单的函数：

int fputc( int c, FILE *fp );

函数 fputc() 把参数 c 的字符值写入到 fp 所指向的输出流中。如果写入成功，它会返回写入的字符，如果发生错误，则会返回 EOF。您可以使用下面的函数来把一个以 null 结尾的字符串写入到流中：

int fputs( const char *s, FILE *fp );

函数 fputs() 把字符串 s 写入到 fp 所指向的输出流中。如果写入成功，它会返回一个非负值，如果发生错误，则会返回 EOF。

您也可以使用 int fprintf(FILE *fp,const char *format, ...) 函数把一个字符串写入到文件中。尝试下面的实例：

注意：请确保您有可用的 tmp 目录，如果不存在该目录，则需要在您的计算机上先创建该目录。

/tmp 一般是 Linux 系统上的临时目录，如果你在 Windows 系统上运行，则需要修改为本地环境中已存在的目录，例如: C:\tmp、D:\tmp等。

实例

#include <stdio.h>

int main()

{

FILE *fp = NULL;

fp = fopen("/tmp/test.txt", "w+");

fprintf(fp, "This is testing for fprintf...\n");

fputs("This is testing for fputs...\n", fp);

fclose(fp);

}

当上面的代码被编译和执行时，它会在 /tmp 目录中创建一个新的文件 test.txt，并使用两个不同的函数写入两行。接下来让我们来读取这个文件。

读取文件

下面是从文件读取单个字符的最简单的函数：

int fgetc( FILE * fp );

fgetc() 函数从 fp 所指向的输入文件中读取一个字符。返回值是读取的字符，如果发生错误则返回 EOF。下面的函数允许您从流中读取一个字符串：

char *fgets( char *buf, int n, FILE *fp );

函数 fgets() 从 fp 所指向的输入流中读取 n - 1 个字符。它会把读取的字符串复制到缓冲区 buf，并在最后追加一个 null 字符来终止字符串。

如果这个函数在读取最后一个字符之前就遇到一个换行符 '\n' 或文件的末尾 EOF，则只会返回读取到的字符，包括换行符。您也可以使用 int fscanf(FILE *fp, const char *format, ...) 函数来从文件中读取字符串，但是在遇到第一个空格和换行符时，它会停止读取。

实例

#include <stdio.h>

int main()

{

FILE *fp = NULL;

char buff[255];

fp = fopen("/tmp/test.txt", "r");

fscanf(fp, "%s", buff);

printf("1: %s\n", buff );

fgets(buff, 255, (FILE*)fp);

printf("2: %s\n", buff );

fgets(buff, 255, (FILE*)fp);

printf("3: %s\n", buff );

fclose(fp);

}

当上面的代码被编译和执行时，它会读取上一部分创建的文件，产生下列结果：

1: This

2: is testing for fprintf...

3: This is testing for fputs...

首先，fscanf() 方法只读取了 This，因为它在后边遇到了一个空格。其次，调用 fgets() 读取剩余的部分，直到行尾。最后，调用 fgets() 完整地读取第二行。

45：二进制 I/O 函数

下面两个函数用于二进制输入和输出：

size_t fread(void *ptr, size_t size_of_elements,

size_t number_of_elements, FILE *a_file);

size_t fwrite(const void *ptr, size_t size_of_elements,

size_t number_of_elements, FILE *a_file);

这两个函数都是用于存储块的读写 - 通常是数组或结构体。

46：C 预处理器

C 预处理器不是编译器的组成部分，但是它是编译过程中一个单独的步骤。简言之，C 预处理器只不过是一个文本替换工具而已，它们会指示编译器在实际编译之前完成所需的预处理。我们将把 C 预处理器（C Preprocessor）简写为 CPP。

所有的预处理器命令都是以井号（#）开头。它必须是第一个非空字符，为了增强可读性，预处理器指令应从第一列开始。下面列出了所有重要的预处理器指令：

指令描述

#define 定义宏

#include 包含一个源代码文件

#undef 取消已定义的宏

#ifdef 如果宏已经定义，则返回真

#ifndef 如果宏没有定义，则返回真

#if 如果给定条件为真，则编译下面代码

#else #if 的替代方案

#elif 如果前面的 #if 给定条件不为真，当前条件为真，则编译下面代码

#endif 结束一个 #if……#else 条件编译块

#error 当遇到标准错误时，输出错误消息

#pragma 使用标准化方法，向编译器发布特殊的命令到编译器中

预处理器实例

分析下面的实例来理解不同的指令。

#define MAX_ARRAY_LENGTH 20

这个指令告诉 CPP 把所有的 MAX_ARRAY_LENGTH 定义为 20。使用 #define 定义常量来增强可读性。

#include <stdio.h>

#include "myheader.h"

这些指令告诉 CPP 从系统库中获取 stdio.h，并添加文本到当前的源文件中。下一行告诉 CPP 从本地目录中获取 myheader.h，并添加内容到当前的源文件中。

#undef FILE_SIZE

#define FILE_SIZE 42

这个指令告诉 CPP 取消已定义的 FILE_SIZE，并定义它为 42。

#ifndef MESSAGE

#define MESSAGE "You wish!"

#endif

这个指令告诉 CPP 只有当 MESSAGE 未定义时，才定义 MESSAGE。

#ifdef DEBUG

/* Your debugging statements here */

#endif

这个指令告诉 CPP 如果定义了 DEBUG，则执行处理语句。在编译时，如果您向 gcc 编译器传递了 -DDEBUG 开关量，这个指令就非常有用。它定义了 DEBUG，您可以在编译期间随时开启或关闭调试。

预定义宏

ANSI C 定义了许多宏。在编程中您可以使用这些宏，但是不能直接修改这些预定义的宏。

宏描述

__DATE__ 当前日期，一个以 "MMM DD YYYY" 格式表示的字符常量。

__TIME__ 当前时间，一个以 "HH:MM:SS" 格式表示的字符常量。

__FILE__ 这会包含当前文件名，一个字符串常量。

__LINE__ 这会包含当前行号，一个十进制常量。

__STDC__ 当编译器以 ANSI 标准编译时，则定义为 1。

让我们来尝试下面的实例：

实例

#include <stdio.h>

main()

{

printf("File :%s\n", __FILE__ );

printf("Date :%s\n", __DATE__ );

printf("Time :%s\n", __TIME__ );

printf("Line :%d\n", __LINE__ );

printf("ANSI :%d\n", __STDC__ );

}

当上面的代码（在文件 test.c 中）被编译和执行时，它会产生下列结果：

File :test.c

Date :Jun 2 2012

Time :03:36:24

Line :8

ANSI :1

48：预处理器运算符

C 预处理器提供了下列的运算符来帮助您创建宏：宏延续运算符（\）

一个宏通常写在一个单行上。但是如果宏太长，一个单行容纳不下，则使用宏延续运算符（\）。例如：

#define message_for(a, b) \

printf(#a " and " #b ": We love you!\n")

字符串常量化运算符（#）

在宏定义中，当需要把一个宏的参数转换为字符串常量时，则使用字符串常量化运算符（#）。在宏中使用的该运算符有一个特定的参数或参数列表。例如：

实例

#include <stdio.h>

#define message_for(a, b) \

printf(#a " and " #b ": We love you!\n")

int main(void)

{

message_for(Carole, Debra);

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

Carole and Debra: We love you!

标记粘贴运算符（##）

宏定义内的标记粘贴运算符（##）会合并两个参数。它允许在宏定义中两个独立的标记被合并为一个标记。例如：

实例

#include <stdio.h>

#define tokenpaster(n) printf ("token" #n " = %d", token##n)

int main(void)

{

int token34 = 40;

tokenpaster(34);

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

token34 = 40

这是怎么发生的，因为这个实例会从编译器产生下列的实际输出：

printf ("token34 = %d", token34);

这个实例演示了 token##n 会连接到 token34 中，在这里，我们使用了字符串常量化运算符（#）和标记粘贴运算符（##）。

defined() 运算符

预处理器 defined 运算符是用在常量表达式中的，用来确定一个标识符是否已经使用 #define 定义过。如果指定的标识符已定义，则值为真（非零）。如果指定的标识符未定义，则值为假（零）。下面的实例演示了 defined() 运算符的用法：

实例

#include <stdio.h>

#if !defined (MESSAGE)

#define MESSAGE "You wish!"

#endif

int main(void)

{

printf("Here is the message: %s\n", MESSAGE);

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

Here is the message: You wish!

参数化的宏

CPP 一个强大的功能是可以使用参数化的宏来模拟函数。例如，下面的代码是计算一个数的平方：

int square(int x) {

return x * x;

}

我们可以使用宏重写上面的代码，如下：

#define square(x) ((x) * (x))

在使用带有参数的宏之前，必须使用 #define 指令定义。参数列表是括在圆括号内，且必须紧跟在宏名称的后边。宏名称和左圆括号之间不允许有空格。例如：

实例

#include <stdio.h>

#define MAX(x,y) ((x) > (y) ? (x) : (y))

int main(void)

{

printf("Max between 20 and 10 is %d\n", MAX(10, 20));

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

Max between 20 and 10 is 20

49：C 头文件

头文件是扩展名为 .h 的文件，包含了 C 函数声明和宏定义，被多个源文件中引用共享。有两种类型的头文件：程序员编写的头文件和编译器自带的头文件。

在程序中要使用头文件，需要使用 C 预处理指令 #include 来引用它。前面我们已经看过 stdio.h 头文件，它是编译器自带的头文件。

引用头文件相当于复制头文件的内容，但是我们不会直接在源文件中复制头文件的内容，因为这么做很容易出错，特别在程序是由多个源文件组成的时候。

A simple practice in C 或 C++ 程序中，建议把所有的常量、宏、系统全局变量和函数原型写在头文件中，在需要的时候随时引用这些头文件。

引用头文件的语法

使用预处理指令 #include 可以引用用户和系统头文件。

它的形式有以下两种：

#include <file>

这种形式用于引用系统头文件。它在系统目录的标准列表中搜索名为 file 的文件。在编译源代码时，您可以通过 -I 选项把目录前置在该列表前。

#include "file"

这种形式用于引用用户头文件。它在包含当前文件的目录中搜索名为 file 的文件。在编译源代码时，您可以通过 -I 选项把目录前置在该列表前。

引用头文件的操作

#include 指令会指示 C 预处理器浏览指定的文件作为输入。预处理器的输出包含了已经生成的输出，被引用文件生成的输出以及 #include 指令之后的文本输出。

例如，如果您有一个头文件 header.h，如下：

char *test (void);

和一个使用了头文件的主程序 program.c，如下：

int x;

#include "header.h"

int main (void)

{

puts (test ());

}

编译器会看到如下的代码信息：

int x;

char *test (void);

int main (void)

{

puts (test ());

}

只引用一次头文件

如果一个头文件被引用两次，编译器会处理两次头文件的内容，这将产生错误。为了防止这种情况，标准的做法是把文件的整个内容放在条件编译语句中，如下：

#ifndef HEADER_FILE

#define HEADER_FILE

the entire header file file

#endif

这种结构就是通常所说的包装器 #ifndef。当再次引用头文件时，条件为假，因为 HEADER_FILE 已定义。此时，预处理器会跳过文件的整个内容，编译器会忽略它。

有条件引用

有时需要从多个不同的头文件中选择一个引用到程序中。例如，需要指定在不同的操作系统上使用的配置参数。您可以通过一系列条件来实现这点，如下：

#if SYSTEM_1

# include "system_1.h"

#elif SYSTEM_2

# include "system_2.h"

#elif SYSTEM_3

...

#endif

但是如果头文件比较多的时候，这么做是很不妥当的，预处理器使用宏来定义头文件的名称。这就是所谓的有条件引用。它不是用头文件的名称作为 #include 的直接参数，您只需要使用宏名称代替即可：

#define SYSTEM_H "system_1.h"

...

#include SYSTEM_H

SYSTEM_H 会扩展，预处理器会查找 system_1.h，就像 #include 最初编写的那样。SYSTEM_H 可通过 -D 选项被您的 Makefile 定义。

50：C 强制类型转换

强制类型转换是把变量从一种类型转换为另一种数据类型。例如，如果您想存储一个 long 类型的值到一个简单的整型中，您需要把 long 类型强制转换为 int 类型。您可以使用强制类型转换运算符来把值显式地从一种类型转换为另一种类型，如下所示：

(type_name) expression

请看下面的实例，使用强制类型转换运算符把一个整数变量除以另一个整数变量，得到一个浮点数：

实例

#include <stdio.h>

int main()

{

int sum = 17, count = 5;

double mean;

mean = (double) sum / count;

printf("Value of mean : %f\n", mean );

}

当上面的代码被编译和执行时，它会产生下列结果：

Value of mean : 3.400000

这里要注意的是强制类型转换运算符的优先级大于除法，因此 sum 的值首先被转换为 double 型，然后除以 count，得到一个类型为 double 的值。

类型转换可以是隐式的，由编译器自动执行，也可以是显式的，通过使用强制类型转换运算符来指定。在编程时，有需要类型转换的时候都用上强制类型转换运算符，是一种良好的编程习惯。

整数提升

整数提升是指把小于 int 或 unsigned int 的整数类型转换为 int 或 unsigned int 的过程。请看下面的实例，在 int 中添加一个字符：

实例

#include <stdio.h>

int main()

{

int i = 17;

char c = 'c'; /* ascii 值是 99 */

int sum;

sum = i + c;

printf("Value of sum : %d\n", sum );

}

当上面的代码被编译和执行时，它会产生下列结果：

Value of sum : 116

在这里，sum 的值为 116，因为编译器进行了整数提升，在执行实际加法运算时，把 'c' 的值转换为对应的 ascii 值。

常用的算术转换

常用的算术转换是隐式地把值强制转换为相同的类型。编译器首先执行整数提升，如果操作数类型不同，则它们会被转换为下列层次中出现的最高层次的类型：

Usual Arithmetic Conversion

常用的算术转换不适用于赋值运算符、逻辑运算符 && 和 ||。

让我们看看下面的实例来理解这个概念：

实例

#include <stdio.h>

int main()

{

int i = 17;

char c = 'c'; /* ascii 值是 99 */

float sum;

sum = i + c;

printf("Value of sum : %f\n", sum );

}

当上面的代码被编译和执行时，它会产生下列结果：

Value of sum : 116.000000

在这里，c 首先被转换为整数，但是由于最后的值是 float 型的，所以会应用常用的算术转换，编译器会把 i 和 c 转换为浮点型，并把它们相加得到一个浮点数。

52：C 错误处理

C 语言不提供对错误处理的直接支持，但是作为一种系统编程语言，它以返回值的形式允许您访问底层数据。在发生错误时，大多数的 C 或 UNIX 函数调用返回 1 或 NULL，同时会设置一个错误代码 errno，该错误代码是全局变量，表示在函数调用期间发生了错误。您可以在 errno.h 头文件中找到各种各样的错误代码。

所以，C 程序员可以通过检查返回值，然后根据返回值决定采取哪种适当的动作。开发人员应该在程序初始化时，把 errno 设置为 0，这是一种良好的编程习惯。0 值表示程序中没有错误。

errno、perror() 和 strerror()

C 语言提供了 perror() 和 strerror() 函数来显示与 errno 相关的文本消息。

perror() 函数显示您传给它的字符串，后跟一个冒号、一个空格和当前 errno 值的文本表示形式。

strerror() 函数，返回一个指针，指针指向当前 errno 值的文本表示形式。

让我们来模拟一种错误情况，尝试打开一个不存在的文件。您可以使用多种方式来输出错误消息，在这里我们使用函数来演示用法。另外有一点需要注意，您应该使用 stderr 文件流来输出所有的错误。

实例

#include <stdio.h>

#include <errno.h>

#include <string.h>

extern int errno ;

int main ()

{

FILE * pf;

int errnum;

pf = fopen ("unexist.txt", "rb");

if (pf == NULL)

{

errnum = errno;

fprintf(stderr, "错误号: %d\n", errno);

perror("通过 perror 输出错误");

fprintf(stderr, "打开文件错误: %s\n", strerror( errnum ));

}

else

{

fclose (pf);

}

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

错误号: 2

通过 perror 输出错误: No such file or directory

打开文件错误: No such file or directory

被零除的错误

在进行除法运算时，如果不检查除数是否为零，则会导致一个运行时错误。

为了避免这种情况发生，下面的代码在进行除法运算前会先检查除数是否为零：

实例

#include <stdio.h>

#include <stdlib.h>

int main()

{

int dividend = 20;

int divisor = 0;

int quotient;

if( divisor == 0){

fprintf(stderr, "除数为 0 退出运行...\n");

exit(-1);

}

quotient = dividend / divisor;

fprintf(stderr, "quotient 变量的值为 : %d\n", quotient );

exit(0);

}

当上面的代码被编译和执行时，它会产生下列结果：

除数为 0 退出运行...

程序退出状态

通常情况下，程序成功执行完一个操作正常退出的时候会带有值 EXIT_SUCCESS。在这里，EXIT_SUCCESS 是宏，它被定义为 0。

如果程序中存在一种错误情况，当您退出程序时，会带有状态值 EXIT_FAILURE，被定义为 -1。所以，上面的程序可以写成：

实例

#include <stdio.h>

#include <stdlib.h>

main()

{

int dividend = 20;

int divisor = 5;

int quotient;

if( divisor == 0){

fprintf(stderr, "除数为 0 退出运行...\n");

exit(EXIT_FAILURE);

}

quotient = dividend / divisor;

fprintf(stderr, "quotient 变量的值为: %d\n", quotient );

exit(EXIT_SUCCESS);

}

当上面的代码被编译和执行时，它会产生下列结果：

quotient 变量的值为 : 4

53：C 递归

递归指的是在函数的定义中使用函数自身的方法。

举个例子：

从前有座山，山里有座庙，庙里有个老和尚，正在给小和尚讲故事呢！故事是什么呢？"从前有座山，山里有座庙，庙里有个老和尚，正在给小和尚讲故事呢！故事是什么呢？'从前有座山，山里有座庙，庙里有个老和尚，正在给小和尚讲故事呢！故事是什么呢？……'"

语法格式如下：

void recursion()

{

statements;

... ... ...

recursion(); /* 函数调用自身 */

... ... ...

}

int main()

{

recursion();

}

C 语言支持递归，即一个函数可以调用其自身。但在使用递归时，程序员需要注意定义一个从函数退出的条件，否则会进入死循环。

递归函数在解决许多数学问题上起了至关重要的作用，比如计算一个数的阶乘、生成斐波那契数列，等等。

数的阶乘

下面的实例使用递归函数计算一个给定的数的阶乘：

实例

#include <stdio.h>

double factorial(unsigned int i)

{

if(i <= 1)

{

return 1;

}

return i * factorial(i - 1);

}

int main()

{

int i = 15;

printf("%d 的阶乘为 %f\n", i, factorial(i));

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

15 的阶乘为 1307674368000.000000

斐波那契数列

下面的实例使用递归函数生成一个给定的数的斐波那契数列：

实例

#include <stdio.h>

int fibonaci(int i)

{

if(i == 0)

{

return 0;

}

if(i == 1)

{

return 1;

}

return fibonaci(i-1) + fibonaci(i-2);

}

int main()

{

int i;

for (i = 0; i < 10; i++)

{

printf("%d\t\n", fibonaci(i));

}

return 0;

}

当上面的代码被编译和执行时，它会产生下列结果：

C 可变参数

有时，您可能会碰到这样的情况，您希望函数带有可变数量的参数，而不是预定义数量的参数。C 语言为这种情况提供了一个解决方案，它允许您定义一个函数，能根据具体的需求接受可变数量的参数。下面的实例演示了这种函数的定义。

int func(int, ... )

{

}

int main()

{

func(2, 2, 3);

func(3, 2, 3, 4);

}

请注意，函数 func() 最后一个参数写成省略号，即三个点号（...），省略号之前的那个参数是 int，代表了要传递的可变参数的总数。为了使用这个功能，您需要使用 stdarg.h 头文件，该文件提供了实现可变参数功能的函数和宏。具体步骤如下：

定义一个函数，最后一个参数为省略号，省略号前面可以设置自定义参数。

在函数定义中创建一个 va_list 类型变量，该类型是在 stdarg.h 头文件中定义的。

使用 int 参数和 va_start 宏来初始化 va_list 变量为一个参数列表。宏 va_start 是在 stdarg.h 头文件中定义的。

使用 va_arg 宏和 va_list 变量来访问参数列表中的每个项。

使用宏 va_end 来清理赋予 va_list 变量的内存。

现在让我们按照上面的步骤，来编写一个带有可变数量参数的函数，并返回它们的平均值：

实例

#include <stdio.h>

#include <stdarg.h>

double average(int num,...)

{

va_list valist;

double sum = 0.0;

int i;

/* 为 num 个参数初始化 valist */

va_start(valist, num);

/* 访问所有赋给 valist 的参数 */

for (i = 0; i < num; i++)

{

sum += va_arg(valist, int);

}

/* 清理为 valist 保留的内存 */

va_end(valist);

return sum/num;

}

int main()

{

printf("Average of 2, 3, 4, 5 = %f\n", average(4, 2,3,4,5));

printf("Average of 5, 10, 15 = %f\n", average(3, 5,10,15));

}

当上面的代码被编译和执行时，它会产生下列结果。应该指出的是，函数 average() 被调用两次，每次第一个参数都是表示被传的可变参数的总数。省略号被用来传递可变数量的参数。

Average of 2, 3, 4, 5 = 3.500000

Average of 5, 10, 15 = 10.000000

54：C 内存管理

本章将讲解 C 中的动态内存管理。C 语言为内存的分配和管理提供了几个函数。这些函数可以在 <stdlib.h> 头文件中找到。

序号 函数和描述

1 void *calloc(int num, int size);

在内存中动态地分配 num 个长度为 size 的连续空间，并将每一个字节都初始化为 0。所以它的结果是分配了 num*size 个字节长度的内存空间，并且每个字节的值都是0。

2 void free(void *address);

该函数释放 address 所指向的内存块,释放的是动态分配的内存空间。

3 void *malloc(int num);

在堆区分配一块指定大小的内存空间，用来存放数据。这块内存空间在函数执行完成后不会被初始化，它们的值是未知的。

4 void *realloc(void *address, int newsize);

该函数重新分配内存，把内存扩展到 newsize。

注意：void * 类型表示未确定类型的指针。C、C++ 规定 void * 类型可以通过类型转换强制转换为任何其它类型的指针。

55：动态分配内存

编程时，如果您预先知道数组的大小，那么定义数组时就比较容易。例如，一个存储人名的数组，它最多容纳 100 个字符，所以您可以定义数组，如下所示：

char name[100];

但是，如果您预先不知道需要存储的文本长度，例如您想存储有关一个主题的详细描述。在这里，我们需要定义一个指针，该指针指向未定义所需内存大小的字符，后续再根据需求来分配内存，如下所示：

实例

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

int main()

{

char name[100];

char *description;

strcpy(name, "Zara Ali");

/* 动态分配内存 */

description = (char *)malloc( 200 * sizeof(char) );

if( description == NULL )

{

fprintf(stderr, "Error - unable to allocate required memory\n");

}

else

{

strcpy( description, "Zara ali a DPS student in class 10th");

}

printf("Name = %s\n", name );

printf("Description: %s\n", description );

}

当上面的代码被编译和执行时，它会产生下列结果：

Name = Zara Ali

Description: Zara ali a DPS student in class 10th

上面的程序也可以使用 calloc() 来编写，只需要把 malloc 替换为 calloc 即可，如下所示：

calloc(200, sizeof(char));

当动态分配内存时，您有完全控制权，可以传递任何大小的值。而那些预先定义了大小的数组，一旦定义则无法改变大小。

重新调整内存的大小和释放内存

当程序退出时，操作系统会自动释放所有分配给程序的内存，但是，建议您在不需要内存时，都应该调用函数 free() 来释放内存。

或者，您可以通过调用函数 realloc() 来增加或减少已分配的内存块的大小。让我们使用 realloc() 和 free() 函数，再次查看上面的实例：

实例

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

int main()

{

char name[100];

char *description;

strcpy(name, "Zara Ali");

/* 动态分配内存 */

description = (char *)malloc( 30 * sizeof(char) );

if( description == NULL )

{

fprintf(stderr, "Error - unable to allocate required memory\n");

}

else

{

strcpy( description, "Zara ali a DPS student.");

}

/* 假设您想要存储更大的描述信息 */

description = (char *) realloc( description, 100 * sizeof(char) );

if( description == NULL )

{

fprintf(stderr, "Error - unable to allocate required memory\n");

}

else

{

strcat( description, "She is in class 10th");

}

printf("Name = %s\n", name );

printf("Description: %s\n", description );

/* 使用 free() 函数释放内存 */

free(description);

}

当上面的代码被编译和执行时，它会产生下列结果：

Name = Zara Ali

Description: Zara ali a DPS student.She is in class 10th

您可以尝试一下不重新分配额外的内存，strcat() 函数会生成一个错误，因为存储 description 时可用的内存不足。

56：C 命令行参数

执行程序时，可以从命令行传值给 C 程序。这些值被称为命令行参数，它们对程序很重要，特别是当您想从外部控制程序，而不是在代码内对这些值进行硬编码时，就显得尤为重要了。

命令行参数是使用 main() 函数参数来处理的，其中，argc 是指传入参数的个数，argv[] 是一个指针数组，指向传递给程序的每个参数。下面是一个简单的实例，检查命令行是否有提供参数，并根据参数执行相应的动作：

#include <stdio.h>

int main( int argc, char *argv[] )

{

if( argc == 2 )

{

printf("The argument supplied is %s\n", argv[1]);

}

else if( argc > 2 )

{

printf("Too many arguments supplied.\n");

}

else

{

printf("One argument expected.\n");

}

使用一个参数，编译并执行上面的代码，它会产生下列结果：

$./a.out testing

The argument supplied is testing

使用两个参数，编译并执行上面的代码，它会产生下列结果：

$./a.out testing1 testing2

Too many arguments supplied.

不传任何参数，编译并执行上面的代码，它会产生下列结果：

$./a.out

One argument expected

应当指出的是，argv[0] 存储程序的名称，argv[1] 是一个指向第一个命令行参数的指针，*argv[n] 是最后一个参数。如果没有提供任何参数，argc 将为 1，否则，如果传递了一个参数，argc 将被设置为 2。

多个命令行参数之间用空格分隔，但是如果参数本身带有空格，那么传递参数的时候应把参数放置在双引号 "" 或单引号 '' 内部。让我们重新编写上面的实例，有一个空间，那么你可以通过这样的观点，把它们放在双引号或单引号""""。让我们重新编写上面的实例，向程序传递一个放置在双引号内部的命令行参数：

#include <stdio.h>

int main( int argc, char *argv[] )

{

printf("Program name %s\n", argv[0]);

if( argc == 2 )

{

printf("The argument supplied is %s\n", argv[1]);

}

else if( argc > 2 )

{

printf("Too many arguments supplied.\n");

}

else

{

printf("One argument expected.\n");

}

使用一个用空格分隔的简单参数，参数括在双引号中，编译并执行上面的代码，它会产生下列结果：

$./a.out "testing1 testing2"

Progranm name ./a.out

The argument supplied is testing1 testing2

60：C 排序算法

1：冒泡排序（英语：Bubble Sort）是一种简单的排序算法。

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。

#include <stdio.h>

void bubble_sort(int arr[], int len) {

int i, j, temp;

for (i = 0; i < len - 1; i++)

for (j = 0; j < len - 1 - i; j++)

if (arr[j] > arr[j + 1]) {

temp = arr[j];

arr[j] = arr[j + 1];

arr[j + 1] = temp;

}

int main() {

int arr[] = { 22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70 };

int len = (int) sizeof(arr) / sizeof(*arr);

bubble_sort(arr, len);

int i;

for (i = 0; i < len; i++)

printf("%d ", arr[i]);

return 0;

}

2：选择排序

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

void selection_sort(int a[], int len)

{

int i,j,temp;

for (i = 0 ; i < len - 1 ; i++)

{

int min = i; // 记录最小值，第一个元素默认最小

for (j = i + 1; j < len; j++) // 访问未排序的元素

{

if (a[j] < a[min]) // 找到目前最小值

{

min = j; // 记录最小值

}

if(min != i)

{

temp=a[min]; // 交换两个变量

a[min]=a[i];

a[i]=temp;

}

/* swap(&a[min], &a[i]); */ // 使用自定义函数交換

}

void swap(int *a,int *b) // 交换两个变量

{

int temp = *a;

*a = *b;

*b = temp;

}*/

3：插入排序

插入排序（英语：Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到 {\displaystyle O(1)} {\displaystyle O(1)}的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

void insertion_sort(int arr[], int len){

int i,j,temp;

for (i=1;i<len;i++){

temp = arr[i];

for (j=i;j>0 && arr[j-1]>temp;j--)

arr[j] = arr[j-1];

arr[j] = temp;

}

4：希尔排序

希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率
但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位

void shell_sort(int arr[], int len) {

int gap, i, j;

int temp;

for (gap = len >> 1; gap > 0; gap = gap >> 1)

for (i = gap; i < len; i++) {

temp = arr[i];

for (j = i - gap; j >= 0 && arr[j] > temp; j -= gap)

arr[j + gap] = arr[j];

arr[j + gap] = temp;

}

5:归并排序

把数据分为两段，从两段中逐个选最小的元素移入新数据段的末尾。

可从上到下或从下到上进行。

1:迭代法

int min(int x, int y) {

return x < y ? x : y;

}

void merge_sort(int arr[], int len) {

int* a = arr;

int* b = (int*) malloc(len * sizeof(int));

int seg, start;

for (seg = 1; seg < len; seg += seg) {

for (start = 0; start < len; start += seg + seg) {

int low = start, mid = min(start + seg, len), high = min(start + seg + seg, len);

int k = low;

int start1 = low, end1 = mid;

int start2 = mid, end2 = high;

while (start1 < end1 && start2 < end2)

b[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];

while (start1 < end1)

b[k++] = a[start1++];

while (start2 < end2)

b[k++] = a[start2++];

}

int* temp = a;

a = b;

b = temp; }

if (a != arr) {

int i;

for (i = 0; i < len; i++)

b[i] = a[i];

b = a; }

free(b);}

2:递归法

void merge_sort_recursive(int arr[], int reg[], int start, int end) {

if (start >= end)

return;

int len = end - start, mid = (len >> 1) + start;

int start1 = start, end1 = mid;

int start2 = mid + 1, end2 = end;

merge_sort_recursive(arr, reg, start1, end1);

merge_sort_recursive(arr, reg, start2, end2);

int k = start;

while (start1 <= end1 && start2 <= end2)

reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];

while (start1 <= end1)

reg[k++] = arr[start1++];

while (start2 <= end2)

reg[k++] = arr[start2++];

for (k = start; k <= end; k++)

arr[k] = reg[k];}

void merge_sort(int arr[], const int len) {

int reg[len];

merge_sort_recursive(arr, reg, 0, len - 1);}

6:快速排序

在区间中随机挑选一个元素作基准，将小于基准的元素放在基准之前，大于基准的元素放在基准之后，再分别对小数区与大数区进行排序。

1:迭代法

typedef struct _Range {

int start, end;

} Range;

Range new_Range(int s, int e) {

Range r;

r.start = s;

r.end = e;

return r;}

void swap(int *x, int *y) {

int t = *x;

*x = *y;

*y = t;}

void quick_sort(int arr[], const int len) {

if (len <= 0)

return; // 避免len等於負值時引發段錯誤（Segment Fault）

// r[]模擬列表,p為數量,r[p++]為push,r[--p]為pop且取得元素

Range r[len];

int p = 0;

r[p++] = new_Range(0, len - 1);

while (p) {

Range range = r[--p];

if (range.start >= range.end)

continue;

int mid = arr[(range.start + range.end) / 2]; // 選取中間點為基準點

int left = range.start, right = range.end;

{

while (arr[left] < mid) ++left; // 檢測基準點左側是否符合要求

while (arr[right] > mid) --right; //檢測基準點右側是否符合要求

if (left <= right)

{

swap(&arr[left],&arr[right]);

left++;right--; // 移動指針以繼續

}

} while (left <= right);

if (range.start < right) r[p++] = new_Range(range.start, right);

if (range.end > left) r[p++] = new_Range(left, range.end);

}

2:递归法

void swap(int *x, int *y) {

int t = *x;

*x = *y;

*y = t;}

void quick_sort_recursive(int arr[], int start, int end) {

if (start >= end)

return;

int mid = arr[end];

int left = start, right = end - 1;

while (left < right) {

while (arr[left] < mid && left < right)

left++;

while (arr[right] >= mid && left < right)

right--;

swap(&arr[left], &arr[right]);

}

if (arr[left] >= arr[end])

swap(&arr[left], &arr[end]);

else

left++;

if (left)

quick_sort_recursive(arr, start, left - 1);

quick_sort_recursive(arr, left + 1, end);

}

void quick_sort(int arr[], int len) {

quick_sort_recursive(arr, 0, len - 1);

}

C语言是由函数组合

C 语言实例

1、C 语言实例 - 输出 "Hello, World!"

#include <stdio.h>

int main()

{

// printf() 中字符串需要引号

printf("Hello, World!");

return 0;

}

2、 C 语言实例 - 输出整数

#include <stdio.h>

int main()

{

int number;

// printf() 输出字符串

printf("输入一个整数: ");

// scanf() 格式化输入

scanf("%d", &number);

// printf() 显示格式化输入

printf("你输入的整数是: %d", number);

return 0;

}

输出结果：

输入一个整数: 45

你输入的整数是: 45

3、 C 语言实例 - 输出单个字符

实例

#include <stdio.h>

int main() {

char c; // 声明 char 变量

c = 'A'; // 定义 char 变量

printf("c 的值为 %c", c);

return 0;

}

输出结果：

c 的值为 A

4、 C 语言实例 - 输出浮点数

使用 printf() 与 %f 输出浮点数。

实例

#include <stdio.h>

int main() {

float f; // 声明浮点数变量

f = 12.001234; // 定义浮点数变量

printf("f 的值为 %f", f);

return 0;

}

输出结果：

f 的值为 12.001234

5、 C 语言实例 - 输出双精度数

使用 printf() 与 %e 输出双精度数。

实例

#include <stdio.h>

int main() {

double d; // 声明双精度变量

d = 12.001234; // 定义双精度变量

printf("d 的值为 %le", d);

return 0;

}

输出结果：

d 的值为 1.200123e+01

6、 C 语言实例 - 两个数字相加

使用 scanf() 来接收输入， printf() 与 %d 格式化输出整数。

实例

#include <stdio.h>

int main()

{

int firstNumber, secondNumber, sumOfTwoNumbers;

printf("输入两个数(以空格分割): ");

// 通过 scanf() 函数接收用户输入的两个整数

scanf("%d %d", &firstNumber, &secondNumber);

// 两个数字相加

sumOfTwoNumbers = firstNumber + secondNumber;

// 输出结果

printf("%d + %d = %d", firstNumber, secondNumber, sumOfTwoNumbers);

return 0;

}

运行结果：

输入两个数(以空格分割): 1 2

1 + 2 = 3

7、 C 语言实例 - 两个浮点数相乘

实例

#include <stdio.h>

int main()

{

double firstNumber, secondNumber, product;

printf("输入两个浮点数: ");

// 用户输入两个浮点数

scanf("%lf %lf", &firstNumber, &secondNumber);

// 两个浮点数相乘

product = firstNumber * secondNumber;

// 输出结果， %.2lf 保留两个小数点

printf("结果 = %.2lf", product);

return 0;

}

运行结果：

输入两个浮点数: 1.2 2.345

结果 = 2.81

8、 C 语言实例 - 字符转 ASCII 码

ASCII 定义了 128 个字符。

分类：

一：0-31、127（删除键）是控制字符

二：空白字符：空格（32）、制表符、垂直制表符、换行、回车。

三：可显示字符：a-z、A-Z、0-9、~、！、@、、%、^、&、#、$、*、（、）、-、+、{、}、[、]、'、"、<、>、，、？、/、|、\、_、：、;、.，还有顿号、。

ASCII 表：

ASCII值 控制字符 ASCII值 控制字符 ASCII值 控制字符 ASCII值 控制字符

0 NUT 32 (space) 64 @ 96 、

1 SOH 33 ! 65 A 97 a

2 STX 34 " 66 B 98 b

3 ETX 35 # 67 C 99 c

4 EOT 36 $ 68 D 100 d

5 ENQ 37 % 69 E 101 e

6 ACK 38 & 70 F 102 f

7 BEL 39 ' 71 G 103 g

8 BS 40 ( 72 H 104 h

9 HT 41 ) 73 I 105 i

10 LF 42 * 74 J 106 j

11 VT 43 + 75 K 107 k

12 FF 44 , 76 L 108 l

13 CR 45 - 77 M 109 m

14 SO 46 . 78 N 110 n

15 SI 47 / 79 O 111 o

16 DLE 48 0 80 P 112 p

17 DCI 49 1 81 Q 113 q

18 DC2 50 2 82 R 114 r

19 DC3 51 3 83 S 115 s

20 DC4 52 4 84 T 116 t

21 NAK 53 5 85 U 117 u

22 SYN 54 6 86 V 118 v

23 TB 55 7 87 W 119 w

24 CAN 56 8 88 X 120 x

25 EM 57 9 89 Y 121 y

26 SUB 58 : 90 Z 122 z

27 ESC 59 ; 91 [ 123 {

28 FS 60 < 92 \ 124 |

29 GS 61 = 93 ] 125 }

30 RS 62 > 94 ^ 126 ～

31 US 63 ? 95 _ 127 DEL

实例

#include <stdio.h>

int main()

{

char c;

printf("输入一个字符: ");

// 读取用户输入

scanf("%c", &c);

// %d 显示整数

// %c 显示对应字符

printf("%c 的 ASCII 为 %d", c, c);

return 0;

}

运行结果：

输入一个字符: a

a 的 ASCII 为 97

9、 C 语言实例 - 两数相除

两数相除，如果有余数，输出余数。

实例

#include <stdio.h>

int main(){

int dividend, divisor, quotient, remainder;

printf("输入被除数: ");

scanf("%d", ÷nd);

printf("输入除数: ");

scanf("%d", &divisor);

// 计算商

quotient = dividend / divisor;

// 计算余数

remainder = dividend % divisor;

printf("商 = %d\n", quotient);

printf("余数 = %d", remainder);

return 0;

}

运行结果：

输入被除数: 5

输入除数: 2

商 = 2

余数 = 1

10、 C 语言实例 - 数值比较

比较两个数

以下实例中定义了两个整数变量，并使用 if 来比较两个数值，可以先看下逻辑图：

实例

#include <stdio.h>

int main() {

int a, b;

a = 11;

b = 99;

// 也可以通过以下代码实现让用户在终端输入两个数

// printf("输入第一个值:");

// scanf("%d", &a);

// printf("输入第二个值:");

// scanf("%d", &b);

if(a > b)

printf("a 大于 b");

else

printf("a 小于等于 b");

return 0;

}

输出结果：

a 小于等于 b

比较三个数

以下实例中定义了两个整数变量，并使用 if 来比较三个数值，可以先看下逻辑图：

实例

#include <stdio.h>

int main() {

int a, b, c;

a = 11;

b = 22;

c = 33;

if ( a > b && a > c )

printf("%d 最大", a);

else if ( b > a && b > c )

printf("%d 最大", b);

else if ( c > a && c > b )

printf("%d 最大", c);

else

printf("有两个或三个数值相等");

return 0;

}

输出结果：

33 最大

11、 C 语言实例 - 计算 int, float, double 和 char 字节大小

使用 sizeof 操作符计算int, float, double 和 char四种变量字节大小。

sizeof 是 C 语言的一种单目操作符，如C语言的其他操作符++、--等，它并不是函数。

sizeof 操作符以字节形式给出了其操作数的存储大小。

实例

#include <stdio.h>

int main()

{

int integerType;

float floatType;

double doubleType;

char charType;

// sizeof 操作符用于计算变量的字节大小

printf("Size of int: %ld bytes\n",sizeof(integerType));

printf("Size of float: %ld bytes\n",sizeof(floatType));

printf("Size of double: %ld bytes\n",sizeof(doubleType));

printf("Size of char: %ld byte\n",sizeof(charType));

return 0;

}

运行结果：

Size of int: 4 bytes

Size of float: 4 bytes

Size of double: 8 bytes

Size of char: 1 byte

计算 long long, long double 字节大小

实例

#include <stdio.h>

int main()

{

int a;

long b;

long long c;

double e;

long double f;

printf("Size of int = %ld bytes \n", sizeof(a));

printf("Size of long = %ld bytes\n", sizeof(b));

printf("Size of long long = %ld bytes\n", sizeof(c));

printf("Size of double = %ld bytes\n", sizeof(e));

printf("Size of long double = %ld bytes\n", sizeof(f));

return 0;

}

运行结果：

Size of int = 4 bytes

Size of long = 8 bytes

Size of long long = 8 bytes

Size of double = 8 bytes

Size of long double = 16 bytes

12、 C 语言实例 - 交换两个数的值

使用临时变量

以下实例演示了交换两个浮点数的值。

实例

#include <stdio.h>

int main()

{

double firstNumber, secondNumber, temporaryVariable;

printf("输入第一个数字: ");

scanf("%lf", &firstNumber);

printf("输入第二个数字: ");

scanf("%lf",&secondNumber);

// 将第一个数的值赋值给 temporaryVariable

temporaryVariable = firstNumber;

// 第二个数的值赋值给 firstNumber

firstNumber = secondNumber;

// 将 temporaryVariable 赋值给 secondNumber

secondNumber = temporaryVariable;

printf("\n交换后, firstNumber = %.2lf\n", firstNumber);

printf("交换后, secondNumber = %.2lf", secondNumber);

return 0;

}

运行结果：

输入第一个数字: 1

输入第二个数字: 2

交换后, firstNumber = 2.00

交换后, secondNumber = 1.00

不使用临时变量

不使用临时变量交换两个整数的值：

实例

#include <stdio.h>

int main() {

int a, b;

a = 11;

b = 99;

printf("交换之前 - \n a = %d, b = %d \n\n", a, b);

a = a + b; // ( 11 + 99 = 110) 此时 a 的变量为两数之和，b 未改变

b = a - b; // ( 110 - 99 = 11)

a = a - b; // ( 110 - 11 = 99)

printf("交换后 - \n a = %d, b = %d \n", a, b);

}

运行结果：

交换之前 -

a = 11, b = 99

交换后 -

a = 99, b = 11

13、 C 语言实例 - 判断奇数/偶数

以下实例判断用户输入的整数是奇数还是偶数。

实例

#include <stdio.h>

int main()

{

int number;

printf("请输入一个整数: ");

scanf("%d", &number);

// 判断这个数除以 2 的余数

if(number % 2 == 0)

printf("%d 是偶数。", number);

else

printf("%d 是奇数。", number);

return 0;

}

运行结果：

请输入一个整数: 5

5 是奇数。

14、 C 语言实例 - 循环区间范围内的奇数/偶数

循环输出区间范围内的奇数/偶数可以通过除于 2 的余数来判断。

以下实例通过循环输出指定区间范围的偶数。

实例

#include <stdio.h>

int main() {

int i;

for(i = 1; i <= 10; i++) {

if(i%2 == 0)

printf(" %2d\n", i);

}

return 0;

}

运行结果：

以下实例通过循环输出指定区间范围的奇数。

实例

#include <stdio.h>

int main() {

int i;

for(i = 1; i <= 10; i++) {

if(i%2 != 0)

printf("%d\n", i);

}

return 0;

}

运行结果：

15、 C 语言实例 - 判断元音/辅音

判断输入的字母是元音，还是辅音。

英语有26个字母，元音只包括 a、e、i、o、u 这五个字母，其余的都为辅音。y是半元音、半辅音字母，但在英语中都把他当作辅音。

实例

#include <stdio.h>

int main()

{

char c;

int isLowercaseVowel, isUppercaseVowel;

printf("输入一个字母: ");

scanf("%c",&c);

// 小写字母元音

isLowercaseVowel = (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u');

// 大写字母元音

isUppercaseVowel = (c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U');

// if 语句判断

if (isLowercaseVowel || isUppercaseVowel)

printf("%c 是元音", c);

else

printf("%c 是辅音", c);

return 0;

}

运行结果：

输入一个字母: G

G 是辅音

16、 C 语言实例 - 判断三个数中的最大数

通过屏幕我们输入三个数字，并找出最大的数。

实例

#include <stdio.h>

int main()

{

double n1, n2, n3;

printf("请输入三个数，以空格分隔: ");

scanf("%lf %lf %lf", &n1, &n2, &n3);

if( n1>=n2 && n1>=n3 )

printf("%.2f 是最大数。", n1);

if( n2>=n1 && n2>=n3 )

printf("%.2f 是最大数。", n2);

if( n3>=n1 && n3>=n2 )

printf("%.2f 是最大数。", n3);

return 0;

}

运行结果：

请输入三个数，以空格分隔: 1 2 3

3.00 是最大数。

17、 C 语言实例 - 一元二次方程

求一元二次方程：ax2+bx+c=0 的根。

输入三个实数a,b,c的值，且a不等于0。

实例

#include <stdio.h>

#include <math.h>

int main()

{

float a,b,c,x1,x2,d;

printf("输入方程的三个系数:");

scanf("%f %f %f",&a,&b,&c);

if(a!=0)

{

d=sqrt(b*b-4*a*c);

x1=(-b+d)/(2*a);

x2=(-b-d)/(2*a);

if(x1<x2)

printf("%0.2f %0.2f\n",x2,x1);

else

printf("%0.2f %0.2f\n",x1,x2);

}

return 0;

}

运行结果：

输入方程的三个系数:1 2 1

-1.00 -1.00

18、 C 语言实例 - 判断闰年

用户输入年份，判断该年份是否为闰年。

实例

#include <stdio.h>

int main()

{

int year;

printf("输入年份: ");

scanf("%d",&year);

if(year%4 == 0)

{

if( year%100 == 0)

{

// 这里如果被 400 整数是闰年

if ( year%400 == 0)

printf("%d 是闰年", year);

else

printf("%d 不是闰年", year);

}

else

printf("%d 是闰年", year );

}

else

printf("%d 不是闰年", year);

return 0;

}

运行结果：

输入年份: 1990

1990 不是闰

19、 C 语言实例 - 判断正数/负数/零

用户输入一个数字，判断该数字是正数还是负数或是零。

实例

#include <stdio.h>

int main()

{

double number;

printf("输入一个数字: ");

scanf("%lf", &number);

if (number <= 0.0)

{

if (number == 0.0)

printf("你输入的是 0。");

else

printf("你输入的是负数。");

}

else

printf("你输入的是正数。");

return 0;

}

运行结果：

输入一个数字: 9

你输入的是正数。

20、 C 语言实例 - 判断字母

用户输入一个字符，判断该字符是否为一个字母。

实例

#include <stdio.h>

int main()

{

char c;

printf("输入一个字符: ");

scanf("%c",&c);

if( (c>='a' && c<='z') || (c>='A' && c<='Z'))

printf("%c 是字母",c);

else

printf("%c 不是字母",c);

return 0;

}

运行结果：

输入一个字符: a

a 是字母

21、 C 语言实例 - 计算自然数的和

自然数是指表示物体个数的数，即由0开始，0，1，2，3，4，……一个接一个，组成一个无穷的集体，即指非负整数。

实例 - 使用 for

#include <stdio.h>

int main()

{

int n, i, sum = 0;

printf("输入一个正整数: ");

scanf("%d",&n);

for(i=1; i <= n; ++i)

{

sum += i; // sum = sum+i;

}

printf("Sum = %d",sum);

return 0;

}

实例 - 使用 while

#include <stdio.h>

int main()

{

int n, i, sum = 0;

printf("输入一个正整数: ");

scanf("%d",&n);

i = 1;

while ( i <=n )

{

sum += i;

++i;

}

printf("Sum = %d",sum);

return 0;

}

运行结果：

输入一个正整数: 100

Sum = 5050

实例 - 使用递归

#include <stdio.h>

int addNumbers(int n);

int main()

{

int num;

printf("输入一个整数: ");

scanf("%d", &num);

printf("Sum = %d",addNumbers(num));

return 0;

}

int addNumbers(int n)

{

if(n != 0)

return n + addNumbers(n-1);

else

return n;

}

22、 C 语言实例 - 输出九九乘法口诀表

使用嵌套 for 循环输出九九乘法口诀表。

实例

#include<stdio.h>

int main(){

//外层循环变量,控制行

int i = 0;

//内层循环变量,控制列

int j = 0;

for(i=1;i<=9;i++){

for(j=1;j<=i;j++){

printf("%dx%d=%d\t",j,i,i*j);

}

//每行输出完后换行

printf("\n");

}

运行结果：

1x1=1

1x2=2 2x2=4

1x3=3 2x3=6 3x3=9

1x4=4 2x4=8 3x4=12 4x4=16

1x5=5 2x5=10 3x5=15 4x5=20 5x5=25

1x6=6 2x6=12 3x6=18 4x6=24 5x6=30 6x6=36

1x7=7 2x7=14 3x7=21 4x7=28 5x7=35 6x7=42 7x7=49

1x8=8 2x8=16 3x8=24 4x8=32 5x8=40 6x8=48 7x8=56 8x8=64

1x9=9 2x9=18 3x9=27 4x9=36 5x9=45 6x9=54 7x9=63 8x9=72 9x9=81

23、 C 语言实例 - 斐波那契数列

斐波那契数列指的是这样一个数列 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368........

这个数列从第3项开始，每一项都等于前两项之和。

实例 - 输出指定数量的斐波那契数列

#include <stdio.h>

int main()

{

int i, n, t1 = 0, t2 = 1, nextTerm;

printf("输出几项: ");

scanf("%d", &n);

printf("斐波那契数列: ");

for (i = 1; i <= n; ++i)

{

printf("%d, ", t1);

nextTerm = t1 + t2;

t1 = t2;

t2 = nextTerm;

}

return 0;

}

运行结果：

输出几项: 10

斐波那契数列: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34,

实例 - 输出指定数字前的斐波那契数列

#include <stdio.h>

int main()

{

int t1 = 0, t2 = 1, nextTerm = 0, n;

printf("输入一个正数: ");

scanf("%d", &n);

// 显示前两项

printf("斐波那契数列: %d, %d, ", t1, t2);

nextTerm = t1 + t2;

while(nextTerm <= n)

{

printf("%d, ",nextTerm);

t1 = t2;

t2 = nextTerm;

nextTerm = t1 + t2;

}

return 0;

}

运行结果：

输入一个正数: 100

斐波那契数列: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89,

24、 C 语言实例 - 求两数的最大公约数

用户输入两个数，求这两个数的最大公约数。

实例 - 使用 for 和 if

#include <stdio.h>

int main()

{

int n1, n2, i, gcd;

printf("输入两个正整数，以空格分隔: ");

scanf("%d %d", &n1, &n2);

for(i=1; i <= n1 && i <= n2; ++i)

{

// 判断 i 是否为最大公约数

if(n1%i==0 && n2%i==0)

gcd = i;

}

printf("%d 和 %d 的最大公约数是 %d", n1, n2, gcd);

return 0;

}

运行结果：

输入两个正整数，以空格分隔: 81 153

81 和 153 的最大公约数是 9

实例 - 使用 while 和 if

#include <stdio.h>

int main()

{

int n1, n2;

printf("输入两个数，以空格分隔: ");

scanf("%d %d",&n1,&n2);

while(n1!=n2)

{

if(n1 > n2)

n1 -= n2;

else

n2 -= n1;

}

printf("GCD = %d",n1);

return 0;

}

运行结果：

输入两个数，以空格分隔: 81 153

GCD = 9

实例 - 适用正数和负数

#include <stdio.h>

int main()

{

int n1, n2;

printf("输入两个数，以空格分隔: ");

scanf("%d %d",&n1,&n2);

// 如果输入的是负数，将其转换为正数

n1 = ( n1 > 0) ? n1 : -n1;

n2 = ( n2 > 0) ? n2 : -n2;

while(n1!=n2)

{

if(n1 > n2)

n1 -= n2;

else

n2 -= n1;

}

printf("GCD = %d",n1);

return 0;

}

运行结果：

输入两个数，以空格分隔: 81 -153

GCD = 9

实例 - 使用递归

#include <stdio.h>

int hcf(int n1, int n2);

int main()

{

int n1, n2;

printf("输入两个正整数: ");

scanf("%d %d", &n1, &n2);

printf("%d 和 %d 的最大公约数为 %d", n1, n2, hcf(n1,n2));

return 0;

}

int hcf(int n1, int n2)

{

if (n2 != 0)

return hcf(n2, n1%n2);

else

return n1;

}

25、 C 语言实例 - 求两数最小公倍数

用户输入两个数，求这两个数的最小公倍数。

实例 - 使用 while 和 if

#include <stdio.h>

int main()

{

int n1, n2, minMultiple;

printf("输入两个正整数: ");

scanf("%d %d", &n1, &n2);

// 判断两数较大的值，并赋值给 minMultiple

minMultiple = (n1>n2) ? n1 : n2;

// 条件为 true

while(1)

{

if( minMultiple%n1==0 && minMultiple%n2==0 )

{

printf("%d 和 %d 的最小公倍数为 %d", n1, n2,minMultiple);

break;

}

++minMultiple;

}

return 0;

}

运行结果：

输入两个正整数: 72 120

72 和 120 的最小公倍数为 360

实例 - 通过最大公约数计算

#include <stdio.h>

int main()

{

int n1, n2, i, gcd, lcm;

printf("输入两个正整数: ");

scanf("%d %d",&n1,&n2);

for(i=1; i <= n1 && i <= n2; ++i)

{

// 判断最大公约数

if(n1%i==0 && n2%i==0)

gcd = i;

}

lcm = (n1*n2)/gcd;

printf("%d 和 %d 的最小公倍数为 %d", n1, n2, lcm);

return 0;

}

运行结果：

输入两个正整数: 72 120

72 和 120 的最小公倍数为 360

26、 C 语言实例 - 阶乘

一个正整数的阶乘（英语：factorial）是所有小于及等于该数的正整数的积，并且 0 的阶乘为 1。自然数 n 的阶乘写作 n!。

n!=1×2×3×...×n。阶乘亦可以递归方式定义：0!=1，1!=1，n!=(n-1)!×n。

实例

#include <stdio.h>

int main()

{

int n, i;

unsigned long long factorial = 1;

printf("输入一个整数: ");

scanf("%d",&n);

// 如果输入是负数，显示错误

if (n < 0)

printf("Error! 负数没有阶乘jiechen");

else

{

for(i=1; i<=n; ++i)

{

factorial *= i; // factorial = factorial*i;

}

printf("%d! = %llu", n, factorial);

}

return 0;

}

运行结果：

输入一个整数: 10

10! = 3628800

实例 - 使用递归

#include <stdio.h>

long int multiplyNumbers(int n);

int main()

{

int n;

printf("输入一个整数: ");

scanf("%d", &n);

printf("%d! = %ld", n, multiplyNumbers(n));

return 0;

}

long int multiplyNumbers(int n)

{

if (n > 1)

return n*multiplyNumbers(n-1);

else

return 1;

}

27、 C 语言实例 - 循环输出26个字母

循环输出 26 个字母。

实例

#include <stdio.h>

int main()

{

char c;

for(c = 'A'; c <= 'Z'; ++c)

printf("%c ", c);

return 0;

}

运行结果：

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

实例 - 输出大写或小写字母

#include <stdio.h>

int main()

{

char c;

printf("输入 u 显示大写字母，输入 l 显示小写字母: ");

scanf("%c", &c);

if(c== 'U' || c== 'u')

{

for(c = 'A'; c <= 'Z'; ++c)

printf("%c ", c);

}

else if (c == 'L' || c == 'l')

{

for(c = 'a'; c <= 'z'; ++c)

printf("%c ", c);

}

else

printf("Error! 输入非法字符。");

return 0;

}

运行结果：

输入 u 显示大写字母，输入 l 显示小写字母: l

a b c d e f g h i j k l m n o p q r s t u v w x y z

28、 C 语言实例 - 判断数字为几位数

用户输入数字，判断该数字是几位数。

实例

#include <stdio.h>

int main()

{

long long n;

int count = 0;

printf("输入一个整数: ");

scanf("%lld", &n);

while(n != 0)

{

// n = n/10

n /= 10;

++count;

}

printf("数字是 %d 位数。", count);

}

运行结果：

输入一个整数: 2345

数字是 4 位数。

29、 C 语言实例 - 计算一个数的 n 次方

计算一个数的 n 次方，例如: 23，其中 2 为基数，3 为指数。

实例 - 使用 while

#include <stdio.h>

int main()

{

int base, exponent;

long long result = 1;

printf("基数: ");

scanf("%d", &base);

printf("指数: ");

scanf("%d", &exponent);

while (exponent != 0)

{

result *= base;

--exponent;

}

printf("结果：%lld", result);

return 0;

}

运行结果：

基数: 2

指数: 3

结果：8

实例 - 使用 pow() 函数

#include <stdio.h>

#include <math.h>

int main()

{

double base, exponent, result;

printf("基数: ");

scanf("%lf", &base);

printf("指数: ");

scanf("%lf", &exponent);

// 计算结果

result = pow(base, exponent);

printf("%.1lf^%.1lf = %.2lf", base, exponent, result);

return 0;

}

运行结果：

基数: 2

指数: 3

2.0^3.0 = 8.00

实例 - 递归

#include <stdio.h>

int power(int n1, int n2);

int main()

{

int base, powerRaised, result;

printf("基数: ");

scanf("%d",&base);

printf("指数(正整数): ");

scanf("%d",&powerRaised);

result = power(base, powerRaised);

printf("%d^%d = %d", base, powerRaised, result);

return 0;

}

int power(int base, int powerRaised)

{

if (powerRaised != 0)

return (base*power(base, powerRaised-1));

else

return 1;

}

30、 C 语言实例 - 判断回文数

判断一个数是否为回文数。

设n是一任意自然数。若将n的各位数字反向排列所得自然数n1与n相等，则称n为一回文数。例如，若n=1234321，则称n为一回文数；但若n=1234567，则n不是回文数

实例

#include <stdio.h>

int main()

{

int n, reversedInteger = 0, remainder, originalInteger;

printf("输入一个整数: ");

scanf("%d", &n);

originalInteger = n;

// 翻转

while( n!=0 )

{

remainder = n%10;

reversedInteger = reversedInteger*10 + remainder;

n /= 10;

}

// 判断

if (originalInteger == reversedInteger)

printf("%d 是回文数。", originalInteger);

else

printf("%d 不是回文数。", originalInteger);

return 0;

}

运行结果：

输入一个整数: 12321

12321 是回文数

31、 C 语言实例 - 判断素数

质数（prime number）又称素数，有无限个。质数定义为在大于1的自然数中，除了1和它本身以外不再有其他因数，这样的数称为质数。

实例

#include <stdio.h>

int main()

{

int n, i, flag = 0;

printf("输入一个正整数: ");

scanf("%d",&n);

for(i=2; i<=n/2; ++i)

{

// 符合该条件不是素数

if(n%i==0)

{

flag=1;

break;

}

if (flag==0)

printf("%d 是素数",n);

else

printf("%d 不是素数",n);

return 0;

}

运行结果：

输入一个正整数: 29

29 是素数

实例 - 判断两个数之间的素数

#include <stdio.h>

int main()

{

int low, high, i, flag;

printf("输入两个整数: ");

scanf("%d %d", &low, &high);

printf("%d 与 %d 之间的素数为: ", low, high);

while (low < high)

{

flag = 0;

for(i = 2; i <= low/2; ++i)

{

if(low % i == 0)

{

flag = 1;

break;

}

if (flag == 0)

printf("%d ", low);

++low;

}

return 0;

}

运行结果：

输入两个整数: 100 200

100 与 200 之间的素数为: 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199

实例 - 使用函数判断两数间的素数

#include <stdio.h>

int checkPrimeNumber(int n);

int main()

{

int n1, n2, i, flag;

printf("输入两个正整数: ");

scanf("%d %d", &n1, &n2);

printf("%d 和 %d 间的素数为: ", n1, n2);

for(i=n1+1; i<n2; ++i)

{

// 判断是否为素数

flag = checkPrimeNumber(i);

if(flag == 1)

printf("%d ",i);

}

return 0;

}

// 函数定义

int checkPrimeNumber(int n)

{

int j, flag = 1;

for(j=2; j <= n/2; ++j)

{

if (n%j == 0)

{

flag =0;

break;

}

return flag;

}

输出结果为：

输入两个正整数: 10 30

10 和 30 间的素数为: 11 13 17 19 23 29

32、 C 语言实例 - 判断Armstrong数(阿姆斯壮数)

Armstrong 数，就是n位数的各位数的n次方之和等于该数，如：

153=1^3+5^3+3^3

1634=1^4+6^4+3^4+4^4

实例

#include <stdio.h>

int main()

{

int number, originalNumber, remainder, result = 0;

printf("输入三位数: ");

scanf("%d", &number);

originalNumber = number;

while (originalNumber != 0)

{

remainder = originalNumber%10;

result += remainder*remainder*remainder;

originalNumber /= 10;

}

if(result == number)

printf("%d 是 Armstrong 数",number);

else

printf("%d 不是 Armstrong 数",number);

return 0;

}

运行结果：

输入三位数: 371

371 是 Armstrong

实例 - 两数之间的 Armstrong 数

#include <stdio.h>

#include <math.h>

int main()

{

int low, high, i, temp1, temp2, remainder, n = 0, result = 0;

printf("输入两个整数: ");

scanf("%d %d", &low, &high);

printf("%d 和 %d 之间的 Armstrong 数为: ", low, high);

for(i = low + 1; i < high; ++i)

{

temp2 = i;

temp1 = i;

// 计算

while (temp1 != 0)

{

temp1 /= 10;

++n;

}

while (temp2 != 0)

{

remainder = temp2 % 10;

result += pow(remainder, n);

temp2 /= 10;

}

if (result == i) {

printf("%d ", i);

}

n = 0;

result = 0;

}

return 0;

}

运行结果：

输入两个整数: 100 1000

100 和 1000 之间的 Armstrong 数为: 153 370 371 407

实例 - 使用函数判断Armstrong 数

#include <stdio.h>

#include <math.h>

int checkPrimeNumber(int n);

int checkArmstrongNumber(int n);

int main()

{

int n, flag;

printf("输入正整数: ");

scanf("%d", &n);

// 检测素数

flag = checkPrimeNumber(n);

if (flag == 1)

printf("%d 是素数。\n", n);

else

printf("%d 不是素数\n", n);

// 检测 Armstrong 数

flag = checkArmstrongNumber(n);

if (flag == 1)

printf("%d 是 Armstrong 数。", n);

else

printf("%d 不是 Armstrong 数。",n);

return 0;

}

int checkPrimeNumber(int n)

{

int i, flag = 1;

for(i=2; i<=n/2; ++i)

{

// 非素数条件

if(n%i == 0)

{

flag = 0;

break;

}

return flag;

}

int checkArmstrongNumber(int number)

{

int originalNumber, remainder, result = 0, n = 0, flag;

originalNumber = number;

while (originalNumber != 0)

{

originalNumber /= 10;

++n;

}

originalNumber = number;

while (originalNumber != 0)

{

remainder = originalNumber%10;

result += pow(remainder, n);

originalNumber /= 10;

}

// 判断条件

if(result == number)

flag = 1;

else

flag = 0;

return flag;

}

输出结果为：

输入正整数: 371

371 不是素数

371 是 Armstrong 数。

33、 C 语言实例 – 求一个整数的所有因数

假如a*b=c（a、b、c都是整数)，那么我们称a和b就是c的因数。

实例

#include <stdio.h>

int main()

{

int number, i;

printf("输入一个整数: ");

scanf("%d",&number);

printf("%d 的因数有: ", number);

for(i=1; i <= number; ++i)

{

if (number%i == 0)

{

printf("%d ",i);

}

return 0;

}

运行结果：

输入一个整数: 60

60 的因数有: 1 2 3 4 5 6 10 12 15 20 30 60

34、 C 语言实例 - 创建各类三角形图案

创建三角形图案。

实例 - 使用 * 号

#include <stdio.h>

int main()

{

int i, j, rows;

printf("行数: ");

scanf("%d",&rows);

for(i=1; i<=rows; ++i)

{

for(j=1; j<=i; ++j)

{

printf("* ");

}

printf("\n");

}

return 0;

}

* *

* * *

* * * *

* * * * *

实例 - 使用数字

#include <stdio.h>

int main()

{

int i, j, rows;

printf("行数: ");

scanf("%d",&rows);

for(i=1; i<=rows; ++i)

{

for(j=1; j<=i; ++j)

{

printf("%d ",j);

}

printf("\n");

}

return 0;

}

1 2

1 2 3

1 2 3 4

1 2 3 4 5

实例 - 使用字母

#include <stdio.h>

int main()

{

int i, j;

char input, alphabet = 'A';

printf("输入大写字母: ");

scanf("%c",&input);

for(i=1; i <= (input-'A'+1); ++i)

{

for(j=1;j<=i;++j)

{

printf("%c", alphabet);

}

++alphabet;

printf("\n");

}

return 0;

}

B B

C C C

D D D D

E E E E E

实例 - 倒三角形

#include <stdio.h>

int main()

{

int i, j, rows;

printf("行数: ");

scanf("%d",&rows);

for(i=rows; i>=1; --i)

{

for(j=1; j<=i; ++j)

{

printf("* ");

}

printf("\n");

}

return 0;

}

* * * * *

* * * *

* * *

* *

实例 - 倒三角形数字

#include <stdio.h>

int main()

{

int i, j, rows;

printf("行数: ");

scanf("%d",&rows);

for(i=rows; i>=1; --i)

{

for(j=1; j<=i; ++j)

{

printf("%d ",j);

}

printf("\n");

}

return 0;

}

1 2 3 4 5

1 2 3 4

1 2 3

1 2

实例 - 金字塔

#include <stdio.h>

int main()

{

int i, space, rows, k=0;

printf("Enter number of rows: ");

scanf("%d",&rows);

for(i=1; i<=rows; ++i, k=0)

{

for(space=1; space<=rows-i; ++space)

{

printf(" ");

}

while(k != 2*i-1)

{

printf("* ");

++k;

}

printf("\n");

}

return 0;

}

* * *

* * * * *

* * * * * * *

* * * * * * * * *

实例 - 数字金字塔

#include <stdio.h>

int main()

{

int i, space, rows, k=0, count = 0, count1 = 0;

printf("行数: ");

scanf("%d",&rows);

for(i=1; i<=rows; ++i)

{

for(space=1; space <= rows-i; ++space)

{

printf(" ");

++count;

}

while(k != 2*i-1)

{

if (count <= rows-1)

{

printf("%d ", i+k);

++count;

}

else

{

++count1;

printf("%d ", (i+k-2*count1));

}

++k;

}

count1 = count = k = 0;

printf("\n");

}

return 0;

}

2 3 2

3 4 5 4 3

4 5 6 7 6 5 4

5 6 7 8 9 8 7 6 5

实例 - 倒金字塔

#include<stdio.h>

int main()

{

int rows, i, j, space;

printf("行数: ");

scanf("%d",&rows);

for(i=rows; i>=1; --i)

{

for(space=0; space < rows-i; ++space)

printf(" ");

for(j=i; j <= 2*i-1; ++j)

printf("* ");

for(j=0; j < i-1; ++j)

printf("* ");

printf("\n");

}

return 0;

}

* * * * * * * * *

* * * * * * *

* * * * *

* * *

实例 - 杨辉三角

#include <stdio.h>

int main()

{

int rows, coef = 1, space, i, j;

printf("行数: ");

scanf("%d",&rows);

for(i=0; i<rows; i++)

{

for(space=1; space <= rows-i; space++)

printf(" ");

for(j=0; j <= i; j++)

{

if (j==0 || i==0)

coef = 1;

else

coef = coef*(i-j+1)/j;

printf("%4d", coef);

}

printf("\n");

}

return 0;

}

1 1

1 2 1

1 3 3 1

1 4 6 4 1

1 5 10 10 5 1

实例 - 弗洛伊德三角形

#include <stdio.h>

#define N 10

int main()

{

int i,j,l;

for(i=1,j=1;i<=N;i++)

{

for(l=1;l<=i;l++,j++)

printf("%5d",j);

printf("\n");

}

return 0;

}

2 3

4 5 6

7 8 9 10

11 12 13 14 15

16 17 18 19 20 21

22 23 24 25 26 27 28

29 30 31 32 33 34 35 36

37 38 39 40 41 42 43 44 45

46 47 48 49 50 51 52 53 54 55

35、 C 语言实例 - 表格形式输出数据

将 1~100 的数据以 10x10 矩阵格式输出。

实例

#include <stdio.h>

int main() {

int i, j, count;

for(i = 1; i <= 10; i++) {

for(j = i; j <=100; j += 10 )

printf(" %3d", j);

printf("\n");

}

return 0;

}

运行结果：

1 11 21 31 41 51 61 71 81 91

2 12 22 32 42 52 62 72 82 92

3 13 23 33 43 53 63 73 83 93

4 14 24 34 44 54 64 74 84 94

5 15 25 35 45 55 65 75 85 95

6 16 26 36 46 56 66 76 86 96

7 17 27 37 47 57 67 77 87 97

8 18 28 38 48 58 68 78 88 98

9 19 29 39 49 59 69 79 89 99

10 20 30 40 50 60 70 80 90 100

等差数列输出 10x10 矩阵格式。

实例

#include <stdio.h>

int main() {

int i, j, count;

int start, end;

start = 2, end = 10;

for(i = start; i <= end; i++) {

count = i;

for(j = 1; j <= 10; j++) {

printf(" %3d", count*j);

}

printf("\n");

}

return 0;

}

运行结果：

2 4 6 8 10 12 14 16 18 20

3 6 9 12 15 18 21 24 27 30

4 8 12 16 20 24 28 32 36 40

5 10 15 20 25 30 35 40 45 50

6 12 18 24 30 36 42 48 54 60

7 14 21 28 35 42 49 56 63 70

8 16 24 32 40 48 56 64 72 80

9 18 27 36 45 54 63 72 81 90

10 20 30 40 50 60 70 80 90 100

乘法运算格式。

实例

#include <stdio.h>

int main() {

int i, j, n;

n = 3;

j = 1;

for(i = n; i <= (n*10); i+=n) {

printf("%3d x %2d = %3d\n", n, j, i);

j++;

}

return 0;

}

运行结果：

3 x 1 = 3

3 x 2 = 6

3 x 3 = 9

3 x 4 = 12

3 x 5 = 15

3 x 6 = 18

3 x 7 = 21

3 x 8 = 24

3 x 9 = 27

3 x 10 = 30

36、 C 语言实例 - 实现简单的计算器

实现加减乘除计算。

实例

# include <stdio.h>

int main() {

char operator;

double firstNumber,secondNumber;

printf("输入操作符 (+, -, *, /): ");

scanf("%c", &operator);

printf("输入两个数字: ");

scanf("%lf %lf",&firstNumber, &secondNumber);

switch(operator)

{

case '+':

printf("%.1lf + %.1lf = %.1lf",firstNumber, secondNumber, firstNumber + secondNumber);

break;

case '-':

printf("%.1lf - %.1lf = %.1lf",firstNumber, secondNumber, firstNumber - secondNumber);

break;

case '*':

printf("%.1lf * %.1lf = %.1lf",firstNumber, secondNumber, firstNumber * secondNumber);

break;

case '/':

printf("%.1lf / %.1lf = %.1lf",firstNumber, secondNumber, firstNumber / secondNumber);

break;

// operator doesn't match any case constant (+, -, *, /)

default:

printf("Error! operator is not correct");

}

return 0;

}

输出结果为：

输入操作符 (+, -, *, /): *

输入两个数字: 4 5

4.0 * 5.0 = 20.0

37、 C 语言实例 - 计算一个数是否可为两个素数之和

计算一个数为两个素数之和。

实例

#include <stdio.h>

int checkPrime(int n);

int main()

{

int n, i, flag = 0;

printf("输入正整数: ");

scanf("%d", &n);

for(i = 2; i <= n/2; ++i)

{

// 检测判断

if (checkPrime(i) == 1)

{

if (checkPrime(n-i) == 1)

{

printf("%d = %d + %d\n", n, i, n - i);

flag = 1;

}

if (flag == 0)

printf("%d 不能分解为两个素数。", n);

return 0;

}

// 判断素数

int checkPrime(int n)

{

int i, isPrime = 1;

for(i = 2; i <= n/2; ++i)

{

if(n % i == 0)

{

isPrime = 0;

break;

}

return isPrime;

}

输出结果为：

输入正整数: 34

34 = 3 + 31

34 = 5 + 29

34 = 11 + 23

34 = 17 + 17

38、 C 语言实例 - 二进制与十进制相互转换

二进制转与十进制相互转换。

实例 - 二进制转换为十进制

#include <stdio.h>

#include <math.h>

int convertBinaryToDecimal(long long n);

int main()

{

long long n;

printf("输入一个二进制数: ");

scanf("%lld", &n);

printf("二进制数 %lld 转换为十进制为 %d", n, convertBinaryToDecimal(n));

return 0;

}

int convertBinaryToDecimal(long long n)

{

int decimalNumber = 0, i = 0, remainder;

while (n!=0)

{

remainder = n%10;

n /= 10;

decimalNumber += remainder*pow(2,i);

++i;

}

return decimalNumber;

}

输出结果为：

输入一个二进制数: 110110111

二进制数 110110111 转换为十进制为 439

实例 - 十进制转换为二进制

#include <stdio.h>

#include <math.h>

long long convertDecimalToBinary(int n);

int main()

{

int n;

printf("输入一个十进制数: ");

scanf("%d", &n);

printf("十进制数 %d 转换为二进制位 %lld", n, convertDecimalToBinary(n));

return 0;

}

long long convertDecimalToBinary(int n)

{

long long binaryNumber = 0;

int remainder, i = 1, step = 1;

while (n!=0)

{

remainder = n%2;

printf("Step %d: %d/2, 余数 = %d, 商 = %d\n", step++, n, remainder, n/2);

n /= 2;

binaryNumber += remainder*i;

i *= 10;

}

return binaryNumber;

}

输出结果为：

输入一个十进制数: 100

Step 1: 100/2, 余数 = 0, 商 = 50

Step 2: 50/2, 余数 = 0, 商 = 25

Step 3: 25/2, 余数 = 1, 商 = 12

Step 4: 12/2, 余数 = 0, 商 = 6

Step 5: 6/2, 余数 = 0, 商 = 3

Step 6: 3/2, 余数 = 1, 商 = 1

Step 7: 1/2, 余数 = 1, 商 = 0

十进制数 100 转换为二进制位 1100100

39、 C 语言实例 - 八进制与十进制相互转换

八进制与十进制相互转换。

实例 - 十进制转换为八进制

#include <stdio.h>

#include <math.h>

int convertDecimalToOctal(int decimalNumber);

int main()

{

int decimalNumber;

printf("输入一个十进制数: ");

scanf("%d", &decimalNumber);

printf("十进制数 %d 转换为八进制为 %d", decimalNumber, convertDecimalToOctal(decimalNumber));

return 0;

}

int convertDecimalToOctal(int decimalNumber)

{

int octalNumber = 0, i = 1;

while (decimalNumber != 0)

{

octalNumber += (decimalNumber % 8) * i;

decimalNumber /= 8;

i *= 10;

}

return octalNumber;

}

输出结果为：

输入一个十进制数: 78

十进制数 78 转换为八进制为 116

实例 - 八进制转换为十进制

#include <stdio.h>

#include <math.h>

long long convertOctalToDecimal(int octalNumber);

int main()

{

int octalNumber;

printf("输入一个八进制数: ");

scanf("%d", &octalNumber);

printf("八进制数 %d 转换为十进制为 %lld", octalNumber, convertOctalToDecimal(octalNumber));

return 0;

}

long long convertOctalToDecimal(int octalNumber)

{

int decimalNumber = 0, i = 0;

while(octalNumber != 0)

{

decimalNumber += (octalNumber%10) * pow(8,i);

++i;

octalNumber/=10;

}

i = 1;

return decimalNumber;

}

输出结果为：

输入一个八进制数: 116

八进制数 116 转换为十进制为 78

40、 C 语言实例 - 八进制与二进制相互转换

八进制与二进制相互转换。

实例 - 二进制转换为八进制

#include <stdio.h>

#include <math.h>

int convertBinarytoOctal(long long binaryNumber);

int main()

{

long long binaryNumber;

printf("输入一个二进制数: ");

scanf("%lld", &binaryNumber);

printf("二进制数 %lld 转换为八进制为 %d", binaryNumber, convertBinarytoOctal(binaryNumber));

return 0;

}

int convertBinarytoOctal(long long binaryNumber)

{

int octalNumber = 0, decimalNumber = 0, i = 0;

while(binaryNumber != 0)

{

decimalNumber += (binaryNumber%10) * pow(2,i);

++i;

binaryNumber/=10;

}

i = 1;

while (decimalNumber != 0)

{

octalNumber += (decimalNumber % 8) * i;

decimalNumber /= 8;

i *= 10;

}

return octalNumber;

}

输出结果为：

输入一个二进制数: 101001

二进制数 101001 转换为八进制为 51

实例 - 八进制转换为二进制

#include <stdio.h>

#include <math.h>

long long convertOctalToBinary(int octalNumber);

int main()

{

int octalNumber;

printf("输入一个八进制数: ");

scanf("%d", &octalNumber);

printf("八进制数 %d 转二进制为 %lld", octalNumber, convertOctalToBinary(octalNumber));

return 0;

}

long long convertOctalToBinary(int octalNumber)

{

int decimalNumber = 0, i = 0;

long long binaryNumber = 0;

while(octalNumber != 0)

{

decimalNumber += (octalNumber%10) * pow(8,i);

++i;

octalNumber/=10;

}

i = 1;

while (decimalNumber != 0)

{

binaryNumber += (decimalNumber % 2) * i;

decimalNumber /= 2;

i *= 10;

}

return binaryNumber;

}

输出结果为：

输入一个八进制数: 51

八进制数 51 转二进制为 101001

41、 C 语言实例 - 字符串翻转

使用递归来翻转字符串。

实例 - 字符串翻转

#include <stdio.h>

void reverseSentence();

int main()

{

printf("输入一个字符串: ");

reverseSentence();

return 0;

}

void reverseSentence()

{

char c;

scanf("%c", &c);

if( c != '\n')

{

reverseSentence();

printf("%c",c);

}

输出结果为：

输入一个字符串: runoob

boonur

42、 C 语言实例 - 计算数组元素平均值

使用 for 循环迭代出输出元素，并将各个元素相加算出总和，再除于元素个数：

实例 1

#include <stdio.h>

int main() {

int array[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};

int sum, loop;

float avg;

sum = avg = 0;

for(loop = 0; loop < 10; loop++) {

sum = sum + array[loop];

}

avg = (float)sum / loop;

printf("平均值为 %.2f", avg);

return 0;

}

输出结果为：

平均值为 4.50

用户自定义输入：

实例 2

#include <stdio.h>

int main()

{

int n, i;

float num[100], sum = 0.0, average;

printf("输入元素个数: ");

scanf("%d", &n);

while (n > 100 || n <= 0)

{

printf("Error! 数字需要在1 到 100 之间。\n");

printf("再次输入: ");

scanf("%d", &n);

}

for(i = 0; i < n; ++i)

{

printf("%d. 输入数字: ", i+1);

scanf("%f", &num[i]);

sum += num[i];

}

average = sum / n;

printf("平均值 = %.2f", average);

return 0;

}

输出结果为：

输入元素个数: 4

1. 输入数字: 1

2. 输入数字: 2

3. 输入数字: 4

4. 输入数字: 8

平均值 = 3.75

43、 C 语言实例 - 输出数组

使用 for 循环输出数组：

实例

#include <stdio.h>

int main() {

int array[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};

int loop;

for(loop = 0; loop < 10; loop++)

printf("%d ", array[loop]);

return 0;

}

输出结果为：

1 2 3 4 5 6 7 8 9 0

使用 for 循环逆向输出数组：

实例

#include <stdio.h>

int main() {

int array[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};

int loop;

for(loop = 9; loop >= 0; loop--)

printf("%d ", array[loop]);

return 0;

}

输出结果为：

0 9 8 7 6 5 4 3 2 1

44、 C 语言实例 - 计算数组元素之和

使用 for 循环迭代出输出元素，并将各个元素相加：

实例

#include <stdio.h>

int main() {

int array[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};

int sum, loop;

sum = 0;

for(loop = 9; loop >= 0; loop--) {

sum = sum + array[loop];

}

printf("元素和为：%d", sum);

return 0;

}

输出结果为：

元素和为：45

45、 C 语言实例 - 查找数组中最大的元素值

查找数组中最大的元素值。

实例 1

#include <stdio.h>

int main() {

int array[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};

int loop, largest;

largest = array[0];

for(loop = 1; loop < 10; loop++) {

if( largest < array[loop] )

largest = array[loop];

}

printf("最大元素为 %d", largest);

return 0;

}

输出结果为：

最大元素为 9

用户自定义输出：

实例 2

#include <stdio.h>

int main()

{

int i, n;

float arr[100];

printf("输入元素个数（0~100）: ");

scanf("%d", &n);

printf("\n");

// 接收用户输入

for(i = 0; i < n; ++i)

{

printf("输入数字 %d: ", i+1);

scanf("%f", &arr[i]);

}

// 循环，并将最大元素存储到 arr[0]

for(i = 1; i < n; ++i)

{

// 如果要查找最小值可以将 < 换成 >

if(arr[0] < arr[i])

arr[0] = arr[i];

}

printf("最大元素为 = %.2f", arr[0]);

return 0;

}

输出结果为：

输入元素个数（0~100）: 4

输入数字 1: 12

输入数字 2: 23

输入数字 3: 1

输入数字 4: 3

最大元素为 = 23.00

46、 C 语言实例 - 查找数组中最小的元素

使用 for 循环迭代出输出元素，从第一元素开始逐个比较，获取最小的元素：

实例

#include <stdio.h>

int main() {

int array[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};

int loop, smallest;

smallest = array[0];

for(loop = 1; loop < 10; loop++) {

if( smallest > array[loop] )

smallest = array[loop];

}

printf("最小元素为 %d", smallest);

return 0;

}

输出结果为：

最小元素为 0

47、 C 语言实例 - 数组拆分与合并

将一个数组拆分为两个数组，一个为奇数数组，一个为偶数数组：

实例

#include <stdio.h>

int main() {

int array[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

int even[10], odd[10];

int loop, e, d;

e = d = 0;

for(loop = 0; loop < 10; loop++) {

if(array[loop]%2 == 0) {

even[e] = array[loop];

e++;

}else {

odd[d] = array[loop];

d++;

}

printf(" 原始数组 -> ");

for(loop = 0; loop < 10; loop++)

printf(" %d", array[loop]);

printf("\n 偶数 -> ");

for(loop = 0; loop < e; loop++)

printf(" %d", even[loop]);

printf("\n 奇数 -> ");

for(loop = 0; loop < d; loop++)

printf(" %d", odd[loop]);

return 0;

}

输出结果为：

原始数组 -> 0 1 2 3 4 5 6 7 8 9

偶数 -> 0 2 4 6 8

奇数 -> 1 3 5 7 9

将奇数数组与偶数数组合并为一个数组：

实例

#include <stdio.h>

int main() {

int array[10];

int even[5] = {0, 2, 4, 6, 8};

int odd[5] = {1, 3, 5, 7, 9};

int loop, index, e_len, o_len;

e_len = o_len = 5;

index = 0;

for(loop = 0; loop < e_len; loop++) {

array[index] = even[loop];

index++;

}

for(loop = 0; loop < o_len; loop++) {

array[index] = odd[loop];

index++;

}

printf("\n偶数 -> ");

for(loop = 0; loop < e_len; loop++)

printf(" %d", even[loop]);

printf("\n奇数 -> ");

for(loop = 0; loop < o_len; loop++)

printf(" %d", odd[loop]);

printf("\n合并后 -> ");

for(loop = 0; loop < 10; loop++)

printf(" %d", array[loop]);

return 0;

}

输出结果为：

偶数 -> 0 2 4 6 8

奇数 -> 1 3 5 7 9

合并后 -> 0 2 4 6 8 1 3 5 7 9

48、 C 语言实例 - 数组拷贝

将一个数组复制给另外一个数组：

实例

#include <stdio.h>

int main() {

int original[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};

int copied[10];

int loop;

for(loop = 0; loop < 10; loop++) {

copied[loop] = original[loop];

}

printf("元素数组 -> 拷贝后的数组 \n");

for(loop = 0; loop < 10; loop++) {

printf(" %2d %2d\n", original[loop], copied[loop]);

}

return 0;

}

输出结果为：

元素数组 -> 拷贝后的数组

1 1

2 2

3 3

4 4

5 5

6 6

7 7

8 8

9 9

0 0

49、 C 语言实例 - 计算标准偏差

计算标准偏差。

实例

#include <stdio.h>

#include <math.h>

float calculateSD(float data[]);

int main()

{

int i;

float data[10];

printf("输入10个元素: ");

for(i=0; i < 10; ++i)

scanf("%f", &data[i]);

printf("\n标准偏差 = %.6f", calculateSD(data));

return 0;

}

float calculateSD(float data[])

{

float sum = 0.0, mean, standardDeviation = 0.0;

int i;

for(i=0; i<10; ++i)

{

sum += data[i];

}

mean = sum/10;

for(i=0; i<10; ++i)

standardDeviation += pow(data[i] - mean, 2);

return sqrt(standardDeviation/10);

}

输出结果为：

输入10个元素: 1

标准偏差 = 2.872281

50、 C 语言实例 - 两个矩阵相加

使用多维数组将两个矩阵相加。

实例

#include <stdio.h>

int main(){

int r, c, a[100][100], b[100][100], sum[100][100], i, j;

printf("输入行数 ( 1 ~ 100): ");

scanf("%d", &r);

printf("输入列数 ( 1 ~ 100): ");

scanf("%d", &c);

printf("\n输入第一维数组的元素:\n");

for(i=0; i<r; ++i)

for(j=0; j<c; ++j)

{

printf("输入元素 a%d%d: ",i+1,j+1);

scanf("%d",&a[i][j]);

}

printf("输入第二维数组的元素:\n");

for(i=0; i<r; ++i)

for(j=0; j<c; ++j)

{

printf("输入元素 a%d%d: ",i+1, j+1);

scanf("%d", &b[i][j]);

}

// 相加

for(i=0;i<r;++i)

for(j=0;j<c;++j)

{

sum[i][j]=a[i][j]+b[i][j];

}

// 显示结果

printf("\n二维数组相加结果: \n\n");

for(i=0;i<r;++i)

for(j=0;j<c;++j)

{

printf("%d ",sum[i][j]);

if(j==c-1)

{

printf("\n\n");

}

return 0;

}

输出结果为：

输入行数 ( 1 ~ 100): 2

输入列数 ( 1 ~ 100): 3

输入第一维数组的元素:

输入元素 a11: 2

输入元素 a12: 3

输入元素 a13: 4

输入元素 a21: 5

输入元素 a22: 2

输入元素 a23: 3

输入第二维数组的元素:

输入元素 a11: -4

输入元素 a12: 5

输入元素 a13: 3

输入元素 a21: 5

输入元素 a22: 6

输入元素 a23: 3

二维数组相加结果:

-2 8 7

10 8 6

51、 C 语言实例 – 矩阵转换

矩阵转换。

实例

#include <stdio.h>

int main()

{

int a[10][10], transpose[10][10], r, c, i, j;

printf("输入矩阵的行与列: ");

scanf("%d %d", &r, &c);

// 存储矩阵的元素

printf("\n输入矩阵元素:\n");

for(i=0; i<r; ++i)

for(j=0; j<c; ++j)

{

printf("输入元素 a%d%d: ",i+1, j+1);

scanf("%d", &a[i][j]);

}

// 显示矩阵 a[][] */

printf("\n输入矩阵: \n");

for(i=0; i<r; ++i)

for(j=0; j<c; ++j)

{

printf("%d ", a[i][j]);

if (j == c-1)

printf("\n\n");

}

// 转换

for(i=0; i<r; ++i)

for(j=0; j<c; ++j)

{

transpose[j][i] = a[i][j];

}

// 显示转换后的矩阵 a

printf("\n转换后矩阵:\n");

for(i=0; i<c; ++i)

for(j=0; j<r; ++j)

{

printf("%d ",transpose[i][j]);

if(j==r-1)

printf("\n\n");

}

return 0;

}

输出结果为：

输入矩阵的行与列: 2 3

输入矩阵元素:

输入元素 a11: 2

输入元素 a12: 3

输入元素 a13: 4

输入元素 a21: 5

输入元素 a22: 6

输入元素 a23: 4

输入矩阵:

2 3 4

5 6 4

转换后矩阵:

2 5

3 6

4 4

52、 C 语言实例 - 使用指针访问数组元素

使用指针访问数组元素。

实例

#include <stdio.h>

int main()

{

int data[5], i;

printf("输入元素: ");

for(i = 0; i < 5; ++i)

scanf("%d", data + i);

printf("你输入的是: \n");

for(i = 0; i < 5; ++i)

printf("%d\n", *(data + i));

return 0;

}

输出结果为：

输入元素: 1

你输入的是:

53、 C 语言实例 - 使用引用循环替换数值

a、b、c 三个变量，通过引用按顺序循环替换他们的值。

实例

#include<stdio.h>

void cyclicSwap(int *a,int *b,int *c);

int main()

{

int a, b, c;

printf("输入 a, b 和 c 的值: ");

scanf("%d %d %d",&a,&b,&c);

printf("交换前:\n");

printf("a = %d \nb = %d \nc = %d\n",a,b,c);

cyclicSwap(&a, &b, &c);

printf("交换后:\n");

printf("a = %d \nb = %d \nc = %d",a, b, c);

return 0;

}

void cyclicSwap(int *a,int *b,int *c)

{

int temp;

// 交换

temp = *b;

*b = *a;

*a = *c;

*c = temp;

}

输出结果为：

输入 a, b 和 c 的值: 1 2 3

交换前:

a = 1

b = 2

c = 3

交换后:

a = 3

b = 1

c = 2

54、 C 语言实例 - 判断最大值

通过用户输入指定的数值，来判断最大值。

实例 - 判断最大值

#include <stdio.h>

#include <stdlib.h>

int main()

{

int i, num;

float *data;

printf("输入元素个数(1 ~ 100): ");

scanf("%d", &num);

// 为 'num' 元素分配内存

data = (float*) calloc(num, sizeof(float));

if(data == NULL)

{

printf("Error!!! 内存没有分配。");

exit(0);

}

printf("\n");

// 用户输入

for(i = 0; i < num; ++i)

{

printf("输入数字 %d: ", i + 1);

scanf("%f", data + i);

}

// 循环找出最大值

for(i = 1; i < num; ++i)

{

// 如果需要找出最小值可以将 < 改为 >

if(*data < *(data + i))

*data = *(data + i);

}

printf("最大元素 = %.2f", *data);

return 0;

}

输出结果为：

输入元素个数(1 ~ 100): 5

输入数字 1: 12

输入数字 2: 32

输入数字 3: 6

输入数字 4: 56

输入数字 5: 21

最大元素 = 56.00

55、 C 语言实例 - 删除字符串中的特殊字符

删除字符串中的除字母外的字符。

实例

#include<stdio.h>

int main()

{

char line[150];

int i, j;

printf("输入一个字符串: ");

fgets(line, (sizeof line / sizeof line[0]), stdin);

for(i = 0; line[i] != '\0'; ++i)

{

while (!( (line[i] >= 'a' && line[i] <= 'z') || (line[i] >= 'A' && line[i] <= 'Z') || line[i] == '\0') )

{

for(j = i; line[j] != '\0'; ++j)

{

line[j] = line[j+1];

}

line[j] = '\0';

}

printf("输出: ");

puts(line);

return 0;

}

输出结果为：

输入一个字符串: run4#$1oob

输出: runoob

56、 C 语言实例 – 连接字符串

使用 strcat() 连接两个字符串。

实例

#include <stdio.h>

int main()

{

char s1[100], s2[100], i, j;

printf("输入第一个字符串: ");

scanf("%s", s1);

printf("输入第二个字符串: ");

scanf("%s", s2);

// 计算字符串 s1 长度

for(i = 0; s1[i] != '\0'; ++i);

for(j = 0; s2[j] != '\0'; ++j, ++i)

{

s1[i] = s2[j];

}

s1[i] = '\0';

printf("连接后: %s", s1);

return 0;

}

输出结果为：

输入第一个字符串: google

输入第二个字符串: runoob

连接后: googlerunoob

57、 C 语言实例 – 计算字符串长度

计算字符串长度。

实例 - 使用 strlen()

#include <stdio.h>

#include <string.h>

int main()

{

char s[1000];

int len;

printf("输入字符串: ");

scanf("%s", s);

len = strlen(s);

printf("字符串长度: %d", len);

return 0;

}

输出结果为：

输入字符串: runoob

字符串长度: 6

实例 - 不使用 strlen()

#include <stdio.h>

int main()

{

char s[1000], i;

printf("输入字符串: ");

scanf("%s", s);

for(i = 0; s[i] != '\0'; ++i);

printf("字符串长度: %d", i);

return 0;

}

输出结果为：

输入字符串: runoob

字符串长度: 6

58、 C 语言实例 – 查找字符在字符串中出现的次数

查找字符在字符串中的起始位置(索引值从 0 开始)。

实例

#include <stdio.h>

int main()

{

char str[1000], ch;

int i, frequency = 0;

printf("输入字符串: ");

fgets(str, (sizeof str / sizeof str[0]), stdin);

printf("输入要查找的字符: ");

scanf("%c",&ch);

for(i = 0; str[i] != '\0'; ++i)

{

if(ch == str[i])

++frequency;

}

printf("字符 %c 在字符串中出现的次数为 %d", ch, frequency);

return 0;

}

输出结果为：

输入字符串: runoob

输入要查找的字符: o

字符 o 在字符串中出现的次数为 2

59、 C 语言实例 – 字符串中各种字符计算

计算字符串中的元音、辅音、数字、空白符。

实例

#include <stdio.h>

int main()

{

char line[150];

int i, vowels, consonants, digits, spaces;

vowels = consonants = digits = spaces = 0;

printf("输入一个字符串: ");

scanf("%[^\n]", line);

for(i=0; line[i]!='\0'; ++i)

{

if(line[i]=='a' || line[i]=='e' || line[i]=='i' ||

line[i]=='o' || line[i]=='u' || line[i]=='A' ||

line[i]=='E' || line[i]=='I' || line[i]=='O' ||

line[i]=='U')

{

++vowels;

}

else if((line[i]>='a'&& line[i]<='z') || (line[i]>='A'&& line[i]<='Z'))

{

++consonants;

}

else if(line[i]>='0' && line[i]<='9')

{

++digits;

}

else if (line[i]==' ')

{

++spaces;

}

printf("元音: %d",vowels);

printf("\n辅音: %d",consonants);

printf("\n数字: %d",digits);

printf("\n空白符: %d", spaces);

return 0;

}

输出结果为：

输入一个字符串: runoob123 erkcomsww dfrunoob

元音: 8

辅音: 15

数字: 3

空白符: 2

60、 C 语言实例 - 字符串复制

将一个变量的字符串复制到另外一个变量中。

实例 - 使用 strcpy()

#include <stdio.h>

#include <string.h>

int main()

{

char src[40];

char dest[100];

memset(dest, '\0', sizeof(dest));

strcpy(src, "This is runoob.com");

strcpy(dest, src);

printf("最终的目标字符串： %s\n", dest);

return(0);

}

输出结果为：

最终的目标字符串： This is runoob.com

实例 - 不使用 strcpy()

#include <stdio.h>

int main()

{

char s1[100], s2[100], i;

printf("字符串 s1: ");

scanf("%s",s1);

for(i = 0; s1[i] != '\0'; ++i)

{

s2[i] = s1[i];

}

s2[i] = '\0';

printf("字符串 s2: %s", s2);

return 0;

}

输出结果为：

字符串 s1: runoob

字符串 s2: runoob

61、 C 语言实例 - 字符串排序

按字典顺序排序。

实例

#include<stdio.h>

#include <string.h>

int main()

{

int i, j;

char str[10][50], temp[50];

printf("输入10个单词:\n");

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

scanf("%s[^\n]",str[i]);

}

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

for(j=i+1; j<10 ; ++j)

{

if(strcmp(str[i], str[j])>0)

{

strcpy(temp, str[i]);

strcpy(str[i], str[j]);

strcpy(str[j], temp);

}

printf("\n排序后: \n");

for(i=0; i<10; ++i)

{

puts(str[i]);

}

return 0;

}

输出结果为：

输入10个单词:

C++

Java

PHP

Python

Perl

Ruby

JavaScript

PHP

排序后:

C++

Java

JavaScript

PHP

Perl

Python

Ruby

62、 C 语言实例 - 使用结构体（struct）

使用结构体（struct）存储学生信息。

实例

#include <stdio.h>

struct student

{

char name[50];

int roll;

float marks;

} s;

int main()

{

printf("输入信息:\n");

printf("名字: ");

scanf("%s", s.name);

printf("编号: ");

scanf("%d", &s.roll);

printf("成绩: ");

scanf("%f", &s.marks);

printf("显示信息:\n");

printf("名字: ");

puts(s.name);

printf("编号: %d\n",s.roll);

printf("成绩: %.1f\n", s.marks);

return 0;

}

输出结果为：

输入信息:

名字: runoob

编号: 123

成绩: 89

显示信息:

名字: runoob

编号: 123

成绩: 89.0

63、 C 语言实例 - 复数相加

使用结构体（struct）将两个复数相加。

我们把形如 a+bi（a,b均为实数）的数称为复数，其中 a 称为实部，b 称为虚部，i 称为虚数单位。

实例

#include <stdio.h>

typedef struct complex

{

float real;

float imag;

} complex;

complex add(complex n1,complex n2);

int main()

{

complex n1, n2, temp;

printf("第一个复数 \n");

printf("输入实部和虚部:\n");

scanf("%f %f", &n1.real, &n1.imag);

printf("\n第二个复数 \n");

printf("输入实部和虚部:\n");

scanf("%f %f", &n2.real, &n2.imag);

temp = add(n1, n2);

printf("Sum = %.1f + %.1fi", temp.real, temp.imag);

return 0;

}

complex add(complex n1, complex n2)

{

complex temp;

temp.real = n1.real + n2.real;

temp.imag = n1.imag + n2.imag;

return(temp);

}

输出结果为：

第一个复数

输入实部和虚部:

2.3 4.5

第二个复数

输入实部和虚部:

3.4 5

Sum = 5.7 + 9.5i

64、 C 语言实例 - 计算两个时间段的差值

计算两个时间段的差值。

实例

#include <stdio.h>

struct TIME

{

int seconds;

int minutes;

int hours;

};

void differenceBetweenTimePeriod(struct TIME t1, struct TIME t2, struct TIME *diff);

int main()

{

struct TIME startTime, stopTime, diff;

printf("输入开始时间: \n");

printf("输入小时、分钟、秒：");

scanf("%d %d %d", &startTime.hours, &startTime.minutes, &startTime.seconds);

printf("输入停止时间: \n");

printf("输入小时、分钟、秒: ");

scanf("%d %d %d", &stopTime.hours, &stopTime.minutes, &stopTime.seconds);

// 计算差值

differenceBetweenTimePeriod(startTime, stopTime, &diff);

printf("\n差值: %d:%d:%d - ", startTime.hours, startTime.minutes, startTime.seconds);

printf("%d:%d:%d ", stopTime.hours, stopTime.minutes, stopTime.seconds);

printf("= %d:%d:%d\n", diff.hours, diff.minutes, diff.seconds);

return 0;

}

void differenceBetweenTimePeriod(struct TIME start, struct TIME stop, struct TIME *diff)

{

if(stop.seconds > start.seconds){

--start.minutes;

start.seconds += 60;

}

diff->seconds = start.seconds - stop.seconds;

if(stop.minutes > start.minutes){

--start.hours;

start.minutes += 60;

}

diff->minutes = start.minutes - stop.minutes;

diff->hours = start.hours - stop.hours;

}

输出结果为：

输入开始时间:

输入小时、分钟、秒：12 34 55

输入停止时间:

输入小时、分钟、秒: 8 12 5

差值: 12:34:55 - 8:12:5 = 4:22:50

65、 C 语言实例 - 将字符串写入文件

将字符串写入文件。

实例

#include <stdio.h>

#include <stdlib.h> /* exit() 函数 */

int main()

{

char sentence[1000];

FILE *fptr;

fptr = fopen("runoob.txt", "w");

if(fptr == NULL)

{

printf("Error!");

exit(1);

}

printf("输入字符串:\n");

fgets(sentence, (sizeof sentence / sizeof sentence[0]), stdin);

fprintf(fptr,"%s", sentence);

fclose(fptr);

return 0;

}

输出结果为：

输入字符串:

runoob.com

打开文件 runoob.txt:

$ cat runoob.txt

runoob.com

66、 C 语言实例 - 从文件中读取一行

从文件中读取一行。

文件 runoob.txt 内容:

$ cat runoob.txt

runoob.com

google.com

实例

#include <stdio.h>

#include <stdlib.h> // exit() 函数

int main()

{

char c[1000];

FILE *fptr;

if ((fptr = fopen("runoob.txt", "r")) == NULL)

{

printf("Error! opening file");

// 文件指针返回 NULL 则退出

exit(1);

}

// 读取文本，直到碰到新的一行开始

fscanf(fptr,"%[^\n]", c);

printf("读取内容:\n%s", c);

fclose(fptr);

return 0;

}

输出结果为：

读取内容:

runoob.com

67、 C 语言实例 - 输出当前文件执行代码

输出当前文件执行代码，__FILE__ 为当前执行的文件常量。

实例

#include <stdio.h>

int main() {

FILE *fp;

char c;

fp = fopen(__FILE__,"r");

do {

c = getc(fp);

putchar(c);

}

while(c != EOF);

fclose(fp);

return 0;

}

输出结果为：

#include <stdio.h>

int main() {

FILE *fp;

char c;

fp = fopen(__FILE__,"r");

do {

c = getc(fp);

putchar(c);

}

while(c != EOF);

fclose(fp);

return 0;

}

68、C 语言实例 - 约瑟夫生者死者小游戏

30 个人在一条船上，超载，需要 15 人下船。

于是人们排成一队，排队的位置即为他们的编号。

报数，从 1 开始，数到 9 的人下船。

如此循环，直到船上仅剩 15 人为止，问都有哪些编号的人下船了呢？

实例

#include<stdio.h>

int c = 0;

int i = 1;

int j = 0;

int a[30] = { 0 };

int b[30] = { 0 };

int main() {

while (i<=31) {

if (i == 31) {

i = 1;

} else if (c == 15) {

break;

} else {

if (b[i] != 0) {

i++;

continue;

} else {

j++;

if (j != 9) {

i++;

continue;

} else {

b[i] = 1;

a[i] = j;

j = 0;

printf("第%d号下船了\n", i);

i++;

c++;

}

执行以上实例，输出结果为：

第9号下船了

第18号下船了

第27号下船了

第6号下船了

第16号下船了

第26号下船了

第7号下船了

第19号下船了

第30号下船了

第12号下船了

第24号下船了

第8号下船了

第22号下船了

第5号下船了

第23号下船了

69、C 语言实例 - 五人分鱼

A、B、C、D、E 五人在某天夜里合伙去捕鱼，到第二天凌晨时都疲惫不堪，于是各自找地方睡觉。

日上三杆，A 第一个醒来，他将鱼分为五份，把多余的一条鱼扔掉，拿走自己的一份。

B 第二个醒来，也将鱼分为五份，把多余的一条鱼扔掉拿走自己的一份。。

C、D、E依次醒来，也按同样的方法拿鱼。

问他们台伙至少捕了多少条鱼?以及每个人醒来时见到了多少鱼？

实例

#include <stdio.h>

int main(){

int n,x,j,k,l,m;

for(n=5;;n++){

j=4*(n-1)/5;

k=4*(j-1)/5;

l=4*(k-1)/5;

m=4*(l-1)/5;

if(n%5==1&&j%5==1&&k%5==1&&l%5==1&&m%5==1){

printf("至少合伙捕鱼：%d条\n",n);

printf("分别见到鱼的条数：%d %d %d %d\n",j,k,l,m);

break;

}

return 0;

}

以上实例输出结果为：

至少合伙捕鱼：3121条

分别见到鱼的条数：2496 1996 1596 1276

C 标准库 - <stdlib.h>

库函数：

1：printf：

规定符

%d 十进制有符号整数

%u 十进制无符号整数

%f 浮点数

%s 字符串

%c 单个字符

%p 指针的值

%e 指数形式的浮点数

%x, %X 无符号以十六进制表示的整数

%o 无符号以八进制表示的整数

%g 把输出的值按照 %e 或者 %f 类型中输出长度较小的方式输出

%p 输出地址符

%lu 32位无符号整数

%llu 64位无符号整数

函数：

1：sizeof(type) ：为了得到某个类型或某个变量在特定平台上的准确大小，您可以使用 sizeof 运算符。表达式 sizeof(type) 得到对象或类型的存储字节大小。

c语言考试知识点总结

相关文章

基于Java和Vue开发的漫画阅读软件漫画阅读小程序漫画APP

LoRa无线空调计费系统都应用在哪里

4.STM32通信接口之SPI通信---硬件SPI的介绍

Open AI 推出 ChatGPT Pro

洛谷P1030 [NOIP2001 普及组] 求先序排列（c嘎嘎）

创意型广告如何配音梨花声音研修院退费

探索 Python 应用的分层依赖：解决 UOS 环境中的 libvirt-python 安装问题

SpringBoot+ENC实现密钥加密及使用原理

多源多汇流网络的等价转换与证明

如何制作“优美”PPT

R中利用ggplot2绘制气泡图

腾讯新版滑块识别/滑块识别

Oracle系统性能监控工具oswatcher演示

PowerShell install 一键部署postgres17

Elasticsearch vs 向量数据库:寻找最佳混合检索方案

【Qt在线安装器】不能下载Qt5

【Unity高级】如何获取着色器(Shader)的关键词

1.1 Beginner Level学习之“使用 rosed 在 ROS 中编辑文件”（第九节）

MySQL语句学习第三篇_数据库

HCIA-openGauss_2_2连接与认证