C语言笔记1

C语言笔记

C语言是一种通用的高级语言，最初是由丹尼斯.里奇在贝尔实验室为开发UNIX操作系统而设计。C语言最开始是于1972年在DEC PDP-11计算机上被首次实现。在1978年，布莱恩.柯林汉 (Brian Kernighan) 和 丹尼斯.里奇(Dennis Ritchie) 制作了C的第一个公开可用的描述，现在被称为K&R标准。C语言标准是于1988年由美国国家标准协会(ANSI, 全称American National Standdard Institude)制定的。目前，C语言是最广泛使用的系统程序设计语言。由于C语言所产生的代码运行速度与汇编语言编写的代码运行速度几乎一样，所以采用C语言作为系统开发语言。

C 程序结构

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

1. 预处理器指令（告诉计算机所编程序所需要的C语言标准库，即一组C内置函数、常量和头文件），代码语句写为：#include <标准库名称>C标准库-参考手册。
2. 函数(函数即为执行特定任务以完成特定功能的一段代码)。
3. 变量(数据存储区的一个名称)
4. 语句&表达式
5. 注释(用于说明代码的目的，所指代的意义等，被注释的部分计算机只读不运行)。

【注】有关注释

1. 单行注释

1. // 单行注释 以 // 开始的单行注释，这种注释可以单独占一行。
2. /* 单行注释 */

2. 多行注释
   
   /*
   多行注释
   多行注释
   
   多行注释
   */
   

需注意的是注释内不可嵌套注释，注释也不可出现在字符串或字符值中。
【代码示例】输出“Hello World”。

#include <stdio.h>//(1)
int main(){//(2)
    /*我的第一个C语言程序*/ //(3)
    printf("Hello World"\n);//(4)
    return 0;//(5)
}//(6)

(1) 预处理器指令#include，因为执行输出功能使用printf函数，此处使用stdio.h的标准库。
(2) 需要执行输出功能，每个功能需要包含在一个函数体内。这里的函数名为main，最终的结束返回结果为int型。这里的类型与函数名main之间需要保留一个空格，用以说明int 与 main为两个分隔的部分。
(3) 注释内容，编译器会直接忽略，机器无须认识这是什么。
(4) printf()函数输出具体的内容，\n为换行符，指打印完要求的内容后执行换行。分号是语句结束符，每个语句必须以分号结束。它表明一个逻辑实体的结束。
(5) 函数功能结束返回0。
(6) 每个函数体的内容都需要用一对{}包裹。

数据类型

在 C 语言中，数据类型指的是用于声明不同类型的变量或函数的一个广泛的系统。变量的类型决定了变量存储占用的空间，以及如何解释存储的位模式。相当于对于一个新生儿，我们需要知道这个新生儿的性别，多重，以方便购买相应的适配型号的衣服。可使用sizeof运算符得到对象或类型的存储字节大小，代码写为：

sizeof(type即数据类型，如int整型)

跟人一样有男有女，C语言中的数据类型也有不同的种类，具体为：

1. 基本类型。该类型的数据是基本的算术类型，主要有整数类型和浮点数类型(即数学上的整数与小数)。
2. 枚举类型。这也是一种算术类型的数据，但是是被用来定义在程序中只能被赋值离散整数值的数据。
3. void类型。类型说明符，void表明没有可用的值。此类型可用于设定1)函数的返回为空;2)所定义的函数无参数，此时参数可写为void;3)类型为void*的指针代表对象的地址，可以转换为任何数据类型。
4. 派生类型。指针类型、聚合类型(包括数组类型与结构体类型)、共用体类型、函数类型。

确定新生儿的性别等信息后，我们需要给这个新生儿一个名字，方便以后称呼。在C语言中，我们对称谓有一个专业的名字叫标识符。

标识符

C语言中的函数,变量或常量等都需要有个称谓，这个称谓统一称为标识符。C 语言标识符是用来标识变量、函数，或任何其他用户自定义项目的名称。 标识符，相当于人的名字，便于对每个量进行区分。就像起名字一样，我们一般不用运算符号、生僻字等，合法的标识符也有一定的表示规则，即

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

