Linux系统中关于gcc的基础练习

Linux系统中关于gcc的基础练习。

一.用 gcc 生成 .a 静态库和 .so 动态库

我们通常把一些公用函数制作成函数库，供其它程序使用。函数库分为静态库和动态库两种。 静态库在程序编译时会被连接到目标代码中，程序运行时将不再需要该静态库。动态库在程 序编译时并不会被连接到目标代码中，而是在程序运行是才被载入，因此在程序运行时还需 要动态库存在。 本部分主要通过举例来说明在 Linux 中如何创建静态库和动态库，以及使用它们。

在创建函数库前，我们先来准备举例用的源程序，并将函数库的源程序编译成.o 文件。

1.第 1 步：编辑生成例子程序 hello.h、hello.c 和 main.c。

先创建一个作业目录，保存本次练习的文件。

mkdir test1 
cd test1

然后用 vim、nano 或 gedit 等文本编辑器编辑生成所需要的 3 个文件。此处笔者用的是vim。hello.c(见程序 2)是函数库的源程序，其中包含公用函数 hello，该函数将在屏幕上输出"Hello XXX!"。hello.h(见程序 1)为该函数库的头文件。main.c(见程序 3)为测试库文件的主程序， 在主程序中调用了公用函数 hello。

程序1：

#ifndef HELLO_H 
#define HELLO_H 
void hello(const char *name); 
#endif //HELLO_H

程序2：

#include <stdio.h> 
void hello(const char *name) 
{
printf("Hello %s!\n", name); 
}

程序3：

#include "hello.h" 
int main() 
{
hello("everyone"); 
return 0; 
}

2. 第 2 步：将 hello.c 编译成.o 文件。

无论静态库，还是动态库，都是由.o 文件创建的。因此，我们必须将源程序 hello.c 通过 g cc 先编译成.o 文件。在系统提示符下键入以下命令得到 hello.o 文件。

gcc -c hello.c

我们运行 ls 命令看看是否生存了 hello.o 文件。
在 ls 命令结果中，我们看到了 hello.o 文件，本步操作完成。 下面我们先来看看如何创建静态库，以及使用它。

3.第 3 步：由.o 文件创建静态库。

静态库文件名的命名规范是以 lib 为前缀，紧接着跟静态库名，扩展名为.a。例如：我们将 创建的静态库名为 myhello，则静态库文件名就是 libmyhello.a。在创建和使用静态库时， 需要注意这点。创建静态库用 ar 命令。在系统提示符下键入以下命令将创建静态库文件 libmyhello.a。

ar -crv libmyhello.a hello.o

我们同样运行 ls 命令查看结果：

ls 命令结果中有 libmyhello.a。

4.第 4 步：在程序中使用静态库。

静态库制作完了，如何使用它内部的函数呢？只需要在使用到这些公用函数的源程序中包 含这些公用函数的原型声明，然后在用 gcc 命令生成目标文件时指明静态库名，gcc 将会从 静态库中将公用函数连接到目标文件中。注意，gcc 会在静态库名前加上前缀 lib，然后追 加扩展名.a 得到的静态库文件名来查找静态库文件。
在程序 3:main.c 中，我们包含了静态库的头文件 hello.h，然后在主程序 main 中直接调用 公用函数 hello。下面先生成目标程序 hello，然后运行 hello 程序看看结果如何。

方法一：

gcc -o hello main.c -L. –lmyhello

自定义的库时，main.c 还可放在-L.和 –lmyhello 之间，但是不能放在它俩之后，否则会提 示 myhello 没定义，但是是系统的库时，如 g++ -o main（-L/usr/lib） -lpthread main.cpp 就不出错。

方法二：

gcc main.c libmyhello.a -o hello

方法三：
先生成 main.o：

gcc -c main.c

再生成可执行文件：

gcc -o hello main.o libmyhello.a

动态库连接时也可以这样做。

运行 hello 程序

