语言概述

概述

C语言是贝尔电话实验室Dennis M. Ritchie于1972年为开发UNIX操作系统而开发的一种通用的，过程式的，命令式的计算机编程语言。C 语言是一种广泛使用的计算机语言，它与 Java 编程语言一样普及，二者在现代软件程序员之间都得到广泛使用。

本教程专为需要从头开始了解C编程语言的软件程序员而设计。本教程将使您对C编程语言有足够的了解，从此可以将自己带到更高水平的专业知识。

在继续本教程之前，您应该对计算机编程术语有基本的了解。 对任何编程语言的基本理解将帮助您理解C编程概念，并在学习过程中快速移动。

简介

C 简介

C语言是一种通用的高级语言，最初是由丹尼斯·里奇在贝尔实验室为开发 UNIX 操作系统而设计的。C 语言最开始是于 1972 年在 DEC PDP-11 计算机上被首次实现。

在1978年，布莱恩·柯林汉（Brian Kernighan）和丹尼斯·里奇（Dennis Ritchie）制作了 C 的第一个公开可用的描述，现在被称为 K&R 标准。

UNIX 操作系统，C编译器，和几乎所有的 UNIX 应用程序都是用 C 语言编写的。由于各种原因，C 语言现在已经成为一种广泛使用的专业语言。

• 易于学习。
• 结构化语言。
• 它产生高效率的程序。
• 它可以处理底层的活动。
• 它可以在多种计算机平台上编译。

关于C语言

• C 语言是为了编写 UNIX 操作系统而被发明的。
• C 语言是以 B 语言为基础的，B 语言大概是在 1970 年被引进的。
• C 语言标准是于 1988 年由美国国家标准协会（ANSI，全称 American National Standard Institute）制定的。
• 截至 1973 年，UNIX 操作系统完全使用 C 语言编写。
• 目前，C 语言是最广泛使用的系统程序设计语言。
• 大多数先进的软件都是使用 C 语言实现的。
• 当今最流行的Linux操作系统和 RDBMS（Relational Database Management System：关系数据库管理系统） MySQL 都是使用 C语言编写的。

为什么要使用C语言？

C 语言最初是用于系统开发工作，特别是组成操作系统的程序。由于 C 语言所产生的代码运行速度与汇编语言编写的代码运行速度几乎一样，所以采用 C 语言作为系统开发语言。下面列举几个使用 C 的实例：

• 操作系统
• 语言编译器
• 汇编器
• 文本编辑器
• 打印机
• 网络驱动器
• 现代程序
• 数据库
• 语言解释器
• 实体工具

C程序

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

环境设置

本地环境设置

如果您想为C编程语言设置您的环境，则需要以下两种计算机上可用的软件工具：（a）文本编辑器和（b）C编译器。

文本编辑器

这将用于键入您的程序。 几个编辑器的例子包括Windows记事本，OS编辑命令，Brief，Epsilon，EMACS和vim或vi。

文本编辑器的名称和版本可能因不同的操作系统而异。 例如，记事本将在Windows上使用，vim或vi可以在Windows和Linux或UNIX上使用。

您使用编辑器创建的文件称为源文件，它们包含程序源代码。 C程序的源文件通常以扩展名“.c”命名。

在开始编程之前，请确保您有一个文本编辑器，并且您有足够的经验编写计算机程序，将其保存在文件中，编译并最终执行。

C编译器

源文件中编写的源代码是您的程序的可读源。 它需要被“编译”成机器语言，以便你的CPU可以按照给出的指令实际执行程序。

编译器将源代码编译成最终的可执行程序。 最常用的免费可用编译器是GNU C/C++编译器，否则，如果您有各自的操作系统，则可以从HP或Solaris获得编译器。

以下部分介绍如何在各种操作系统上安装GNU C/C++编译器。我们一直在提及C/C++，因为GNU gcc编译器适用于C和C ++编程语言。

UNIX/Linux上的安装

如果您使用的是Linux或UNIX，请通过从命令行输入以下命令来检查系统上是否安装了GCC

$ gcc -v

如果你的机器上安装了GNU编译器，那么它应该如下打印一条消息

Using built-in specs.
Target: i386-redhat-linux
Configured with: ../configure --prefix=/usr .......
Thread model: posix
gcc version 4.1.2 20080704 (Red Hat 4.1.2-46)

如果未安装GCC，则必须使用https://gcc.gnu.org/install/上提供的详细说明自行安装。

本教程是基于Linux编写的，所有给出的示例都是在Linux系统的Cent OS风格上编译的。

Mac OS上的安装

如果您使用Mac OS X，获取GCC的最简单方法是从Apple网站下载Xcode开发环境，并遵循简单的安装说明。 一旦你设置了Xcode，你就可以使用C / C ++的GNU编译器。

Xcode下载地址 developer.apple.com/technologies/tools/

Windows上的安装

要在Windows上安装GCC，您需要安装MinGW。 要安装MinGW，请转到MinGW主页www.mingw.org，并按照链接进入MinGW下载页面。 下载MinGW安装程序的最新版本，该程序应该命名为MinGW- .exe。

