1.C语言和C程序

1.C语言和C程序

C语言（1.C语言和C程序）

目录

• 一、C语言概述
• • 1. C语言的发展历程
  • 2. C语言的标准
  • 3. C语言结构
  • 4. 注释
• 二、程序环境
• • 1. C程序结构
  • 2. 翻译环境
  • • 2.1 预编译/预处理
    • 2.2 编译
    • 2.3 汇编
    • 2.4 链接
  • 3. 运行环境
  • • 3.1 C程序内存
    • 3.2 程序执行过程
• 三、预处理
• • 1. 预定义符号
  • 2. #define
  • • 2.1 定义标识符
    • 2.2 定义宏
    • 2.3 替换规则
    • 2.4 # 和
    • 2.6 宏和函数对比
  • 3. #undef
  • 4. 条件编译
  • • 4.1 常见的条件编译指令
    • 4.2 使用风格
  • 5. #include
  • • 5.1 包含方式
    • 5.1 重复引用
  • 6. 其他预处理指令

一、C语言概述

​ C语言：一门通用的计算机编程语言

1. C语言的发展历程

1. 二进制指令：可以直接被计算机识别的机器语言，是由0、1组成的代码
2. 汇编语言：将机器语言使用助记符来封装，形成汇编语言
3. B语言：对汇编语言进行封装，形成高级语言
4. C语言：对汇编语言进行封装，形成高级语言

2. C语言的标准

​ 由于互联网各厂对C语言的使用和修改，导致C语言的通用性越来越差，国际标准化组织将C语言进行标准化。常用的标准为C11，C89，C99，C90。

​ ANSI C为最初的标准，以后经常能看到这个标准

3. C语言结构

​ C语言一共有32个关键字，但是C99标准后有增加了5个关键字，目前主流编译器对C99的支持并不好，所以在这里我们默认使用C90的标准，即只使用32个关键字

4. 注释

​ 注释：用于对代码进行解释说明的，注释不参与编译过程，也不是代码的一部分

​ C语言标准定义的注释格式如下：

/* 注释内容 */

​ 注意：该注释不能嵌套

​ 在我们常见的代码中还见过行注释：

//注释内容

​ 行注释是C++的语法，在C语言标准里未定义，但是绝大多数编译器都支持行注释，且可以嵌套

二、程序环境

​ C语言的实现中有两种环境，分别是翻译环境和执行环境

• 翻译环境：在这个环境中，源代码被转换成可执行的机器指令
• 执行环境：用于实际执行代码，也叫运行环境

1. C程序结构

• 头文件：用来声明全局变量，自定义类型，函数原型的文件，后缀是.h
• 源文件：用户用来写代码的文件，代码的内容存储在源文件中，后缀是.c
• 目标文件：源文件经过编译后的二进制文件，里面都是机器指令
  • Windows系统下后缀是.obj，Linux系统下后缀是.o
• 可执行文件：经过编译链接后的可以直接运行的二进制文件，也是我们需要的最终结果
  • Windows系统下后缀是.exe，Linux系统下后缀是.out

2. 翻译环境

​ 源代码转换成可执行程序要经过2个步骤：编译 + 链接

​ 编译又可以细分为3个步骤：预编译 + 编译 + 汇编

• 编译器：进行编译的软件为编译器，每一个源文件由编译器转换为目标文件，VS2019的编译器为cl.exe
• 链接器：进行链接的软件叫链接器，每个目标文件和链接库由链接器捆绑在一起，形成一个可执行文件，VS2019的链接器为

以Linux系统下的gcc编译器演示编译过程，将源文件test.c 和add.c进行编译和链接：

2.1 预编译/预处理

• Linux命令：gcc -E test.c -o test.i，gcc -E add.c -o add.i

• 生成文件：test.i 和 add.i（源文件处理后的文件）

• 作用：将源文件进行处理

  1. 头文件包含
  2. 注释删除
  3. #define标识符替换，并删除定义的符号