2. C 标识符内不允许出现标点字符，比如 @、$ 和 %。

3. C 是区分大小写的编程语言。因此，在 C 中，Manpower 和 manpower 是两个不同的标识符。

【注】C中列出了具有的一些保留字(关键字)C语言保留字，保留字不可作为常量名、变量名或其他标识符的名称。

变量、常量

变量

变量：程序可操作的存储区的名字。

每个变量定义时需要指明其数据类型与标识符，C 中每个变量都有特定的类型，类型决定了变量存储的大小和布局(就像每个个体必须分男女去对应的卫生间)，该范围内的值都可以存储在内存中，运算符可应用于变量上。定义方式写为：

type variable_list

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

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

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

type variable_name = value;

示例如下：

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

常量

常量是固定值，在程序执行期间不会改变。这些固定的值，又叫做字面量。常量即为常规的变量，只不过常量的值在定义后不能进行修改。常量可以是任何类型的基本数据类型，比如整数常量、浮点常量、字符常量，或字符串常量，也有枚举常量。

常量定义方式

在C语言中，通常将把常量定义为大写字母形式，定义方式有：

1. 使用#define预处理器。
2. 使用const关键字。
   代码语法分别为：

#define identifier value(#define 常量名称 常量取值)
const type variable = value;(const 变量类型 变量名=变量取值)
【注】：const 声明常量要在一个语句内完成。

常见常量类型

整数常量

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

整数常量也可以带一个后缀，后缀是 U 和 L 的组合，U 表示无符号整数（unsigned），L 表示长整数（long）。后缀可以是大写，也可以是小写，U 和 L 的顺序任意。
浮点常量
浮点常量由整数部分、小数点、小数部分和指数部分组成。带符号的指数是用 e 或 E 引入的。
字符常量

字符常量是括在单引号中，例如，‘x’ 可以存储在 char 类型的简单变量中。字符常量可以是一个普通的字符、一个转义序列(由反斜线字符组成，用以表示固定的意义)或一个通用的字符(UNICODE字符集作用:为世界650种语言进行统一编码，兼容ISO-8859-1。位数:UNICODE字符集有多个编码方式，分别是UTF-8，UTF-16和UTF-32。)

字符串常量

字符串字面值或常量是括在双引号""中。一个字符串包含类似于字符常量的字符：普通的字符、转义序列和通用的字符。字符串各字符之间可以使用空格、斜线、逗号等分隔符。如如下三种表示方式相同

1. "hello, dear"

2. "hello, \

dear"

3. "hello, " "d" "ear"

函数

函数是用于执行一个特定的任务的一组语句。每个C语言程序至少有一个函数，即主函数main()。

函数定义的代码语句写为：

return_type function_name( type of parameter1 name of parameter1,..., type of parameter1 name of parameter1)
{
   body of the function
}

即

所定义函数的返回值的数据类型  函数名(参数1(写明参数的数据类型及标识), 参数2,...,参数n){
    函数体;
}

【注：】

1. 有些函数执行所需的操作而不返回值，在这种情况下，return_type 是关键字 void。
2. 在定义函数时，函数的参数类型是必须的，否则不合法，但函数参数的名称并不是非有不可的，没有并不影响函数的运行。

【代码示例】求判断两个数a,b的大小，返回大的那个数。

#include <stdio.h>
int max(int a, int b){
    int result;
    result = a > b ? a : b;
    return result;
}
int main(){
	printf("%d\n", max(3,5));
	return 0;
}

运行结果为：

5
上述max(3,5)即在主函数中使用函数max(),即调用max()函数。在调用时，程序会将在主函数中实际给定的参数3,5传递给函数max(),函数max()即使用该参数组进行运算。

函数参数

所构建函数的参数被称为形式参数，形式参数跟函数体内的其他局部变量一样，在进入函数时被创建，退出函数时被销毁。

可变参数

当定义函数时，我们可能不确定函数参数的个数到底是多少，那么此时需要考虑可变数量的参数的函数定义。 stdarg.h头文件提供了实现可变参数功能的函数和宏.
带有可变数量参数的函数语法可写为:

函数类型   函数名(int 用于表示变量个数的变量, ...){
          函数体；
}