我们删除静态库文件试试公用函数 hello 是否真的连接到目标文件 hello 中了。

程序照常运行，静态库中的公用函数已经连接到目标文件中了。 我们继续看看如何在 Linux 中创建动态库。我们还是从.o 文件开始。

5.第 5 步：由.o 文件创建动态库文件。

动态库文件名命名规范和静态库文件名命名规范类似，也是在动态库名增加前缀 lib，但其 文件扩展名为.so。例如：我们将创建的动态库名为 myhello，则动态库文件名就是 libmyh ello.so。用 gcc 来创建动态库。 在系统提示符下键入以下命令得到动态库文件 libmyhello.so。

gcc -shared -fPIC -o libmyhello.so hello.o （-o 不可少）

我们照样使用 ls 命令看看动态库文件是否生成。

如果系统是AMD64位的，则需要在编译生成.o文件的时候在-c 的后面添加 -fPIC

6.第 6 步：在程序中使用动态库。

在程序中使用动态库和使用静态库完全一样，也是在使用到这些公用函数的源程序中包含 这些公用函数的原型声明，然后在用 gcc 命令生成目标文件时指明动态库名进行编译。我 们先运行 gcc 命令生成目标文件，再运行它看看结果。

gcc -o hello main.c -L. -lmyhello

或

gcc main.c libmyhello.so -o hello

运行结果如下

此时出现报错，是因为找不到动态库文件 libmyhello.so。程序在运行时， 会在/usr/lib 和/lib 等目录中查找需要的动态库文件。若找到，则载入动态库，否则将提示类似上述错误而终止程序运行。我们将文件 libmyhello.so 复制到目录/usr/lib 中。

sudo mv libmyhello.so /usr/lib

再次运行程序，结果如下：

二.静态库.a与动态库.so文件的生成与使用

1.从test1目录返回上层之后创建一个作业目录，保存本次练习的文件。

返回命令

cd ..

创建test2目录

然后用 vim、nano 或 gedit 等文本编辑器编辑生成所需要的四个文件 A1.c 、 A2.c、 A.h、 test.c 。
A1.c:

#include <stdio.h> 
void print1(int arg)
{ printf("A1 print arg:%d\n",arg); 
}

A2.c：

#include<stdio.h>
void print2(char *arg)
{
printf("A2 printf arg:%s\n",arg);
}

A.h：

#ifndef A_H
#define A_H
void print1(int);
void print2(char *);
#endif

test.c:

#include<stdlib.h>
#include "A.h"
int main()
{
print1(1);
print2("test");
exit(0);
}

2.静态库.a 文件的生成与使用。

2.1、生成目标文件

gcc -c A1.c A2.c

2.2、生成静态库.a 文件

ar crv libafile.a A1.o A2.o

2.3使用.a 库文件，创建可执行程序（若采用此种方式，需保证生成的.a 文件与.c 文件保 存在同一目录下，即都在当前目录下）

gcc -o test test.c libafile.a

3、共享库.so 文件的生成与使用。

3.1生成目标文件(xxx.o（) 此处生成.o 文件必须添加"-fpic"(小模式，代码少)，否则在生成.so 文件时会出错）

 gcc -c -fpic A1.c A2.c

3.2 生成共享库.so 文件

gcc -shared *.o -o libsofile.so

3.3使用.so 库文件，创建可执行程序

biwengtao@ubuntu:~/test2$ gcc -o test test.c libsofile.so
biwengtao@ubuntu:~/test2$ ./test
./test: error while loading shared libraries: libsofile.so: cannot open shared object file: No such file or directory

发现出现错误
运行 ldd test，查看链接情况：

biwengtao@ubuntu:~/test2$ ldd test
        linux-vdso.so.1 =>  (0x00007fff41ff9000)
        libsofile.so => not found
        libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f1ebcdd6000)
        /lib64/ld-linux-x86-64.so.2 (0x00007f1ebd1a0000)

