C 语言教程

1. C 语言教程

https://www.runoob.com/cprogramming/c-tutorial.html

可以写在一个或多个扩展名为 “.c” 的文本文件中。

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

1.1. 实例解析

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

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

#include 
 
int main()
{
    /* 我的第一个 C 程序 */
    printf("Hello, World! \n");
 
    return 0;
}
1
2
3
4
5
6
7
8
9

• 所有的 C 语言程序都需要包含 main() 函数。 代码从 main() 函数开始执行。
• /* ... */ 用于注释说明。
• printf() 用于格式化输出到屏幕。printf() 函数在 “stdio.h” 头文件中声明。
• stdio.h 是一个头文件 (标准输入输出头文件) , #include 是一个预处理命令, 用来引入头文件。 当编译器遇到 printf() 函数时, 如果没有找到 stdio.h 头文件, 会发生编译错误。
• return 0; 语句用于表示退出程序。终止 main() 函数, 并返回值 0。

1.2. C11

当前最新的 C 语言标准为 C18 , 在它之前的 C 语言标准有 C17、C11…C99 等。

C 语言标准是于 1988 年由美国国家标准协会 (ANSI, 全称 American National Standard Institute) 制定的。

C11(也被称为 C1X) 指 ISO 标准 ISO/IEC 9899:2011。在它之前的 C 语言标准为 C99。

新特性:

• 对齐处理 (Alignment) 的标准化(包括 _Alignas 标志符, alignof 运算符, aligned_alloc 函数以及头文件)。
• _Noreturn 函数标记, 类似于 gcc 的 attribute((noreturn))。
• _Generic 关键字。
• 多线程 (Multithreading) 支持, 包括:
• _Thread_local 存储类型标识符, 头文件, 里面包含了线程的创建和管理函数。
• _Atomic 类型修饰符和头文件。
• 增强的 Unicode 的支持。基于 C Unicode 技术报告 ISO/IEC TR 19769:2004, 增强了对 Unicode 的支持。包括为 UTF-16/UTF-32 编码增加了 char16_t 和 char32_t 数据类型, 提供了包含 unicode 字符串转换函数的头文件。
• 删除了 gets() 函数, 使用一个新的更安全的函数 gets_s() 替代。
• 增加了边界检查函数接口, 定义了新的安全的函数, 例如 fopen_s(), strcat_s() 等等。
• 增加了更多浮点处理宏(宏)。
• 匿名结构体/联合体支持。这个在 gcc 早已存在, C11 将其引入标准。
• 静态断言 (Static assertions), _Static_assert(), 在解释 #if 和 #error 之后被处理。
• 新的 fopen() 模式, (“…x”)。类似 POSIX 中的 O_CREAT|O_EXCL, 在文件锁中比较常用。
• 新增 quick_exit() 函数作为第三种终止程序的方式。当 exit() 失败时可以做最少的清理工作。

1.3. GCC

$ gcc -v
1

1.3.1. Linux

如果未安装 GCC, 那么请按照 http://gcc.gnu.org/install/ 上的详细说明安装 GCC。

1.3.2. MacOS

如果您使用的是 Mac OS X, 最快捷的获取 GCC 的方法是从苹果的网站上下载 Xcode 开发环境, 并按照安装说明进行安装。一旦安装上 Xcode, 您就能使用 GNU 编译器。

Xcode 目前可从 developer.apple.com/technologies/tools/ 上下载。

1.3.3. Windows

为了在 Windows 上安装 GCC, 您需要安装 MinGW。为了安装 MinGW, 请访问 MinGW 的主页 mingw-w64.org, 进入 MinGW 下载页面, 下载最新版本的 MinGW 安装程序, 命名格式为 MinGW-.exe。

当安装 MinGW 时, 您至少要安装 gcc-core、gcc-g++、binutils 和 MinGW runtime, 但是一般情况下都会安装更多其他的项。

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

当完成安装时, 您可以从 Windows 命令行上运行 gcc、g++、ar、ranlib、dlltool 和其他一些 GNU 工具。

1.4. 编译 & 执行 C 程序

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

请确保您的路径中已包含 gcc 编译器, 并确保在包含源文件 hello.c 的目录中运行它。

如果是多个 c 代码的源码文件, 编译方法如下:

$ gcc test1.c test2.c -o main.out
$ ./main.out
1
2

1.5. C 的令牌 (Token)

C 程序由各种令牌组成, 令牌可以是关键字、标识符、常量、字符串值, 或者是一个符号。例如, 下面的 C 语句包括五个令牌:

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

这五个令牌分别是:

printf
(
"Hello, World! \n"
)
;
1
2
3
4
5

1.5.1. 分号 ;