2.2 编译

• Linux命令：gcc -S test.i，gcc -S add.i

• 生成文件：test.s 和 add.s（汇编代码）

• 作用：将源文件转换成汇编代码

  1. 语法分析

  2. 词法分析

  3. 语义分析

  4. 符号汇总：将全局符号进行修改后汇总

     C语言符号修改：符号前加_，如：main变_main

2.3 汇编

• Linux命令：gcc -c test.s，gcc -c add.s

• 生成文件：test.o 和 add.o（二进制文件，里面都是二进制指令，通常叫目标文件）

  • Windows系统中的文件：test.obj 和 add.obj

• 作用：将汇编代码转换成二进制指令

  1. 将汇编转换成二进制指令
  2. 形成符号表：对于每个文件，都对其全局符号申请空间，并将其对应的内存地址存储在符号表中
     1. 定义的标识符：符号表中存储其真实内存地址
     2. 声明的标识符：符号表中存储无效的地址，由编译器指定无效地址

2.4 链接

• 生成文件：a.out（可执行程序）

  • Windows系统中的文件&#

• 作用：将多个 .o文件 和 链接库 链接成一个可执行文件

  1. 合并段表：就是将多个.o文件按照特定内容进行合并

  2. 合并符号表并重定向：将多个.o文件的符号表进行合并

     声明的标识符中无效地址会被该标识符的真实内存地址取代

3. 运行环境

3.1 C程序内存

C程序的内存分布，只介绍几个简单的，笼统的说一下

• 栈stack：函数栈帧的创建，局部变量都在这里存储，具有临时性
• 堆heap：通过动态内存申请的变量都在堆内存储，需要申请和释放
• 静态区static：字符串常量、全局变量、static声明的局部变量都在这里存储，在编译期为该变量开辟好内存，内容不可改变，整个进程运行期间都存在
• 代码区：代码被存储在这里

3.2 程序执行过程

1. 程序必须载入内存中
   1. 在有操作系统的环境中，一般由操作系统完成
   2. 在独立的环境中，必须由手工安排，也可以是通过可执行代码置入只读内存来完成载入
2. 程序执行开始，调用main函数
3. 开始执行程序代码。此时程序使用一个运行时堆栈(stack)，存储局部变量和返回地址。程序同时也使用一个静态内存(static)，该内存中的变量在整个程序执行时一直存在并且不能修改值
4. 终止程序。正常终止main函数，也可能是意外终止

三、预处理

1. 预定义符号

​ C语言中有些存在的预定义符号可以供我们使用，它们都是库中用#define定义的符号

__FILE__	//源文件路径，字符串
__LINE__	//当前行号，int
__DATE__	//编译日期，字符串
__TIME__	//编译时间，字符串
__STDC__	//标准C，遵循ANSI C，其值为1，否则未定义

​ VS2019不遵循ANSI，gcc遵循，__STDC__值为1

2. #define

2.1 定义标识符

#define NAME stuff

注意：

1. define标识符建议全部为大写，用"_"来分隔单词
2. define定义标识符时，建议后面不要加分号，容易导致问题
3. 如果stuff太长，可以分行写，每行后加一个反斜杠做续行符（最后一行不用续行符）

​ 举个栗子：

#define MAX 1000			//将MAX定义为整型常量1000
#define REG register		//将register标识符定义为更简洁的标识符REG
#define DO_FORVER for(;;)	 //将一段语句定义为一个标识符
#define BEBUG_PRINT printf("file:%stline:%dtdate:%sttime:%sn," 	//使用做续行符__FILE__, __LEIN__, __DATE__, __TIME__)

2.2 定义宏

​ 宏(macro)：#define允许把参数替换到文本中，这种实现称为宏或定义宏

​ 如：定义一个宏SQUARE，参数为x，替换内容为x*x

#define SQUARE(x) x*x

​ 使用SQUARE，并传递参数5