安装MinGW时，至少需要安装gcc-core，gcc-g ++，binutils和MinGW运行时，但您可能希望安装更多。

将MinGW安装的bin子目录添加到您的PATH环境变量中，以便您可以通过其简单名称在命令行上指定这些工具。

安装完成后，您将能够从Windows命令行运行gcc，g ++，ar，ranlib，dlltool和其他几个GNU工具。

程序结构

C 程序结构

在我们研究C编程语言的基本结构之前，让我们看看最小的C程序结构，以便我们可以在以后的章节中将其作为参考。

Hello World示例

一个C程序基本上由以下几部分组成

• 预处理器指令
• 函数
• 变量
• 语句 & 表达式
• 注释

让我们看一段简单的代码，可以输出单词 "Hello World"

#include <stdio.h>

int main() {
/* my first program in C */
printf("Hello, World! \n");

return 0;
}

让我们看看上述的程序的各个部分

• 程序的第一行 #include <stdio.h> 是预处理器指令，告诉 C 编译器在实际编译之前要包含 stdio.h 文件。
• 下一行 int main() 是主函数，程序从这里开始执行。
• 下一行 /*...*/ 将会被编译器忽略，这里放置程序的注释内容。它们被称为程序的注释。
• 下一行 printf(...) 是 C 中另一个可用的函数，会在屏幕上显示消息 "Hello, World!"。
• 下一行 return 0; 终止 main() 函数，并返回值 0。

编译并执行C程序

让我们看看如何将源代码保存在一个文件中，以及如何编译和运行它。 以下是简单的步骤

• 打开一个文本编辑器，添加上述代码。
• 保存文件为 hello.c。
• 打开命令提示符，进入到保存文件所在的目录。
• 键入 gcc hello.c，输入回车，编译代码。
• 如果代码中没有错误，命令提示符会跳到下一行，并生成 a.out 可执行文件。
• 现在，键入 a.out 来执行程序。
• 您可以看到屏幕上显示 "Hello World"。

$ gcc hello.c
$ ./a.out
Hello, World!

确保你的路径包含gcc编译器，并且在包含源文件hello.c的目录中运行它。

基本语法

C 基本语法

您已经看到了C程序的基本结构，因此很容易理解C语言的其他基本程序块。

C语言的令牌

C程序由各种令牌组成，而令牌可以是关键字，标识符，常量，字符串文字或符号。 例如，以下C语句由五个令牌组成

printf("Hello, World! \n");

这五个令牌分别是;

printf
(
"Hello, World! \n"
)
;

分号

在C程序中，分号是语句终结符。 也就是说，每个单独的语句都必须以分号结尾。 它表示一个逻辑实体的结束。

下面是两个不同的语句

printf("Hello, World! \n");
return 0;

注释

注释就像是 C 程序中的帮助文本，它们会被编译器忽略。它们以 /* 开始，以字符 */ 终止，如下所示

/* my first program in C */

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

标识符

C标识符是用于标识变量，函数或任何其他用户定义项目的名称。 标识符以字母A到Z，a到z或下划线'_'开头，后跟零个或多个字母，下划线和数字（0到9）。

C不允许在标识符中使用标点符号，如@，$和％。 C是一种区分大小写的编程语言。 因此，Manpower和manpower是C中两个不同的标识符。下面是一些可接受标识符的例子

mohd       zara    abc   move_name  a_123
myname50   _temp   j     a23b9      retVal

关键字

下表列出了 C 中的保留字。这些保留字不能作为常量名、变量名或其他标识符名称。

auto	else	long	switch
break	enum	register	typedef
case	extern	return	union
char	float	short	unsigned
const	for	signed	void
continue	goto	sizeof	volatile
default	if	static	while
do	int	struct	_Packed
double

C中的空格

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

在C中，空格用于描述空白符、制表符、换行符和注释。空格分隔语句的各个部分，让编译器能识别语句中的某个元素（比如 int）在哪里结束，下一个元素在哪里开始。因此，在下面的语句中

int age;

编译器必须至少有一个int和age之间的空格字符（通常是空格），以便能够区分它们。 另一方面，在下面的声明

fruit = apples + oranges;   // get the total fruit

fruit 和 =，或者 = 和 apples 之间的空格字符不是必需的，但是为了增强可读性，您可以根据需要适当增加一些空格。

数据类型

C 数据类型

在C语言中，数据类型指的是用于声明不同类型的变量或函数的一个广泛的系统。变量的类型决定了变量存储占用的空间，以及如何解释存储的位模式。

C中的类型可分为以下几种：

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

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

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

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

数组类型和结构类型统称为聚合类型。函数的类型指的是函数返回值的类型。在本章节接下来的部分我们将介绍基本类型，其他几种类型会在后边几个章节中进行讲解。

整数类型

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

类型	存储大小	值范围
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

要在特定平台上获取类型或变量的确切大小，可以使用sizeof运算符。 表达式sizeof（type）以字节为单位生成对象或类型的存储大小。 下面给出的是在任何机器上获取int类型大小的示例