即使用可变参数功能的函数，其参数包括两个：一个是用于表示变量个数的变量；另一个是省略号（…）。

可变参数功能的函数的函数体定义步骤如下：

1. 首先，在函数定义的过程中，在函数体部分需要创建一个 va_list变量类型, 该类型是在 stdarg.h头文件中定义的。
2. 其次，使用va_start宏来初始化va_list类型的变量，va_start宏在stdarg.h头文件中。语法写为：

va_start(va_list类型变量的变量名，代表参数个数的变量名)。

3. 再次，使用va_arg宏来初始化va_list类型的变量，va_arg宏在stdarg.h头文件中。语法写为：

va_arg(va_list类型变量的变量名，int)。

4. 最后，使用va_end宏来清理赋予va_list 类型变量的内存。语法写为：

va_arg(va_list类型变量的变量名)。

【代码示例】编写一个带有可变数量参数的函数，并返回它们的平均值。

#include <stdio.h>
#include <stdarg.h>

double average(int num, ...){
      va_list valist;
      double sum = 0.0;
      int i;
      va_start(valist, num);
      for(i = 0; i < num; i++){
        sum += va_arg(valist, int);
        }
      va_end(valist);
       return sum / num;
}
 int main(){
  printf("2,3,4,5的平均数为：%f\n", average(4, 2,3,4,5));
  printf("5,10,15的平均数为：%f\n", average(3, 5,10,15));
  
  return 0; 
}

输出结果为：

2,3,4,5的平均数为：3.500000
5,10,15的平均数为：10.000000

作用域与存储类

作用域

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

1. 在函数或块内部的局部变量。
2. 在所有函数外部的全局变量。
3. 在行驶参数的函数参数定义中。

局部变量

局部变量是定义于某个函数或块的内部声明变量，该变量只能在所定义的函数体或代码块内部的语句中使用，其他区域不可使用。

全局变量

全局变量时定义在函数外部，通常在程序的顶部。全局变量在整个程序运行过程中都是有效的，可以被程序内的任何函数访问。

【注：】在程序中，局部变量和全局变量的名称是可以相同的，在两变量名称相同的情况下，在函数体内会使用局部变量名，全局变量不会被使用。
【代码示例】

#include <stdio.h>
int g; /* 全局变量声明 */
int f = 3;
int main1(void) {
	printf ("value of f = %d\n", f);
	printf ("value of g = %d\n", g);/*全局变量可在程序内的所有函数体内使用*/
	//printf ("value of a = %d\n", a);/*局部变量a不存在于此函数体内，无法输出，运行报错。*/
	}
int main ()
{
  int a, b, f; /* 局部变量声明 */
  /* 实际初始化 */
  a = 10;
  b = 20;
  f = 4;
  g = a + b;
  printf ("value of a = %d, b = %d, g = %d and f = %d\n", a, b, g, f);/*全局变量与局部变量重名，函数运行会使用局部变量的取值*/
  main1();
  return 0;
}

运行结果为：

value of a = 10, b = 20, g = 30 and f = 4
value of f = 3
value of g = 30

形式参数

形式参数是指所构造函数的参数，被当做该函数内的局部变量。

存储类

变量的作用域是从空间的角度来分析的，分全局和局部变量。从时间角度来看，变量还有存储类别的属性，即变量在内存中的存储方式，称为存储期(生命期)

存储期可以分为静态存储期(static storage duration)和动态存储期(dynamic storage duration)。所谓静态存储方式是指在程序运行期间，系统对变量分配固定的存储空间(包括程序区，静态存储区，动态存储区)。而动态存储方式则是在程序运行期间，系统对变量动态地分配存储空间。

存储类定义 C 程序中变量/函数的范围（可见性）和生命周期。C语言中可用的存储类具体包含

1. auto
2. register
3. static
4. extern

全局变量全部存放在静态存储区中，在程序开始执行时给全局变量分配存储单元，程序执行完毕就释放这些空间。在程序执行过程中它们占据固定的存储单元，而不是动态地进行分配和释放。

在动态存储区中存放以下数据:

