1、由源码到可执行程序的过程
源码.c->(预处理)->预处理过的.i源文件->(编译)->汇编文件.S->(汇编)->目标文件.o->(链接)->elf可执行程序
编译链接中各种文件扩展名的含义
扩展名 | 含义 |
---|---|
.c | C语言源代码文件 |
.m | Objective-C源代码文件 |
.a | 由目标文件构成的静态库文件 |
.o | 编译后的目标文件 |
.C | CC++源代码文件 |
.out | 链接器生成的可执行文件 |
.h | 程序所包含的头文件 |
.s | 汇编语言源代码文件 后期不再进行预处理操作 |
.S | 汇编语言源代码文件,后期还会进行预处理操作,可以包含预处理指令 |
.i | 预处理过的C源代码文件 |
.ii | 预处理过的C++源代码文件 |
2、预处理的意义
3、编程中常见的预处理
4、gcc中只预处理不编译的方法
gcc xx.c -o xx
可以指定可执行程序的名称;譬如gcc xx.c -c -o xx.o
可以指定只编译不连接,也可以生成.o的目标文件。gcc -E xx.c -o xx.i
可以实现只预处理不编译。一般情况下没必要只预处理不编译,但有时候这种技巧可以用来帮助我们研究预处理过程,帮助debug程序。#define pchar char *
typedef char * PCHAR
int main(void)
{
pchar p3,P4;
PCHAR p1, p2;
return 0;
}
通过执行gcc -E preprocess.c -o preprocess.i (只预处理不编译)
得到preprocess.i
typedef char * PCHAR
int main(void)
{
char * p3,P4;
char * p1, char * p2;
return 0;
}
5、头文件包含
(1)#include <>
和 #include" "
的区别:<>专门用来包含系统提供的头文件,""用来包含自己写的头文件;更深层次来说:<>的话C语言编译器只会到系统指定目录(编译器中配置的或者操作系统配置的寻找目录,譬如在ubuntu中是/usr/include目录,编译器还允许用-I来附加指定其他的包含路径)去寻找这个头文件(隐含意思就是不会找当前目录下),如果找不到就会提示这个头文件不存在。
(2)""包含的头文件,编译器默认会先在当前目录下寻找相应的头文件,如果没找到然后再到系统指定目录去寻找,如果还没找到则提示文件不存在。
注意:规则虽然允许用双引号来包含系统指定目录,但是一般的使用原则是:如果是系统指定的自带的用<>,如果是自己写的在当前目录下放着用"",如果是自己写的但是集中放在了一起专门存放头文件的目录下将来在编译器中用-I参数来寻找,这种情况下用<>。
(3)头文件包含的真实含义就是:在#include
6、注释
在工程中注释应该注意些什么
注释的原则是有助于对程序的阅读理解,下面列举一些有关注释的注意点
7、条件编译
int a = 0;
#ifdef NUM // 如果前面有定义NUM这个符号,成立
a = 111;
printf("#ifdef NUM.\n");
#else // 如果前面没有定义NUM这个符号,则执行下面的语句
a = 222;
printf("#elif.\n");
#endif
printf("a = %d.\n", a);
int a = 0;
#if (NUM == 0) // 如果前面有定义NUM这个符号,成立
a = 111;
printf("#ifdef NUM.\n");
#else // 如果前面没有定义NUM这个符号,则执行下面的语句
a = 222;
printf("#elif.\n");
#endif
#ifdef XXX
判定条件成立与否时主要是看XXX这个符号在本语句之前有没有被定义,只要定义了这个符号就是成立的。#if (条件表达式),
它的判定标准是()中的表达式是否为true还是flase,跟C中的if语句有点像。1、宏定义的规则和使用解析
2、宏定义示例1:MAX宏,求2个数中较大的一个(带参数宏)
#define MAX(a, b) (((a)>(b)) ? (a) : (b))
3、宏定义示例2:SEC_PER_YEAR,用宏定义表示一年中有多少秒(不带参数宏)
#define SEC_PER_YEAR (365*24*60*60UL)
关键:
第一点:当一个数字直接出现在程序中时,它的是类型默认是int
第二点:一年有多少秒,这个数字刚好超过了int类型存储的范围
4、带参宏和带参函数的区别(宏定义的缺陷)
(1)宏定义是在预处理期间处理的,而函数是在编译期间处理的。这个区别带来的实质差异是:宏定义最终是在调用宏的地方把宏体原地展开,而函数是在调用函数处跳转到函数中去执行,执行完后再跳转回来。
宏定义和函数的最大差别就是:宏定义是原地展开,因此没有调用开销;而函数是跳转执行再返回,因此函数有比较大的调用开销。所以宏定义和函数相比,优势就是没有调用开销,没有传参开销,所以当函数体很短(尤其是只有一句话时)可以用宏定义来替代,这样效率高。
(2)带参宏和带参函数的一个重要差别就是:宏定义不会检查参数的类型,返回值也不会附带类型;而函数有明确的参数类型和返回值类型。当我们调用函数时编译器会帮我们做参数的静态类型检查,如果编译器发现我们实际传参和参数声明不同时会报警告或错误。
5、内联函数和inline关键字
6、宏定义来实现条件编译(#define #undef #ifdef)
(1)#ifndef ,#define和#endif
#ifndef __ARM_H_ //如果不存在ARM.h
#define __ARM_H_ //就引入ARM.h
/*。。。。。
头文件的内容
。。。。。*/
#endif //否则不引入ARM.h
(2)#if defined,#ifdef 和#if !defined, #ifndef
#if define (x)
/...code...../
#endif
#if defined
中,不管括号里面的x的逻辑是真还是假它只管这个程序的前面的宏定义里面有没有定义“x”这个宏,如果定义了x这个宏,那么编译器会编译中间的code,否则直接忽视中间的…code…代码。#if defined取反就是#if ! defined.。#ifdef x与 #ifdefined (x)用法相似。#include
#define NUM 1
int main(void)
{
int a = 0;
#ifdef NUM // 如果前面有定义NUM这个符号,成立
a = 111;
printf("#ifdef NUM.\n");
#else // 如果前面没有定义NUM这个符号,则执行下面的语句
a = 222;
printf("#elif.\n");
#endif
return 0;
}
通过gcc -E a.c -o a.i (只预处理不编译)得到a.i
int main(void)
{
int a = 0;
a = 111;
printf("#ifdef NUM.\n");
return 0;
}
(3)#ifdef与#if defined的区别
#if define(A) && define (B)
... <code> ....
#endif
表示只有A和B这两个宏定义都存在的时候才编译代码,而ifdef只能判断单个宏定义,不能判断多个复杂条件。
1、C语言为什么会有函数
2、函数书写的一般原则:
3、函数是动词、变量是名词(面相对象中分别叫方法和成员变量)
4、函数的实质是:数据处理器
1、函数三要素:定义、声明、调用
2、函数原型和作用
(1)函数原型就是函数的声明,说白了就是函数的函数名、返回值类型、参数列表。
(2)函数原型的主要作用就是给编译器提供原型,让编译器在编译程序时帮我们进行参数的静态类型检查
(3)必须明白:编译器在编译程序时是以单个源文件为单位的(所以一定要在哪里调用在哪里声明),而且编译器工作时已经经过预处理处理了,最最重要的是编译器编译文件时是按照文件中语句的先后顺序执行的。
(4)编译器从源文件的第一行开始编译,遇到函数声明时就会收到编译器的函数声明表中,然后继续向后。当遇到一个函数调用时,就在我的本文件的函数声明表中去查这个函数,看有没有原型相对应的一个函数(这个相对应的函数有且只能有一个)。如果没有或者只有部分匹配则会报错或报警告;如果发现多个则会报错或报警告(函数重复了,C语言中不允许2个函数原型完全一样,这个过程其实是在编译器遇到函数定义时完成的。所以函数可以重复声明但是不能重复定义)
#include
int add(int a, int b); // 函数声明
int main(void)
{
int a = 3, b = 5;
int sum = add(a, b); // 典型的函数调用
printf("3+5=%d.\n", add(3, 5)); // add函数的返回值作为printf函数的一个参数
return 0;
}
// 函数定义
int add(int a, int b) // 函数名、参数列表、返回值
{
return a + b; //函数体
}
1、什么是递归函数
// 用递归函数来计算阶乘
#include
int jiecheng(int n); // 函数声明
void digui(int n);
int main(void)
{
digui(300);
//int a = 5;
//printf("%d的阶乘是:%d.\n", a, jiecheng(a));
return 0;
}
// 函数定义
int jiecheng(int n)
{
// 传参错误校验
if (n < 1)
{
printf("n必须大于等于1.\n");
return -1;
}
if (n == 1)
{
return 1;
}
else
{
return (n * jiecheng(n-1));
}
}
void digui(int n)
{
int a[100];
//printf("递归前:n = %d.\n", n);
if (n > 1)
{
digui(n-1);
}
else
{
printf("结束递归,n = %d.\n", n);
}
printf("递归后:n = %d.\n", n);
}
2、函数的递归调用原理
3、使用递归函数的原则:收敛性、栈溢出
1、什么是函数库?
2、函数库的由来
3、函数库的提供形式:动态链接库与静态链接库
(1)早期的函数共享都是以源代码的形式进行的。这种方式共享是最彻底的(后来这种源码共享的方向就形成了我们现在的开源社区)。但是这种方式有它的缺点,缺点就是无法以商业化形式来发布函数库。
(2)商业公司需要将自己的有用的函数库共享给被人(当然是付费的),但是又不能给客户源代码。这时候的解决方案就是以库(主要有2种:静态库和动态库)的形式来提供。
(3)比较早出现的是静态链接库。静态库其实就是商业公司将自己的函数库源代码经过只编译不连接形成.o的目标文件,然后用ar工具将.o文件归档成.a的归档文件(.a的归档文件又叫静态链接库文件)。商业公司通过发布.a库文件和.h头文件来提供静态库给客户使用;客户拿到.a和.h文件后,通过.h头文件得知库中的库函数的原型,然后在自己的.c文件中直接调用这些库文件,在连接的时候链接器会去.a文件中拿出被调用的那个函数的编译后的.o二进制代码段链接进去形成最终的可执行程序。
(4)动态链接库比静态链接库出现的晚一些,效率更高一些,是改进型的。现在我们一般都是使用动态库。静态库在用户链接自己的可执行程序时就已经把调用的库中的函数的代码段链接进最终可执行程序中了,这样好处是可以执行,坏处是太占地方了。尤其是有多个应用程序都使用了这个库函数时,实际上在多个应用程序最后生成的可执行程序中都各自有一份这个库函数的代码段。当这些应用程序同时在内存中运行时,实际上在内存中有多个这个库函数的代码段,这完全重复了。
而动态链接库本身不将库函数的代码段链接入可执行程序,只是做个标记。然后当应用程序在内存中执行时,运行时环境发现它调用了一个动态库中的库函数时,会去加载这个动态库到内存中,然后以后不管有多少个应用程序去调用这个库中的函数都会跳转到第一次加载的地方去执行(不会重复加载)。
4、函数库中库函数的使用