发现确实是找不到对应的.so 文件。 这是由于 linux 自身系统设定的相应的设置的原因，即其只在/lib and /usr/lib 下搜索对应 的.so 文件，故需将对应 so 文件拷贝到对应路径。

sudo cp libsofile.so /usr/lib

再次执行./test，即可成功运行。
同时可直接使用 gcc -o test test.c -L. -lname，来使用相应库文件
其中，-L.：表示在当前目录下，可自行定义路径 path，即使用-Lpath 即可。
－lname：name:即对应库文件的名字(除开 lib)，即若使用 libafile.a，则 name 为 afile； 若要使用 libsofile.so，则 name 为 sofile)

三.通过上述操作进行对 .a 静态库和 .so 动态库生产及使用的练习。

1.在以前的程序代码基础上除x2x函数外再扩展写一个x2y函数。main函数代码将调用x2x和x2y ；将这3个函数分别写成单独的3个 .c文件。

sub1.c

sub2.c

main.c

#include<stdio.h>
#include"main.h"
void main()
{
        int a=8,b=4;
        printf("%d\n",x2x(a,b));
        printf("%d\n",x2y(a,b));
}

main.h

#ifndef MATN_H
#define MAIN_H
float x2x(int a,int b);
float x2y(int a,int b);
#endif

2.用gcc分别编译为3个.o 目标文件。

gcc -c sub1.c sub2.c

3.将x2x、x2y目标文件用 ar工具生成1个 .a 静态库文件。

4.用 gcc将 main函数的目标文件与此静态库文件进行链接，生成最终的可执行程序。

gcc -o main main.c libsub.a

四.Linux GCC 常用命令。

1、简介

GCC 的意思也只是 GNU C Compiler 而已。经过了这么多年的发展，GCC 已经不仅仅能支持 C 语言；它现在还支持 Ada 语言、C++ 语言、Java 语言、Objective C 语言、Pascal 语言、COBOL 语言，以及支持函数式编程和逻辑编程的 Mercury 语言，等等。而 GCC 也不再单只是 GNU C 语 言编译器的意思了，而是变成了 GNU Compiler Collection 也即是 GNU 编译器家族的意思了。另 一方面，说到 GCC 对于操作系统平台及硬件平台支持，概括起来就是一句话：无所不在。

2、简单编译。

示例如下。

//test.c 
#include <stdio.h> 
int main(void) 
{
printf("Hello World!\n"); 
return 0; 
}

这个程序，一步到位的编译指令是:

gcc test.c -o test

实质上，上述编译过程是分为四个阶段进行的，即预处理(也称预编译，Preprocessing)、编译 (Compilation)、汇编 (Assembly)和连接(Linking)。

2.1预处理

gcc -E test.c -o test.i 或 gcc -E test.c

可以输出 test.i 文件中存放着 test.c 经预处理之后的代码。打开 test.i 文件，看一看，就明白了。后 面那条指令，是直接在命令行窗口中输出预处理后的代码.
gcc 的-E 选项，可以让编译器在预处理后停止，并输出预处理结果。在本例中，预处理结果就是将 stdio.h 文件中的内容插入到 test.c 中了。

2.2 编译为汇编代码(Compilation)

预处理之后，可直接对生成的 test.i 文件编译，生成汇编代码：

gcc -S test.i -o test.s

gcc 的-S 选项，表示在程序编译期间，在生成汇编代码后，停止，-o 输出汇编代码文件。