1. 函数形式参数。在调用函数时给形参分配存储空间。
2. 函数中的局部变量(未加static声明的局部变量，详见后面的介绍)。
3. 函数调用时的现场保护和返回地址等。

对以上这些数据，在函数调用开始时分配动态存储空间，函数结束时释放这些空间。在程序执行过程中，这种分配和释放是动态的，如果在一个程序中两次调用同一函数，则要进行两次分配和释放，而两次分配给此函数中局部变量的存储空间地址可能是不相同的。

存储类用关键字auto声明的变量

函数的形参和函数中定义的局部变量。在函数被调用时，系统给形参和函数中定义的变量分配空间，数据存储在动态存储区内，在函数调用结束后，存储空间自动释放。因此这些局部变量称为自动变量，自动变量用关键字auto作为存储类别的声明。例如：

int fun(int a){
    auto int b, c;/*这里也可直接省略关键字auto*/
}

存储类别auto和数据类型int的顺序任意。关键字auto可以省略，如果不写auto，则系统会把它默认为自动存储类别。

存储类用关键字static声明的变量

静态局部变量。有时希望函数中的局部变量的值在函数调用结束后不消失而保留原值，即其占用的存储单元不释放，在下一次调用该函数时，该变量会保留上一次函数调用结束时的值。

使用static定义外部变量
有时在程序设计中希望某些外部变量只限于被本文件引用，而不能被其他文件引用。这时可以在定义外部变量时加一个static声明。

【代码示例】

#include <stdio.h>
int d = 3;/*全局变量默认为静态存储方式，在函数中的值每次都会被保留*/
int fun(int a){
	auto int b = 3;/*局部变量作为自动变量每次的函数运行值会在函数调用结束后释放*/
	static int c = 3;/*静态局部变量存储方式为静态存储，在函数中的值每次都会被保留*/
	b = b + 1;
	c = c + 1;
	d = d + 1;
	printf("b的值为%d\n",b);
	printf("c的值为%d\n",c);
	printf("d的值为%d\n",d);
	return a + b + c + d;
}
int main(){
	int a = 3;
	int result;
	for(int i = 1; i<4; i++){
		result = fun(a);
		printf("a+b+c+d的第%d次和的值为%d\n",i,result);
	}
	return 0;	
}

输出结果为：

b的值为4
c的值为4
d的值为4
a+b+c+d的第1次和的值为15
b的值为4
c的值为5
d的值为5
a+b+c+d的第2次和的值为17
b的值为4
c的值为6
d的值为6
a+b+c+d的第3次和的值为19
关于b： 局部变量作为自动变量每次的函数运行值会在函数调用结束后释放，所以每次调用函数时，b的取值都是从3开始
关于c： 静态局部变量存储方式为静态存储，在函数中的值每次都会被保留，所以第一次函数调用结束后，c的值变为4，此值会被保留，故而在第二次调用时，c的初值为4，调用结束后c的值变为5，c=5的取值为第三次调用时的初值，三次调用后c的值为6。
关于d： 全局变量默认为静态存储方式，在函数中的值每次都会被保留, 其结果分析同c

【注：】如果初始化后，变量只被引用而不改变其值，则这时用静态局部变量比较方便，以免每次调用时重新赋值。 但是应该看到，用静态存储要多占内存，而且降低了程序的可读性，当调用次数多时往往弄不清静态局部变量的当前值是什么。因此，如不必要，不要多用静态局部变量。

【代码示例：】使用静态局部变量求n的阶乘。