#include <stdio.h>
#include <limits.h>

int main() {
printf("Storage size for int : %d \n", sizeof(int));

return 0;
}

当您编译并执行上述程序时，它会在Linux上产生以下结果

Storage size for int : 4

浮点类型

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

类型	存储大小	值范围	精度
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 位小数

头文件 float.h 定义了宏，在程序中可以使用这些值和其他有关实数二进制表示的细节。下面的实例将输出浮点类型占用的存储空间以及它的范围值

#include <stdio.h>
#include <float.h>

int main() {
printf("Storage size for float : %d \n", sizeof(float));
printf("Minimum float positive value: %E\n", FLT_MIN );
printf("Maximum float positive value: %E\n", FLT_MAX );
printf("Precision value: %d\n", FLT_DIG );

return 0;
}

当您在 Linux 上编译并执行上面的程序时，它会产生下列结果

Storage size for float : 4
Minimum float positive value: 1.175494E-38
Maximum float positive value: 3.402823E+38
Precision value: 6

void类型

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

序号	类型与描述
1	函数返回为空 C 中有各种函数都不返回值，或者您可以说它们返回空。不返回值的函数的返回类型为空。例如 void exit (int status);
2	函数参数为空 C 中有各种函数不接受任何参数。不带参数的函数可以接受一个 void。例如 int rand(void);
3	指针指向 void 类型为 void * 的指针代表对象的地址，而不是类型。例如，内存分配函数 void *malloc( size_t size ); 返回指向 void 的指针，可以转换为任何数据类型。

变量

C 变量

变量不过是给我们的程序可以操作的存储区域的名称。 C中的每个变量都有一个特定的类型，它决定了变量内存的大小和布局; 可以存储在该存储器中的值的范围; 以及可以应用于该变量的一组操作。

变量的名称可以由字母，数字和下划线字符组成。 它必须以字母或下划线开头。 大写和小写字母是不同的，因为C区分大小写。 根据前一章中介绍的基本类型，将会有以下基本变量类型

类型	描述
char	通常是一个字节（八位）。这是一个整数类型。
int	对机器而言，整数的最自然的大小。
float	单精度浮点值。单精度是这样的格式，1位符号，8位指数，23位小数。
double	双精度浮点值。双精度是1位符号，11位指数，52位小数。
void	表示类型的缺失。

C编程语言还允许定义各种其他类型的变量，我们将在随后的章节中介绍这些变量，如枚举，指针，数组，结构，联合等。本章让我们仅研究基本变量类型。

C中的变量定义

变量定义就是告诉编译器在何处创建变量的存储，以及如何创建变量的存储。变量定义指定一个数据类型，并包含了该类型的一个或多个变量的列表，如下所示

type variable_list;

在这里，type 必须是一个有效的 C 数据类型，可以是 char、w_char、int、float、double、bool 或任何用户自定义的对象，variable_list 可以由一个或多个标识符名称组成，多个标识符之间用逗号分隔。下面列出几个有效的声明：

int    i, j, k;
char   c, ch;
float  f, salary;
double d;

行 int i, j, k; 声明并定义了变量 i、j 和 k，这指示编译器创建类型为 int 的名为 i、j、k 的变量。

变量可以在声明的时候被初始化（指定一个初始值）。初始化器由一个等号，后跟一个常量表达式组成，如下所示：

type variable_name = value;

下面列举几个实例

extern int d = 3, f = 5;    // declaration of d and f.
int d = 3, f = 5;           // definition and initializing d and f.
byte z = 22;                // definition and initializes z.
char x = 'x';               // the variable x has the value 'x'.

不带初始化的定义：带有静态存储持续时间的变量会被隐式初始化为 NULL（所有字节的值都是 0），其他所有变量的初始值是未定义的。

C中的变量声明

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

当您使用多个文件时，变量声明很有用，并且您可以在链接程序时可用的其中一个文件中定义变量。 您将使用关键字extern在任何地方声明一个变量。 尽管可以在C程序中多次声明变量，但它只能在文件，函数或代码块中定义一次。

例子，尝试以下示例，其中变量已在顶部声明，但它们已在主函数内定义和初始化。

#include <stdio.h>

// Variable declaration:
extern int a, b;
extern int c;
extern float f;

int main () {

/* variable definition: */
int a, b;
int c;
float f;

/* actual initialization */
a = 10;
b = 20;

c = a + b;
printf("value of c : %d \n", c);

f = 70.0/3.0;
printf("value of f : %f \n", f);

return 0;
}

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

value of c : 30
value of f : 23.333334

C 中的左值（Lvalues）和右值（Rvalues）

C 中有两种类型的表达式

• 左值（lvalue）：指向内存位置的表达式被称为左值（lvalue）表达式。左值可以出现在赋值号的左边或右边。
• 右值（rvalue）：术语右值（rvalue）指的是存储在内存中某些地址的数值。右值是不能对其进行赋值的表达式，也就是说，右值可以出现在赋值号的右边，但不能出现在赋值号的左边。

变量是左值，因此它们可能出现在任务的左侧。 数字文字是右值，因此它们可能不会被分配，并且不能出现在左边。 看看下面的有效和无效的陈述