2.3 汇编(Assembly）

对于上一小节中生成的汇编代码文件 test.s，gas 汇编器负责将其编译为目标文件，如下：

gcc -c test.s -o test.o

2.4 连接(Linking）

gcc 连接器是 gas 提供的，负责将程序的目标文件与所需的所有附加的目标文件连接起来，最终生 成可执行文件。附加的目标文件包括静态连接库和动态连接库。
对于上一小节中生成的 test.o，将其与Ｃ标准输入输出库进行连接，最终生成程序 test

gcc test.o -o test

3、多个程序文件的编译

通常整个程序是由多个源文件组成的，相应地也就形成了多个编译单元，使用 GCC 能够很好地管理 这些编译单元。假设有一个由 test1.c 和 test2.c 两个源文件组成的程序，为了对它们进行编译，并 最终生成可执行程序 test，可以使用下面这条命令：

gcc test1.c test2.c -o test

如果同时处理的文件不止一个，GCC 仍然会按照预处理、编译和链接的过程依次进行。如果深究起 来，上面这条命令大致相当于依次执行如下三条命令：

gcc -c test1.c -o test1.o 
gcc -c test2.c -o test2.o 
gcc test1.o test2.o -o test

4、检错

gcc -pedantic illcode.c -o illcode

-pedantic 编译选项并不能保证被编译程序与 ANSI/ISO C 标准的完全兼容，它仅仅只能用来帮助 Linux 程序员离这个目标越来越近。或者换句话说，-pedantic 选项能够帮助程序员发现一些不符合 ANSI/ISO C 标准的代码，但不是全部，事实上只有 ANSI/ISO C 语言标准中要求进行编译器诊断的 那些情况，才有可能被 GCC 发现并提出警告。
除了-pedantic 之外，GCC 还有一些其它编译选项也能够产生有用的警告信息。这些选项大多以-W 开头，其中最有价值的当数-Wall 了，使用它能够使 GCC 产生尽可能多的警告信息。

gcc -Wall illcode.c -o illcode

GCC 给出的警告信息虽然从严格意义上说不能算作错误，但却很可能成为错误的栖身之所。一个优 秀的 Linux 程序员应该尽量避免产生警告信息，使自己的代码始终保持标准、健壮的特性。所以将 警告信息当成编码错误来对待，是一种值得赞扬的行为！所以，在编译程序时带上-Werror 选项，那 么 GCC 会在所有产生警告的地方停止编译，迫使程序员对自己的代码进行修改，如下：

gcc -Werror test.c -o test

5 库文件连接

开发软件时，完全不使用第三方函数库的情况是比较少见的，通常来讲都需要借助许多函数库的支 持才能够完成相应的功能。从程序员的角度看，函数库实际上就是一些头文件（.h）和库文件（so、或 lib、dll）的集合。虽然 Linux 下的大多数函数都默认将头文件放到/usr/include/目录下，而库文 件则放到/usr/lib/目录下；Windows 所使用的库文件主要放在 Visual Stido 的目录下的 include 和 lib， 以及系统文件夹下。但也有的时候，我们要用的库不再这些目录下，所以 GCC 在编译时必须用自己 的办法来查找所需要的头文件和库文件。 例如我们的程序 test.c 是在 linux 上使用 c 连接 mysql，这个时候我们需要去 mysql 官网下载 MySQL Connectors 的 C 库，下载下来解压之后，有一个 include 文件夹，里面包含 mysql connectors 的头 文件，还有一个 lib 文件夹，里面包含二进制 so 文件 libmysqlclient.so 其中 inclulde 文件夹的路径是/usr/dev/mysql/include,lib 文件夹是/usr/dev/mysql/lib。

5.1 编译成可执行文件

首先我们要进行编译 test.c 为目标文件，这个时候需要执行

gcc –c –I /usr/dev/mysql/include test.c –o test.o

5.2 链接

最后我们把所有目标文件链接成可执行文件:

gcc –L /usr/dev/mysql/lib –lmysqlclient test.o –o test

Linux 下的库文件分为两大类分别是动态链接库（通常以.so 结尾）和静态链接库（通常以.a 结尾）， 二者的区别仅在于程序执行时所需的代码是在运行时动态加载的，还是在编译时静态加载的。

5.3 强制链接时使用静态链接库

默认情况下， GCC 在链接时优先使用动态链接库，只有当动态链接库不存在时才考虑使用静态链 接库，如果需要的话可以在编译时加上-static 选项，强制使用静态链接库。
在/usr/dev/mysql/lib 目录下有链接时所需要的库文件 libmysqlclient.so 和 libmysqlclient.a，为了让 GCC 在链接时只用到静态链接库，可以使用下面的命令:

gcc –L /usr/dev/mysql/lib –static –lmysqlclient test.o –o test

6.二进制程序处理工具

(1) addr2line：用 来将程序 地址转 换成其所 对应的程 序源文 件及所对 应的代 码 行，也可以得到所对应的函数。该工具将帮助调试器在调试的过程中定位对 应的源代码位置。
(2) as：主要用于汇编，有关汇编的详细介绍请参见后文。
(3) ld：主要用于链接，有关链接的详细介绍请参见后文。
(4) ar：主要用于创建静态库。为了便于初学者理解，在此介绍动态库与静态库 的概念：
如果 要将 多个 .o 目标 文件 生成 一个 库文 件， 则存 在两 种类 型的库，一种是静态库，另一种是动态库。
在 windows 中 静态 库是 以 .lib 为 后缀 的文 件 ，共 享库 是以 .dll 为 后缀 的 文 件 。 在 linux 中 静 态 库 是 以 .a 为 后 缀 的 文 件 ， 共 享 库 是 以 .so 为 后 缀 的文件。
静 态 库 和 动 态 库 的 不 同 点 在 于 代 码 被 载 入 的 时 刻 不 同 。 静 态 库 的 代 码 在 编 译 过 程 中 已 经 被 载 入 可 执 行 程 序 ， 因 此 体 积 较 大 。 共 享 库 的 代 码 是 在 可 执 行 程 序 运 行 时 才 载 入 内 存 的 ， 在 编 译 过 程 中 仅 简 单 的 引 用 ， 因 此 代 码 体 积 较 小 。 在 Linux 系 统 中 ， 可 以 用 ldd 命 令 查 看 一 个 可 执 行 程 序 依 赖 的 共 享 库。
如 果 一 个 系 统 中 存 在 多 个 需 要 同 时 运 行 的 程 序 且 这 些 程 序 之 间 存 在 共 享 库，那么采用动态库的形式将更节省内存。
(5) ldd：可以用于查看一个可执行程序依赖的共享库。
(6) objcopy：将一种对象文件翻译成另一种格式，譬如将.bin 转换成.elf、或 者将.elf 转换成.bin 等。
(7) objdump：主要的作用是反汇编。有关反汇编的详细介绍，请参见后文。
(8) readelf：显示有关 ELF 文件的信息，请参见后文了解更多信息。
(9) size：列出可执行文件每个部分的尺寸和总尺寸，代码段、数据段、总大小 等，请参见后文了解使用 size 的具体使用实例。

五、as汇编编译器

1、简介

as汇编编译器针对的是AT&T汇编代码风格，Intel风格的汇编代码则可以用nasm汇编编译器编译生成执行程序

2、在ubuntu中下载安装nasm

  sudo apt install nasm

3、使用nasm对示例代码“hello.asm”编译生成可执行程序

3.1hello.asm

	; hello.asm
section .data            ; 数据段声明
        msg db "Hello, world!", 0xA     ; 要输出的字符串
        len equ $ - msg                 ; 字串长度
section .text            ; 代码段声明
global _start            ; 指定入口函数
_start:                  ; 在屏幕上显示一个字符串
        mov edx, len     ; 参数三：字符串长度
        mov ecx, msg     ; 参数二：要显示的字符串
        mov ebx, 1       ; 参数一：文件描述符(stdout)
        mov eax, 4       ; 系统调用号(sys_write)
        int 0x80         ; 调用内核功能
                         ; 退出程序
        mov ebx, 0       ; 参数一：退出代码
        mov eax, 1       ; 系统调用号(sys_exit)
        int 0x80         ; 调用内核功能

3.2使用nasm -f elf64 hello.asm，会生成一个hello.o文件

3.3使用ld -s -o hello hello.o ,生成一个可执行文件hello

4、与“hello world”C代码的编译生成的程序大小进行对比

nasm输出hello world生成的程序大小：

c语言输出hello world生成的程序大小：

由此可见nasm生成的程序大小比C语言小得多。

六、Linux中的第三方库函数

1、Linux 系统中终端程序最常用的光标库（curses）

1）光标库（curses）的主要函数功能

curses函数库能够优化光标的移动并最小化需要对屏幕进行的刷新，从而也减少了必须向字符终端发送的字符数目。

2)一些基本函数名称及功能

从屏幕读取：

chtype inch(void);  //返回光标位置字符
int instr(char *string);  //读取字符到string所指向的字符串中
int innstr(char *string, int numbers);//读取numbers个字符到string所指向的字符串中

清除屏幕：

int erase(void);//在屏幕的每个位置写上空白字符
int clear(void);//使用一个终端命令来清除整个屏幕，相当于vi内的Ctrl+L
//内部调用了clearok来执行清屏操作,(在下次调用refresh时可以重现屏幕原文）

int clrtobot(void);//清除光标位置到屏幕结尾的内容
int clrtoeol(void);//清除光标位置到该行行尾的内容

移动光标：

int move(int new_y, int new_x);    //移动stdcsr的光标位置
int leaveok(WINDOW *window_ptr,bool leave_flag);
//设置一个标志，用于控制在屏幕刷新后curses将物理光标放置的位置。

窗口移动和更新屏幕:

int mvwin(WINDOW *win, int new_y, int new_x);   //移动窗口
int wrefresh(WINDOW *win);
int wclear(WINDOW *win);
int werase(WINDOW *win);
//类似于上面的refresh, clear, erase，但是此时针对特定窗口操作，而不是stdcur

int touchwin(WINDOW *win);     //指定该窗口内容已改变、
//下次wrefresh时，需重绘窗口。利用该函数，安排要显示的窗口
	
int scrollok(WINDOW *win, bool flag);    //指定是否允许窗口卷屏
int scroll(WINDOW *win);   //把窗口内容上卷一行

窗口优化屏幕刷新:

int wnoutrefresh(WINDOW *window_ptr);
//The wnoutrefresh subroutine determines which parts of the terminal may need updating.
	
int doupdate(void);
//The doupdate subroutine sends to the terminal the commands to perform any required changes.

2、体验即将绝迹的远古时代的 BBS （一个用键盘光标控制的终端程序）

在 win10 系统中，“控制面板”–>“程序”—>“启用或关闭Windows功能”，启用 “telnet client” 和"适用于Linux的Windows子系统"(后面会使用)。 然后打开一个cmd命令行窗口，命令行输入 telnet bbs.newsmth.net，以游客身份体验一下即将绝迹的远古时代的 BBS （一个用键盘光标控制的终端程序）。

1)、点开控制面板

2)、点击程序

3)、点击启用或关闭Windows功能

4)、启用 “telnet client” 和"适用于Linux的Windows子系统"

5)、打开一个cmd命令行窗口

6)命令行输入 telnet bbs.newsmth.net，即可体验

3、curses库的安装

1)输入：

 sudo apt-get install libncurses5-dev

2） 头文件(比如curses.h)和库文件的安装目录

curses函数库的头文件和库文件就被分别安装在/usr/include/和/usr/lib/下

4、用gcc编译生成一个终端游戏

参考链接: 弹球游戏
首先建立一个文件，将上述连接中的程序代码复制过去，编译时使用该编译命令：gcc mysnake1.0.c -lcurses -o mysnake1.0，最后运行生成的可执行文件，便可体验到Linux中玩贪吃蛇的乐趣了。