SQUARE(5);

​ 预编译期间，源代码的此语句就被替换为

5*5;

注意：

1. 宏中的每个参数和表达式建议带上小括号，为避免替换后运算的优先级跟预想的不一样
1. 使用宏时，不要传入带副作用的参数，否则结果是难以预测的

​ 如：1. 使用宏计算5+1的平方，并加上2，结果却为13，错误

#define SQUARE(x) x*x	//宏定义
SQUARE(5+1) + 2;	    //使用该宏
5+1*5+1 + 2;		   //替换后的式子

​ 将宏的参数加上小括号后，计算结果为38，正确

#define SQUARE(x) ((x)*(x))  //加了括号的宏定义
SQUARE(5+1) + 2;			//使用该宏
((5+1)*(5+1)) + 2;			//替换后的式子

​ 如：2. 将a++和b++作为参数传入一下宏

#define MAX(A, B) (((A)>(B)) ? (A) : (B))	//宏定义int a=5, b=8;
int c = MAX(a++, b++);		//宏调用int c = (((a++)>(b++)) ? (a++) : (b++));	//替换后的式子，结果为a=6,b=10,c=9

2.3 替换规则

​ 在程序预编译时，会对#define定义的宏或标识符进行替换，步骤如下

1. 调用宏时，首先检查参数，如果参数包含由#define定义的符号，则它被首先替换
2. 将替换文本直接替换到该标识符出现的位置，对于宏还有参数的替换
3. 最后对文件进行检查，如果还有#defien定义的符号，则重复以上步骤

注意：

1. 宏参数中可以出现其他#define定义的符号，但是对于宏不能递归定义
2. 预处理器搜索#define时，字符串常量中出现该符号时，则不被替换，如：char str[] = "SQUARE(5)";

2.4 # 和

​ 在宏的参数中使用该符号

​ #参数名：将该参数加上 “” 替换到替换文本中

//宏定义
#define PRINT(FORMAT, VALUE) printf("the value of "#VALUE" is "FORMAT"n", VALUE)int a = 10;
PRINT("%d", a);	//宏调用//替换后的式子，VALUE替换为a，#VALUE替换为"a"
printf("the value of ""a"" is ""%d""n", 10);

​ 参数名##参数名：将两边的符号合成一个符号

//宏定义
#define ADD_TO_SUM(NUM, VALUE) sum##NUM += valueint sum5 = 10;
ADD_TO_SUM(5, 10);	//调用宏sum5 += 10;		//替换后的式子，sum和5拼接，合成sum5

注意：这样的连接必须产生一个合法的标识符，否则就是未定义的

2.6 宏和函数对比

宏的优点：

1. 宏的速度比函数快。
   1. 宏是在编译期直接进行替换，源文件直接编译链接为可执行文件进行运行
   2. 函数是在运行期间对参数进行复制，创建函数栈帧进行运行，运行完销毁在栈中的内存
2. 宏是类型无关的
   1. 宏是直接替换，不受类型检查
   2. 函数要对参数进行检查，参数必须要相互对应

宏的缺点：

1. 每次调用宏时，都会直接将替换文本替换到标识符位置，多次调用或替换文本内容很多时，将大大增加程序的长度
2. 宏是没办法调试的
3. 宏的类型无关，导致不够严谨
4. 宏可能会带来算术优先级问题

宏和函数的区别：

属性	#define定义宏	函数
代码长度	每次调用都会替换，除非宏小，否则程序长度大幅增加	函数只出现在一个地方，每次调用函数都是调用这一个地方的代码
执行速度	更快	存在调用和返回的开销，相对慢一点
操作符优先级	直接替换容易产生优先级问题，建议书写时使用括号	将参数直接拷贝，对参数进行操作，操作符优先级问题不容产生
带有副作用的参数	直接替换导致每次使用参数都会产生副作用，容易产生不可预料的后果，所以不要使用带副作用的参数	形参只在传值的时候求一次值，结果更容易控制
参数类型	参数类型无关，只要操作数合法，都能使用	参数类型必须一一对应
调试	宏不方便调试	函数可以逐语句调试
递归	不能递归	可以递归