int g = 20; // valid statement

10 = 20; // invalid statement; would generate compile-time error

常量

C 常量

常量指的是程序在执行过程中可能不会改变的固定值。 这些固定值也被称为文字。

常量可以是任何的基本数据类型，比如整数常量、浮点常量、字符常量，或字符串字面值，也有枚举常量。

常量就像是常规的变量，只不过常量的值在定义后不能进行修改。

整数常量

整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，不带前缀则默认表示十进制。

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

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

    212         /* Legal */
	215u        /* Legal */
	0xFeeL      /* Legal */
	078         /* Illegal: 8 is not an octal digit */
	032UU       /* Illegal: cannot repeat a suffix */

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

85         /* decimal */
0213       /* octal */
0x4b       /* hexadecimal */
30         /* int */
30u        /* unsigned int */
30l        /* long */
30ul       /* unsigned long */

浮点常量

浮点常量由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量。

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

下面列举几个浮点常量的实例

3.14159       /* Legal */
314159E-5L    /* Legal */
510E          /* Illegal: incomplete exponent */
210f          /* Illegal: no decimal or exponent */
.e55          /* Illegal: missing integer or fraction */

字符常量

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

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

在 C 中，有一些特定的字符，当它们前面有反斜杠时，它们就具有特殊的含义，被用来表示如换行符（\n）或制表符（\t）等。

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

转义序列	含义
\\	\ 字符
\'	' 字符
\"	" 字符
\?	? 字符
\a	警报铃声
\b	退格键
\f	换页符
\n	换行符
\r	回车
\t	水平制表符
\v	垂直制表符
\ooo	一到三位的八进制数
\xhh . . .	一个或多个数字的十六进制数

下面的实例显示了一些转义序列字符

#include <stdio.h>

int main() {
printf("Hello\tWorld\n\n");

return 0;
}

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

Hello World

字符串常量

字符串字面值或常量是括在双引号 "" 中的。一个字符串包含类似于字符常量的字符：普通的字符、转义序列和通用的字符。

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

下面的实例显示了一些字符串常量。下面这三种形式所显示的字符串是相同的。

"hello, dear"

"hello, \

dear"

"hello, " "d" "ear"

定义常量

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

• 使用 #define 预处理器。
• 使用 const 关键字。

#define 预处理器

下面是使用 #define 预处理器定义常量的形式：

#define identifier value

具体请看下面的实例

#include <stdio.h>

#define LENGTH 10
#define WIDTH  5
#define NEWLINE '\n'

int main() {
int area;

area = LENGTH * WIDTH;
printf("value of area : %d", area);
printf("%c", NEWLINE);

return 0;
}

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

value of area : 50

const关键字

您可以使用 const 前缀声明指定类型的常量，如下所示：

const type variable = value;

具体请看下面的实例

#include <stdio.h>

int main() {
const int  LENGTH = 10;
const int  WIDTH = 5;
const char NEWLINE = '\n';
int area;

area = LENGTH * WIDTH;
printf("value of area : %d", area);
printf("%c", NEWLINE);

return 0;
}

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

value of area : 50

请注意，把常量定义为大写字母形式，是一个很好的编程实践。

存储类

C 存储类

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

• auto
• register
• static
• extern

auto存储类

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

{
	int mount;
	auto int month;
}

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

register存储类

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

{
	register int  miles;
}

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

static存储类

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

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

static 是全局变量的默认存储类，以下两个变量 (count 和 road) 都有一个 static 存储类。

static int Count;
int Road;

main()
{
printf("%d\n", Count);
printf("%d\n", Road);
}

以下实例演示了 static 修饰全局变量和局部变量的应用

#include <stdio.h>

/* function declaration */
void func(void);

static int count = 5; /* global variable */

main() {

while(count--) {
func();
}

return 0;
}

/* function definition */
void func( void ) {

static int i = 5; /* local static variable */
i++;

printf("i is %d and count is %d\n", i, count);
}

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

i is 6 and count is 4
i is 7 and count is 3
i is 8 and count is 2
i is 9 and count is 1
i is 10 and count is 0

extern存储类

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

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

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

第一个文件: main.c

#include <stdio.h>

int count ;
extern void write_extern();

main() {
count = 5;
write_extern();
}

第二个文件: support.c

#include <stdio.h>

extern int count;

void write_extern(void) {
printf("count is %d\n", count);
}

在这里，第二个文件中的 extern 关键字用于声明已经在第一个文件 main.c 中定义的 count。现在 ，编译这两个文件，如下所示：

$ gcc main.c support.c

这会产生 a.out 可执行程序，当程序被执行时，它会产生下列结果：

count is 5

运算符

C 运算符

运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C 语言内置了丰富的运算符，并提供了以下类型的运算符

• 算术运算符
• 关系运算符
• 逻辑运算符
• 位运算符
• 赋值运算符
• 杂项运算符

本章将逐一介绍算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符和其他运算符。

算术运算符

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