#include <stdio.h>
#include <time.h>
clock_t start1, stop1,start2, stop2;
double duration1, duration2;
int fac(int n){
	static int f = 1;
	f = f*n;
	printf("f的值为：%d\n",f);
	return f;
}
int fac1(int n){
	if(n <= 1){
		return 1;
	}else{
		return n * fac1(n-1);
	}
}
int main(){
	int i;
	int n = 5;
	int res,res1;
	
	start1 = clock();
	for(i = 1; i<=n;i++){
		res = fac(i);	
	}
	stop1 = clock();/*捕捉从程序开始运行到clock()被调用时所耗费的时间。这个时间单位是clock tick(时钟打点)*/
	duration1 = ((double)(stop1-start1))/CLK_TCK;/*CLK_TCK是一个常数，表示机器时钟每秒所走的时钟打点数*/ 
	printf("ticks1 = %f\n", (double)(stop1-start1));
	printf("使用静态局部变量运行时间间隔为duration1 = %6.2e\n", duration1);
	
	start2 = clock();
	res1=fac1(5);
	stop2 = clock();
	duration2 = ((double)(stop2-start2))/CLK_TCK;
	printf("ticks2 = %f\n", (double)(stop2-start2));
	printf("使用递归函数运行时间间隔为duration2 = %6.2e\n", duration2);
	
	
	printf("5的阶乘为：%d\n",res);
	printf("5的阶乘为：%d\n",res1);
}

输出结果为：

f的值为：1
f的值为：2
f的值为：6
f的值为：24
f的值为：120
ticks1 = 2.000000
使用静态局部变量运行时间间隔为duration1 = 2.00e-03
ticks2 = 0.000000
使用递归函数运行时间间隔为duration2 = 0.00e+00
5的阶乘为：120
5的阶乘为：120

存储类用关键字register声明的变量

用register声明的变量称为寄存器变量。

一般情况下，变量的值是存放在内存中的。当程序中用到哪一个变量的值时，由控制器发出指令将内存中该变量的值送到CPU中的运算器。经过运算器进行运算，如果需要存数，再从运算器将数据送到内存存放。

为提高执行效率，C允许将局部变量的值放在CPU中的寄存器中，需要用时直接从寄存器取出参加运算，不必再到内存中去存取。这种变量叫做寄存器变量，用关键字register作声明。

#include <stdio.h>
#include <time.h>
clock_t start1, stop1,start2, stop2,start3, stop3;
double duration1, duration2, duration3;
int fac(int n){
	static int f = 1;
	f = f*n;
	printf("f的值为：%d\n",f);
	return f;
}
int fac1(int n){
	if(n <= 1){
		return 1;
	}else{
		return n * fac1(n-1);
	}
}
int facregister(int n)  
{  
  register int i, f=1; //定义i和f是寄存器变量  
  for(i=1;i<=n;++i){
  	f=f*i;
  }  
  return f;  
} 
int main(){
	int i;
	int n = 5;
	int res,res1,res2;
	
	start1 = clock();
	for(i = 1; i<=n;i++){
		res = fac(i);	
	}
	stop1 = clock();/*捕捉从程序开始运行到clock()被调用时所耗费的时间。这个时间单位是clock tick(时钟打点)*/
	duration1 = ((double)(stop1-start1))/CLK_TCK;/*CLK_TCK是一个常数，表示机器时钟每秒所走的时钟打点数*/ 
	printf("ticks1 = %f\n", (double)(stop1-start1));
	printf("使用静态局部变量运行时间间隔为duration1 = %6.2e\n", duration1);
	
	start2 = clock();
	res1=fac1(5);
	stop2 = clock();
	duration2 = ((double)(stop2-start2))/CLK_TCK;
	printf("ticks2 = %f\n", (double)(stop2-start2));
	printf("使用递归函数运行时间间隔为duration2 = %6.2e\n", duration2);
	
	start3 = clock();
	res2 = facregister(5);	
	stop3 = clock();/*捕捉从程序开始运行到clock()被调用时所耗费的时间。这个时间单位是clock tick(时钟打点)*/
	duration1 = ((double)(stop1-start1))/CLK_TCK;/*CLK_TCK是一个常数，表示机器时钟每秒所走的时钟打点数*/ 
	printf("ticks3 = %f\n", (double)(stop3-start3));
	printf("使用寄存器变量运行时间间隔为duration3 = %6.2e\n", duration3);
	
	printf("5的阶乘为：%d\n",res);
	printf("5的阶乘为：%d\n",res1);
	printf("5的阶乘为：%d\n",res2);
}

运行结果为：

f的值为：1
f的值为：2
f的值为：6
f的值为：24
f的值为：120
ticks1 = 5.000000
使用静态局部变量运行时间间隔为duration1 = 5.00e-03
ticks2 = 0.000000
使用递归函数运行时间间隔为duration2 = 0.00e+00
ticks3 = 0.000000
使用寄存器变量运行时间间隔为duration3 = 0.00e+00
5的阶乘为：120
5的阶乘为：120
5的阶乘为：120