在 C 程序中, 分号是语句结束符。也就是说, 每个语句必须以分号结束。它表明一个逻辑实体的结束。

1.5.2. 注释

C 语言有两种注释方式:

// 单行注释
1

以 // 开始的单行注释, 这种注释可以单独占一行。

/* 单行注释 */

/* 
 多行注释
 */
1
2
3
4
5

1.5.3. 标识符

• 一个标识符以字母 A-Z 或 a-z 或下划线 _ 开始, 后跟零个或多个字母、下划线和数字 (0-9)。
• C 标识符内不允许出现标点字符, 比如 @、$ 和 %。
• C 是区分大小写的编程语言。

1.5.4. 关键字

这些保留字不能作为常量名、变量名或其他标识符名称。

1.5.5. C 中的空格

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

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

int age;
1

在这里, int 和 age 之间必须至少有一个空格字符(通常是一个空白符), 这样编译器才能够区分它们。

1.6. C 数据类型

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

• 基本类型: 它们是算术类型, 包括两种类型: 整数类型和浮点类型。
• 枚举类型: 它们也是算术类型, 被用来定义在程序中只能赋予其一定的离散整数值的变量。
• void 类型: 类型说明符 void 表明没有可用的值。
• 派生类型: 它们包括: 指针类型、数组类型、结构类型、共用体类型和函数类型。

1.6.1. 整数类型

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

以下列出了 32 位系统与 64 位系统的存储大小的差别 (windows 相同):

为了得到某个类型或某个变量在特定平台上的准确大小, 您可以使用 sizeof 运算符。表达式 sizeof(type) 得到对象或类型的存储字节大小。下面的实例演示了获取 int 类型的大小:

#include 
#include 
 
int main()
{
   printf("int 存储大小 : %lu \n", sizeof(int));
   
   return 0;
}
1
2
3
4
5
6
7
8
9

%lu 为 32 位无符号整数, 详细说明查看 C 库函数 - printf()。

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

int 存储大小 : 4 
1

1.6.2. 浮点类型

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

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

#include 
#include 
 