运算符	描述	实例
+	把两个操作数相加	A + B 将得到 30
-	从第一个操作数中减去第二个操作数	A - B 将得到 -10
*	把两个操作数相乘	A * B 将得到 200
/	分子除以分母	B / A 将得到 2
%	取模运算符，整除后的余数	B % A 将得到 0
++	自增运算符，整数值增加 1	A++ 将得到 11
--	自减运算符，整数值减少 1	A-- 将得到 9

请看下面的实例，了解 C 语言中所有可用的算术运算符

#include <stdio.h>

main() {

int a = 21;
int b = 10;
int c ;

c = a + b;
printf("Line 1 - Value of c is %d\n", c );

c = a - b;
printf("Line 2 - Value of c is %d\n", c );

c = a * b;
printf("Line 3 - Value of c is %d\n", c );

c = a / b;
printf("Line 4 - Value of c is %d\n", c );

c = a % b;
printf("Line 5 - Value of c is %d\n", c );

c = a++;
printf("Line 6 - Value of c is %d\n", c );

c = a--;
printf("Line 7 - Value of c is %d\n", c );
}

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

Line 1 - Value of c is 31
Line 2 - Value of c is 11
Line 3 - Value of c is 210
Line 4 - Value of c is 2
Line 5 - Value of c is 1
Line 6 - Value of c is 21
Line 7 - Value of c is 22

关系运算符

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

运算符	描述	实例
==	检查两个操作数的值是否相等，如果相等则条件为真。	(A == B) 不为真。
!=	检查两个操作数的值是否相等，如果不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是则条件为真。	(A > B) 不为真。
<	检查左操作数的值是否小于右操作数的值，如果是则条件为真。	(A < B) 为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。	(A >= B) 不为真。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。	(A <= B) 为真。

请看下面的实例，了解 C 语言中所有可用的关系运算符

#include <stdio.h>

main() {

int a = 21;
int b = 10;
int c ;

if( a == b ) {
printf("Line 1 - a is equal to b\n" );
} else {
printf("Line 1 - a is not equal to b\n" );
}

if ( a < b ) {
printf("Line 2 - a is less than b\n" );
} else {
printf("Line 2 - a is not less than b\n" );
}

if ( a > b ) {
printf("Line 3 - a is greater than b\n" );
} else {
printf("Line 3 - a is not greater than b\n" );
}

/* Lets change value of a and b */
a = 5;
b = 20;

if ( a <= b ) {
printf("Line 4 - a is either less than or equal to  b\n" );
}

if ( b >= a ) {
printf("Line 5 - b is either greater than  or equal to b\n" );
}
}

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

Line 1 - a is not equal to b
Line 2 - a is not less than b
Line 3 - a is greater than b
Line 4 - a is either less than or equal to  b
Line 5 - b is either greater than  or equal to b

逻辑运算符

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

运算符	描述	实例
&&	称为逻辑与运算符。如果两个操作数都非零，则条件为真。	(A && B) 为假。
||	称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。	(A || B) 为真。
!	称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。	!(A && B) 为真。

请看下面的实例，了解 C 语言中所有可用的逻辑运算符

#include <stdio.h>

main() {

int a = 5;
int b = 20;
int c ;

if ( a && b ) {
printf("Line 1 - Condition is true\n" );
}

if ( a || b ) {
printf("Line 2 - Condition is true\n" );
}

/* lets change the value of  a and b */
a = 0;
b = 10;

if ( a && b ) {
printf("Line 3 - Condition is true\n" );
} else {
printf("Line 3 - Condition is not true\n" );
}

if ( !(a && b) ) {
printf("Line 4 - Condition is true\n" );
}

}

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

Line 1 - Condition is true
Line 2 - Condition is true
Line 3 - Condition is not true
Line 4 - Condition is true

位运算符

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

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

假设如果 A = 60，且 B = 13，现在以二进制格式表示，它们如下所示

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A  = 1100 0011

下表显示了 C 语言支持的位运算符。假设变量 A 的值为 60，变量 B 的值为 13，则：