3. #undef

​ 用于移除一个宏定义

#undef NAME	//移除NAME符号的定义

注意：一个符号要被重新定义，那么它要先移除

4. 条件编译

​ 在编译一个程序时，我们可以使用条件编译语句来决定内容是否被编译

4.1 常见的条件编译指令

1. 判断表达式结果，决定是否编译，常量表达式为0时不编译

#if 常量表达式//...
#endif

2. 多分支，跟if - else if使用方式一样

#if 常量表达式1//...
#elif 常量表达式2//...
#elif 常量表达式3//...
#else//...
#endif

3. 判断是否被定义

​ 判断该符号定义时，执行编译，有两种语句

//第一种，用#if判断defined中的符号
#if defined(symbol)//...
#endif//第二种，直接用#ifdef判断符号
#ifdef symbol//...
#endif

​ 判断该符号未定义时，执行编译，也是两种语句，并且跟上面两种对应

//第一种，用!对defined取反
#if !defined(symbol)//...
#endif//第二种，用#ifndef判断符号，中间多个n哦
#ifndef symbol//...
#endif

4. 嵌套条件指令

​ 跟if语句使用一样，可以嵌套使用

#if defined(OS_UNIX)#ifdef OPTION1unix_version_option1();#endif#ifdef OPTION2unix_version_option2();#endif
#elif defined(OS_MSDOS)#ifdef OPTION2msdos_version_option2();#endif
#endif

4.2 使用风格

1. 每一个#if，#ifdef，#ifndef 都有一个#endif作为结束标志，并且匹配最近的判断
2. 每一个#endif后面建议加上注释，用来标识是由哪个符号判断的结束指令
3. 理论上条件指令只要结果为假，内容不会被编译，但是并不建议使用它来当注释使用
   1. 注释是用来提醒该代码的功能，对于一些不重要的内容程序员可能并不阅读
   2. 条件指令是代码的一部分，若是当注释来使用，则程序员不得不关注其内容

//使用注释标识#if指令的结束标志
#if __DEBUG__//...
#endif //__DEBUG__

5. #include

​ #include指令包含头文件，预处理器先删除这条指令，在将头文件中的内容粘贴到源文件中

5.1 包含方式

1. 本地文件包含

#include "filename.h"

​ 查找策略：先在源文件目录下查找，如果该头文件未找到，则在库函数头文件下查找，若是还没有则编译错误

2. 库文件包含

#include <filename.h>

​ 查找策略：直接在库函数头文件下查早，若是没有则编译错误

3. 嵌套文件包含

​ 如：test.h中包含了add.h，add.h中包含了stdio.h，test.h中嵌套包含了stdio.h

​ 若是头文件很多，并且各自有很多引用，则容易发生头文件的重复包含

注意：

1. 使用""和<>包含头文件的区别是查找策略不同
2. ""可以用来包含库文件，但是不建议
   1. 使用双引号包含库文件会使查找效率减低
   2. 不容易区分库文件和本地文件，增加代码的阅读难度

5.1 重复引用

​ 一个头文件被包含了10次，那么源文件中就有10个该头文件的内容，也会被编译10次，大大增加了代码长度，所以头文件被重复包含是非常糟糕的

​ 解决重复引用有两种方式

1. 使用条件编译指令

​ 如果__TEST_H__没有被定义，则定义该符号，并完成头文件的编译，否则不对条件指令内的内容进行编译

#ifndef __TEST_H__
#define __TEST_H__//头文件内容#endif //__TEST_H__

2. 使用#pragma once

​ 在头文件前加上该指令

#pragma once

6. 其他预处理指令

#error
#pragma
#line
...
不做介绍，自己了解#pragma pack()在结构体已介绍