int main()
{
   printf("float 存储最大字节数 : %lu \n", sizeof(float));
   printf("float 最小值: %E\n", FLT_MIN );
   printf("float 最大值: %E\n", FLT_MAX );
   printf("精度值: %d\n", FLT_DIG );
   
   return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

%E 为以指数形式输出单、双精度实数, 详细说明查看 C 库函数 - printf()。

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

float 存储最大字节数 : 4 
float 最小值: 1.175494E-38
float 最大值: 3.402823E+38
精度值: 6
1
2
3
4

1.6.3. void 类型

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

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

1.7. C 变量

变量其实只不过是程序可操作的存储区的名称。C 中每个变量都有特定的类型, 类型决定了变量存储的大小和布局, 该范围内的值都可以存储在内存中, 运算符可应用于变量上。

C 语言也允许定义各种其他类型的变量, 比如枚举、指针、数组、结构、共用体等等。

1.7.1. C 中的变量定义

type variable_list;
1

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

int    i, j, k;
char   c, ch;
float  f, salary;
double d;
1
2
3
4

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

type variable_name = value;
1

下面列举几个实例:

extern int d = 3, f = 5;    // d 和 f 的声明与初始化
int d = 3, f = 5;           // 定义并初始化 d 和 f
byte z = 22;                // 定义并初始化 z
char x = 'x';               // 变量 x 的值为 'x'
1
2
3
4

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

1.7.2. C 中的变量声明

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

变量的声明有两种情况:

1. 一种是需要建立存储空间的。例如: int a 在声明的时候就已经建立了存储空间。
2. 另一种是不需要建立存储空间的, 通过使用 extern 关键字声明变量名而不定义它。 例如: extern int a 其中变量 a 可以在别的文件中定义的。
3. 除非有 extern 关键字, 否则都是变量的定义。

extern int i; //声明, 不是定义
int i; //声明, 也是定义
1
2

尝试下面的实例, 其中, 变量在头部就已经被声明, 但是定义与初始化在主函数内:

#include 
 
// 函数外定义变量 x 和 y
int x;
int y;
int addtwonum()
{
    // 函数内声明变量 x 和 y 为外部变量
    extern int x;
    extern int y;
    // 给外部变量(全局变量)x 和 y 赋值
    x = 1;
    y = 2;
    return x+y;
}
 
int main()
{
    int result;
    // 调用函数 addtwonum
    result = addtwonum();
    
    printf("result 为: %d",result);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

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

$ gcc addtwonum.c test.c -o main
$ ./main
1
2

1.7.3. C 中的左值 (Lvalues) 和右值 (Rvalues)

C 中有两种类型的表达式:

• 左值 (lvalue): 指向内存位置的表达式被称为左值 (lvalue) 表达式。左值可以出现在赋值号的左边或右边。
• 右值 (rvalue): 术语右值 (rvalue) 指的是存储在内存中某些地址的数值。右值是不能对其进行赋值的表达式, 也就是说, 右值可以出现在赋值号的右边, 但不能出现在赋值号的左边。
  变量是左值, 因此可以出现在赋值号的左边。数值型的字面值是右值, 因此不能被赋值, 不能出现在赋值号的左边。下面是一个有效的语句:

int g = 20;
1

但是下面这个就不是一个有效的语句, 会生成编译时错误:

10 = 20;
1

1.8. C 常量

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

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

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

1.8.1. 整数常量

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

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

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

212         /* 合法的 */
215u        /* 合法的 */
0xFeeL      /* 合法的 */
078         /* 非法的: 8 不是八进制的数字 */
032UU       /* 非法的: 不能重复后缀 */
1
2
3
4
5

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

85         /* 十进制 */
0213       /* 八进制 */
0x4b       /* 十六进制 */
30         /* 整数 */
30u        /* 无符号整数 */
30l        /* 长整数 */
30ul       /* 无符号长整数 */
1
2
3
4
5
6
7

1.8.2. 浮点常量

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

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

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

3.14159       /* 合法的 */
314159E-5L    /* 合法的 */
510E          /* 非法的: 不完整的指数 */
210f          /* 非法的: 没有小数或指数 */
.e55          /* 非法的: 缺少整数或分数 */
1
2
3
4
5

1.8.3. 字符常量

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

字符常量可以是一个普通的字符(例如 ‘x’)、一个转义序列(例如 ‘\t’), 或一个通用的字符(例如 ‘\u02C0’)。

在 C 中, 有一些特定的字符, 当它们前面有反斜杠时, 它们就具有特殊的含义, 被用来表示如换行符(\n)或制表符(\t)等。下表列出了一些这样的转义序列码:

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

#include 
 
int main()
{
   printf("Hello\tWorld\n\n");
 
   return 0;
}
1
2
3
4
5
6
7
8

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

Hello   World
1

1.8.4. 字符串常量

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

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

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

"hello, dear"

"hello, \

dear"

"hello, " "d" "ear"
1
2
3
4
5
6
7

1.8.5. 定义常量

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

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

1.8.5.1. #define 预处理器

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

#define identifier value
1

具体请看下面的实例:

#include 
 
#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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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

value of area : 50
1

1.8.5.2. const 关键字

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

const type variable = value;
1

const 声明常量要在一个语句内完成:

#include 
 
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

value of area : 50
1

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

1.9. C 存储类

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

• auto
• register
• static
• extern

1.9.1. auto 存储类

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

{
   int mount;
   auto int month;
}
1
2
3
4

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

1.9.2. register 存储类

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

{
register int miles;
}

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

1.9.3. static 存储类

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

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

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

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

#include 
 
/* 函数声明 */
void func1(void);
 
static int count=10;        /* 全局变量 - static 是默认的 */
 
int main()
{
  while (count--) {
      func1();
  }
  return 0;
}
 
void func1(void)
{
/* 'thingy' 是 'func1' 的局部变量 - 只初始化一次
 * 每次调用函数 'func1' 'thingy' 值不会被重置。
 */                
  static int thingy=5;
  thingy++;
  printf(" thingy 为 %d ， count 为 %d\n", thingy, count);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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

可能您现在还无法理解这个实例，因为我已经使用了函数和全局变量，这两个概念目前为止还没进行讲解。即使您现在不能完全理解，也没有关系，后续的章节我们会详细讲解。当上面的代码被编译和执行时，它会产生下列结果：

 thingy 为 6 ， count 为 9
 thingy 为 7 ， count 为 8
 thingy 为 8 ， count 为 7
 thingy 为 9 ， count 为 6
 thingy 为 10 ， count 为 5
 thingy 为 11 ， count 为 4
 thingy 为 12 ， count 为 3
 thingy 为 13 ， count 为 2
 thingy 为 14 ， count 为 1
 thingy 为 15 ， count 为 0
1
2
3
4
5
6
7
8
9
10

1.9.4. extern 存储类

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

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

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

第一个文件：main.c

#include 
 
int count ;
extern void write_extern();
 
int main()
{
   count = 5;
   write_extern();
}
1
2
3
4
5
6
7
8
9
10

第二个文件：support.c

#include 
 
extern int count;
 
void write_extern(void)
{
   printf("count is %d\n", count);
}
1
2
3
4
5
6
7
8

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

$ gcc main.c support.c
1

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

count is 5
1

1.10. C 运算符

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

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

1.10.1. 算术运算符