运算符	描述	实例
&	如果同时存在于两个操作数中，二进制 AND 运算符复制一位到结果中。	(A & B) 将得到 12，即为 0000 1100
|	如果存在于任一操作数中，二进制 OR 运算符复制一位到结果中。	(A | B) 将得到 61，即为 0011 1101
^	如果存在于其中一个操作数中但不同时存在于两个操作数中，二进制异或运算符复制一位到结果中。	(A ^ B) 将得到 49，即为 0011 0001
~	二进制补码运算符是一元运算符，具有"翻转"位效果，即0变成1，1变成0。	(~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。
<<	二进制左移运算符。左操作数的值向左移动右操作数指定的位数。	A << 2 将得到 240，即为 1111 0000
>>	二进制右移运算符。左操作数的值向右移动右操作数指定的位数。	A >> 2 将得到 15，即为 0000 1111

请看下面的实例，了解 C 语言中所有可用的位运算符

#include <stdio.h>

main() {

unsigned int a = 60;    /* 60 = 0011 1100 */
unsigned int b = 13;    /* 13 = 0000 1101 */
int c = 0;

c = a & b;       /* 12 = 0000 1100 */
printf("Line 1 - Value of c is %d\n", c );

c = a | b;       /* 61 = 0011 1101 */
printf("Line 2 - Value of c is %d\n", c );

c = a ^ b;       /* 49 = 0011 0001 */
printf("Line 3 - Value of c is %d\n", c );

c = ~a;          /*-61 = 1100 0011 */
printf("Line 4 - Value of c is %d\n", c );

c = a << 2;     /* 240 = 1111 0000 */
printf("Line 5 - Value of c is %d\n", c );

c = a >> 2;     /* 15 = 0000 1111 */
printf("Line 6 - Value of c is %d\n", c );
}

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

Line 1 - Value of c is 12
Line 2 - Value of c is 61
Line 3 - Value of c is 49
Line 4 - Value of c is -61
Line 5 - Value of c is 240
Line 6 - Value of c is 15

赋值运算符

下表列出了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

请看下面的实例，了解 C 语言中所有可用的赋值运算符

#include <stdio.h>

main() {

int a = 21;
int c ;

c =  a;
printf("Line 1 - =  Operator Example, Value of c = %d\n", c );

c +=  a;
printf("Line 2 - += Operator Example, Value of c = %d\n", c );

c -=  a;
printf("Line 3 - -= Operator Example, Value of c = %d\n", c );

c *=  a;
printf("Line 4 - *= Operator Example, Value of c = %d\n", c );

c /=  a;
printf("Line 5 - /= Operator Example, Value of c = %d\n", c );

c  = 200;
c %=  a;
printf("Line 6 - %= Operator Example, Value of c = %d\n", c );

c <<=  2;
printf("Line 7 - <<= Operator Example, Value of c = %d\n", c );

c >>=  2;
printf("Line 8 - >>= Operator Example, Value of c = %d\n", c );

c &=  2;
printf("Line 9 - &= Operator Example, Value of c = %d\n", c );

c ^=  2;
printf("Line 10 - ^= Operator Example, Value of c = %d\n", c );

c |=  2;
printf("Line 11 - |= Operator Example, Value of c = %d\n", c );
}

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

Line 1 - =  Operator Example, Value of c = 21
Line 2 - += Operator Example, Value of c = 42
Line 3 - -= Operator Example, Value of c = 21
Line 4 - *= Operator Example, Value of c = 441
Line 5 - /= Operator Example, Value of c = 21
Line 6 - %= Operator Example, Value of c = 11
Line 7 - <<= Operator Example, Value of c = 44
Line 8 - >>= Operator Example, Value of c = 11
Line 9 - &= Operator Example, Value of c = 2
Line 10 - ^= Operator Example, Value of c = 0
Line 11 - |= Operator Example, Value of c = 2

杂项运算符 ↦ sizeof & 三元

下表列出了 C 语言支持的其他一些重要的运算符，包括 sizeof 和 ? :。

运算符	描述	实例
sizeof()	返回变量的大小。	sizeof(a) 将返回 4，其中 a 是整数。
&	返回变量的地址。	&a; 将给出变量的实际地址。
*	指向一个变量。	*a; 将指向一个变量。
? :	条件表达式	如果条件为真 ? 则值为 X : 否则值为 Y

请看下面的实例，了解 C 语言中所有可用的杂项运算符

#include <stdio.h>
	
main() {
	
	int a = 4;
	short b;
	double c;
	int* ptr;
	
	/* example of sizeof operator */
	printf("Line 1 - Size of variable a = %d\n", sizeof(a) );
	printf("Line 2 - Size of variable b = %d\n", sizeof(b) );
	printf("Line 3 - Size of variable c= %d\n", sizeof(c) );
	
	/* example of & and * operators */
	ptr = &a;    /* 'ptr' now contains the address of 'a'*/
	printf("value of a is  %d\n", a);
	printf("*ptr is %d.\n", *ptr);
	
	/* example of ternary operator */
	a = 10;
	b = (a == 1) ? 20: 30;
	printf( "Value of b is %d\n", b );
	
	b = (a == 10) ? 20: 30;
	printf( "Value of b is %d\n", b );
}

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

Line 1 - Size of variable a = 4
Line 2 - Size of variable b = 2
Line 3 - Size of variable c= 8
value of a is  4
*ptr is 4.
Value of b is 30
Value of b is 20

C中的运算符优先级

运算符的优先级确定表达式中项的组合。这会影响到一个表达式如何计算。某些运算符比其他运算符有更高的优先级，例如，乘除运算符具有比加减运算符更高的优先级。

例如 x = 7 + 3 * 2，在这里，x 被赋值为 13，而不是 20，因为运算符 * 具有比 + 更高的优先级，所以首先计算乘法 3*2，然后再加上 7。

下表将按运算符优先级从高到低列出各个运算符，具有较高优先级的运算符出现在表格的上面，具有较低优先级的运算符出现在表格的下面。在表达式中，较高优先级的运算符会优先被计算。

类别	运算符	结合性
后缀	() [] -> . ++ - -	从左到右
一元	+ - ! ~ ++ - - (type)* & sizeof	从右到左
乘除	* / %	从左到右
加减	+ -	从左到右
移位	<< >>	从左到右
关系	< <= > >=	从左到右
相等	== !=	从左到右
位与 AND	&	从左到右
位异或 XOR	^	从左到右
位或 OR	|	从左到右
逻辑与 AND	&&	从左到右
逻辑或 OR	||	从左到右
条件	?:	从右到左
赋值	= += -= *= /= %=>>= <<= &= ^= |=	从右到左
逗号	,	从左到右

请看下面的实例，了解 C 语言中运算符的优先级

#include <stdio.h>
	
main() {
	
	int a = 20;
	int b = 10;
	int c = 15;
	int d = 5;
	int e;
	
	e = (a + b) * c / d;      // ( 30 * 15 ) / 5
	printf("Value of (a + b) * c / d is : %d\n",  e );
	
	e = ((a + b) * c) / d;    // (30 * 15 ) / 5
	printf("Value of ((a + b) * c) / d is  : %d\n" ,  e );
	
	e = (a + b) * (c / d);   // (30) * (15/5)
	printf("Value of (a + b) * (c / d) is  : %d\n",  e );
	
	e = a + (b * c) / d;     //  20 + (150/5)
	printf("Value of a + (b * c) / d is  : %d\n" ,  e );
	
	return 0;
}

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

Value of (a + b) * c / d is : 90
Value of ((a + b) * c) / d is  : 90
Value of (a + b) * (c / d) is  : 90
Value of a + (b * c) / d is  : 50

判断

C 判断

决策制定结构要求程序员指定一个或多个要由程序评估或测试的条件，以及如果条件被确定为真时要执行的语句，并且可选地，如果条件被确定为要执行的其他语句 被确定为假。

以下显示的是大多数编程语言中的典型决策结构的一般形式

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

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

语句	描述
if 语句	一个 if 语句 由一个布尔表达式后跟一个或多个语句组成。
if...else 语句	一个 if 语句 后可跟一个可选的 else 语句，else 语句在布尔表达式为假时执行。
嵌套 if 语句	您可以在一个 if 或 else if 语句内使用另一个 if 或 else if 语句。
switch 语句	一个 switch 语句允许测试一个变量等于多个值时的情况。
嵌套 switch 语句	您可以在一个 switch 语句内使用另一个 switch 语句。

if语句

一个if语句由一个布尔表达式和一个或多个语句组成。

C 语言中 if 语句的语法

if(boolean_expression) {
/* statement(s) will execute if the boolean expression is true */
}

如果布尔表达式为 true，则 if 语句内的代码块将被执行。如果布尔表达式为 false，则 if 语句结束后的第一组代码（闭括号后）将被执行。

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

流程图

实例

#include <stdio.h>

int main () {

/* local variable definition */
int a = 10;

/* check the boolean condition using if statement */

if( a < 20 ) {
/* if condition is true then print the following */
printf("a is less than 20\n" );
}

printf("value of a is : %d\n", a);

return 0;
}

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

a is less than 20;
value of a is : 10

if...else 语句

一个 if 语句 后可跟一个可选的 else 语句，else 语句在布尔表达式为 false 时执行。

C 语言中 if...else 语句的语法

if(boolean_expression) {
/* statement(s) will execute if the boolean expression is true */
} else {
/* statement(s) will execute if the boolean expression is false */
}

如果布尔表达式为 true，则执行 if 块内的代码。如果布尔表达式为 false，则执行 else 块内的代码。

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

流程图

实例

#include <stdio.h>

int main ()
{
	/* 局部变量定义 */
	int a = 100;

	/* 检查布尔条件 */
	if( a < 20 )
	{
	/* 如果条件为真，则输出下面的语句 */
	printf("a 小于 20\n" );
	}
	else
	{
	/* 如果条件为假，则输出下面的语句 */
	printf("a 大于 20\n" );
	}
	printf("a 的值是 %d\n", a);

	return 0;
}

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

a 大于 20
a 的值是 100

if...else if...else 语句

一个 if 语句后可跟一个可选的 else if...else 语句，这可用于测试多种条件。

当使用 if...else if...else 语句时，以下几点需要注意：

• 一个 if 后可跟零个或一个 else，else 必须在所有 else if 之后。
• 一个 if 后可跟零个或多个 else if，else if 必须在 else 之前。
• 一旦某个 else if 匹配成功，其他的 else if 或 else 将不会被测试。

C 语言中的 if...else if...else 语句的语法：

if(boolean_expression 1) {
	/* Executes when the boolean expression 1 is true */
} else if( boolean_expression 2) {
	/* Executes when the boolean expression 2 is true */
} else if( boolean_expression 3) {
	/* Executes when the boolean expression 3 is true */
} else {
	/* executes when the none of the above condition is true */
}

实例

#include <stdio.h>
	
int main () {
	
	/* local variable definition */
	int a = 100;
	
	/* check the boolean condition */
	if( a == 10 ) {
		/* if condition is true then print the following */
		printf("Value of a is 10\n" );
	} else if( a == 20 ) {
		/* if else if condition is true */
		printf("Value of a is 20\n" );
	} else if( a == 30 ) {
		/* if else if condition is true  */
		printf("Value of a is 30\n" );
	} else {
		/* if none of the conditions is true */
		printf("None of the values is matching\n" );
	}
	
	printf("Exact value of a is: %d\n", a );
	
	return 0;
}

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

None of the values is matching
Exact value of a is: 100

嵌套if语句

在 C 语言中，嵌套 if-else 语句是合法的，这意味着您可以在一个 if 或 else if 语句内使用另一个 if 或 else if 语句。

C 语言中 嵌套 if 语句的语法

if( boolean_expression 1) {
	
	/* Executes when the boolean expression 1 is true */
	if(boolean_expression 2) {
		/* Executes when the boolean expression 2 is true */
	}
}

您可以嵌套 else if...else，方式与嵌套 if 语句相似。

实例

#include <stdio.h>
	
int main () {
	
	/* local variable definition */
	int a = 100;
	int b = 200;
	
	/* check the boolean condition */
	if( a == 100 ) {
	
		/* if condition is true then check the following */
		if( b == 200 ) {
			/* if condition is true then print the following */
			printf("Value of a is 100 and b is 200\n" );
		}
	}
	
	printf("Exact value of a is : %d\n", a );
	printf("Exact value of b is : %d\n", b );
	
	return 0;
}

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

Value of a is 100 and b is 200
Exact value of a is : 100
Exact value of b is : 200

switch语句

一个 switch 语句允许测试一个变量等于多个值时的情况。每个值称为一个 case，且被测试的变量会对每个 switch case 进行检查。

C 语言中 switch 语句的语法

switch(expression) {

	case constant-expression  :
		statement(s);
		break; /* optional */

	case constant-expression  :
		statement(s);
		break; /* optional */

	/* you can have any number of case statements */
	default : /* Optional */
	statement(s);
}

switch 语句必须遵循下面的规则

• switch 语句中的 expression 是一个常量表达式，必须是一个整型或枚举类型。
• 在一个 switch 中可以有任意数量的 case 语句。每个 case 后跟一个要比较的值和一个冒号。
• case 的 constant-expression 必须与 switch 中的变量具有相同的数据类型，且必须是一个常量或字面量。
• 当被测试的变量等于 case 中的常量时，case 后跟的语句将被执行，直到遇到 break 语句为止。
• 当遇到 break 语句时，switch 终止，控制流将跳转到 switch 语句后的下一行。
• 不是每一个 case 都需要包含 break。如果 case 语句不包含 break，控制流将会 继续 后续的 case，直到遇到 break 为止。
• 一个 switch 语句可以有一个可选的 defaultcase，出现在 switch 的结尾。default case 可用于在上面所有 case 都不为真时执行一个任务。default case 中的 break 语句不是必需的。

流程图

实例

#include <stdio.h>
	
int main () {
	
	/* local variable definition */
	char grade = 'B';
	
	switch(grade) {
		case 'A' :
			printf("Excellent!\n" );
			break;
		case 'B' :
		case 'C' :
			printf("Well done\n" );
			break;
		case 'D' :
			printf("You passed\n" );
			break;
		case 'F' :
			printf("Better try again\n" );
			break;
		default :
			printf("Invalid grade\n" );
	}
	
	printf("Your grade is  %c\n", grade );
	
	return 0;
}

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

Well done
Your grade is B

嵌套switch语句

您可以把一个 switch 作为一个外部 switch 的语句序列的一部分，即可以在一个 switch 语句内使用另一个 switch 语句。即使内部和外部 switch 的 case 常量包含共同的值，也没有矛盾。

C 语言中 嵌套 switch 语句的语法

switch(ch1) {
	
	case 'A':
		printf("This A is part of outer switch" );
	
		switch(ch2) {
			case 'A':
				printf("This A is part of inner switch" );
				break;
			case 'B': /* case code */
		}
	
		break;
	case 'B': /* case code */
}

实例

#include <stdio.h>
	
int main () {
	
	/* local variable definition */
	int a = 100;
	int b = 200;
	
	switch(a) {
	
		case 100:
			printf("This is part of outer switch\n", a );
	
			switch(b) {
				case 200:
					printf("This is part of inner switch\n", a );
				}
	}
	
	printf("Exact value of a is : %d\n", a );
	printf("Exact value of b is : %d\n", b );
	
	return 0;
}

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

This is part of outer switch
This is part of inner switch
Exact value of a is : 100
Exact value of b is : 200    

? : 运算符(三元运算符)

我们已经在前面的章节中讲解了 条件运算符 ? :，可以用来替代 if...else 语句。它的一般形式如下：

Exp1 ? Exp2 : Exp3;

其中，Exp1、Exp2 和 Exp3 是表达式。请注意，冒号的使用和位置。

? 表达式的值是由 Exp1 决定的。如果 Exp1 为真，则计算 Exp2 的值，结果即为整个 ? 表达式的值。如果 Exp1 为假，则计算 Exp3 的值，结果即为整个 ? 表达式的值。