在程序中定义寄存器变量对编译系统只是建议性(而不是强制性)的。当今的优化编译系统能够识别使用频繁的变量，自动地将这些变量放在寄存器中。

存储类用关键字extern声明的变量

全局变量(外部变量)是在函数的外部定义的，它的作用域为从变量的定义处开始，到本程序文件的末尾。在此作用域内，全局变量可以为本文件中各个函数所引用。编译时将全局变量分配在静态存储区。

有时需要用关键字extern来声明全局变量，以扩展全局变量的作用域。主要有以下几种情况：

1) 在一个文件内声明全局变量

如果外部变量不在文件的开头定义，其有效的作用范围只限于定义处到文件终了。如果在定义点之前的函数想引用该全局变量，则应该在引用之前用关键字extern对该变量作外部变量声明，表示该变量是一个将在下面定义的全局变量。有了此声明，就可以从声明处起，合法地引用该全局变量，这种声明称为提前引用声明。
2) 在多文件的程序中声明外部变量

如果一个程序包含两个文件，在两个文件中都要用到同一个外部变量num，不能分别在两个文件中各自定义一个外部变量num。正确的做法是：在任一个文件中定义外部变量num，而在另一文件中用extern对num作外部变量声明。即

extern int num;

用extern扩展全局变量的作用域，虽然能为程序设计带来方便，但应十分慎重，因为在执行一个文件中的函数时，可能会改变了该全局变量的值，从而会影响到另一文件中的函数执行结果。

参考文献

1. https://www.runoob.com/cprogramming/c-tutorial.html
2. https://www.cnblogs.com/bhlr/p/6689734.html

附录

汇编语言

汇编语言是面向机器的程序设计语言。在汇编语言中，用助记符(Memoni)代替操作码，用地址符号(Symbol)或标号(Label)代替地址码。在不同的设备中，汇编语言对应着不同的机器语言指令集，通过汇编过程转换成机器指令。普遍地说，特定的汇编语言和特定的机器语言指令集是一一对应的不同平台之间不可直接移植。汇编语言是一种用于电子计算机、微处理器、微控制器或其他可编程器件的低级语言。在今天的实际应用中，它通常被应用在底层，硬件操作和高要求的程序优化的场合。驱动程序、嵌入式操作系统和实时运行程序都需要汇编语言。

主要特点

1. 汇编是一种面向机器的低级语言，通常是为特定的计算机或系列计算机专门设计的。汇编语言是面向具体机型的，它离不开具体计算机的指令系统，因此，对于不同型号计算机，有着不同的结构的汇编语言，而且，对于同一问题所编制的汇编语言程序在不同种类的计算机间是互不相通的。
2. 保持了机器语言的优点。具有直接和简捷的特点。汇编语言由于采用了助记符号来编写程序，比用机器预言的二进制代码编程要方便些，在一定程度上简化了编程过程，汇编语言的特点是用符号代替了机器指令代码，而且助记符与指令代码一一对应，基本保留了机器语言的灵活性。
3. 可有效地访问、控制计算机的各种硬件设备，如磁盘、存储器、CPU、I/O端口等
4. 用汇编语言编制的程序输入计算机，计算机不能像用机器语言编写的程序一样直接识别和执行，必须通过预先放入计算机的“汇编程序”中进行加工和编译，才能变成能够被计算机直接识别和处理的二进制代码程序。
5. 目标代码简短，占用内存少，执行速度快，是高效的程序设计语言。
6. 经常与高级语言配合使用。

缺点

汇编语言是一种层次非常低的语言，它仅仅高于直接手工编写二进制的机器指令码，因此不可避免的存在一些缺点：

1. 编写的代码难懂，不好维护。
2. 容易产生bug，难以调试。
3. 只能针对特定的体系结构和处理器进行优化。
4. 开发效率低，时间长且单调。

参考文献： https://baike.so.com/doc/5261296-5494926.html#refff_5261296-5494926-1