【Linux操作系统】GCC编译与静态库、动态库制作详解

旧城等待， 2024-03-23 18:09 61阅读 0赞

> GCC是一款广泛使用的开源编译器，它支持多种编程语言，并且具有强大的编译能力。在软件开发中，我们经常需要将代码编译成可执行文件或者库文件。本文将详细介绍GCC编译过程以及如何制作静态库和动态库。  
> ![在这里插入图片描述][ed4c4c76039a44419d98d3428d4ada65.png]

#### 文章目录 ####

*   *  一、GCC编译过程
     *   *  1. 预处理阶段
         *  2. 编译阶段
         *  3. 汇编阶段
         *  4. 链接阶段
     *  二、静态库制作
     *   *  1. 静态库制作
         *  2. 使用静态库
         *  补充：头文件对应
     *  三、动态库制作
     *   *  1. 动态库制作
         *  2. 使用动态库
         *  补充：动态库加载错误及解决方法
     *  四、总结
 *  补充：gcc使用技巧

### 一、GCC编译过程 ###

GCC编译过程主要分为四个阶段：***预处理、编译、汇编和链接***。下面我们将逐一介绍每个阶段的作用。  
![在这里插入图片描述][b400b3a792f1497699f151b9ece56ccb.png]

#### 1. 预处理阶段 ####

预处理阶段主要是对源代码进行宏展开、头文件包含、条件编译等预处理操作。预处理器会根据源文件中的预处理指令，生成一个新的文件，通常以.i作为扩展名。

**示例代码：**

// main.c
    #include <stdio.h>
    
    #define PI 3.1415926
    
    int main() {
        
        printf("PI = %f\n", PI);
        return 0;
    }

**预处理后的代码：**

// main.i
    # 1 "main.c"
    # 1 "<built-in>"
    # 1 "<command-line>"
    # 1 "main.c"
    # 1 "/usr/include/stdio.h" 1 3 4
    # 27 "/usr/include/stdio.h" 3 4
    ...

#### 2. 编译阶段 ####

编译阶段将预处理后的代码转换成汇编代码，即将高级语言代码翻译成汇编语言代码。编译器会检查语法错误、类型错误等，并生成一个汇编文件，通常以.s作为扩展名。

**示例代码：**

// main.i
    # 1 "main.c"
    ...
    int main() {
        
        printf("PI = %f\n", PI);
        return 0;
    }

**编译后的汇编代码：**

// main.s
        .file "main.c"
        .section    .rodata
    .LC0:
        .string "PI = %f\n"
        .text
    .globl main
        .type   main, @function
    main:
        pushq   %rbp
        movq    %rsp, %rbp
        subq    $16, %rsp
        movsd   .LC0(%rip), %xmm0
        movl    $1, %eax
        movl    $.LC1, %edi
        movl    $0, %eax
        call    printf
        movl    $0, %eax
        leave
        ret
        .size   main, .-main
        .section    .rodata
    .LC1:
        .string "PI = %f\n"
        .text
        .section    .note.GNU-stack,"",@progbits

#### 3. 汇编阶段 ####

汇编阶段将汇编代码转换成机器代码。汇编器会将汇编代码转换成二进制指令，生成一个目标文件，通常以.o作为扩展名。

**示例代码：**

// main.s
        .file "main.c"
    ...

**汇编后的目标文件：**

// main.o
    ...

#### 4. 链接阶段 ####

链接阶段将目标文件与所需的库文件进行链接，生成最终的可执行文件。链接器会解析目标文件中的符号引用，并将其与库文件中的符号定义进行匹配。

**示例代码：**

// main.o
    ...

**链接后的可执行文件：**

// main
    ...

### 二、静态库制作 ###

好的，下面我将给出一个更详细的例子来说明如何制作和使用静态库。

#### 1. 静态库制作 ####

首先，我们需要创建两个源文件add.c和sub.c，分别实现加法和减法的功能。

**add.c：**

int add(int a, int b) {
        
        return a + b;
    }

**sub.c：**

int sub(int a, int b) {
        
        return a - b;
    }

然后，我们使用gcc命令将这两个源文件编译成目标文件。

$ gcc -c add.c sub.c

生成add.o和sub.o文件。

接下来，我们使用ar命令将目标文件打包成一个静态库文件libmath.a。

$ ar rcs libmath.a add.o sub.o

这一步完之后你的目录里会包含  
`add.c` /`sub.c` /`add.o` /`sub.o` /`libmath.a`

#### 2. 使用静态库 ####

现在我们已经制作好了一个静态库libmath.a，接下来我们将使用这个静态库。

首先，我们创建一个main.c文件，调用静态库中的函数。

**main.c：**

#include <stdio.h>
    
    extern int add(int a, int b);
    extern int sub(int a, int b);
    
    int main() {
        
        int a = 10;
        int b = 5;
        
        int sum = add(a, b);
        int difference = sub(a, b);
        
        printf("Sum: %d\n", sum);
        printf("Difference: %d\n", difference);
        
        return 0;
    }

要进行声明函数，要不系统会默认隐形声明，容易导致错误。

然后，我们使用gcc命令将main.c文件与静态库链接起来生成可执行文件。

$ gcc main.c -L. -lmath -o main

最后，我们运行可执行文件main。

$ ./main

输出结果：

Sum: 15
    Difference: 5

#### 补充：头文件对应 ####

假设我们有一个名为`example`的静态库，其中包含了一个函数`void print_hello()`。为了使用这个函数，我们需要有一个头文件`example.h`，其中包含了函数的声明。

**example.h：**

#ifndef EXAMPLE_H
    #define EXAMPLE_H
    
    void print_hello();
    
    #endif

在使用这个静态库的源文件中，我们需要包含`example.h`头文件，并调用其中的函数。

**main.c：**

#include <stdio.h>
    #include "example.h"
    
    int main() {
        
        printf("Hello, world!\n");
        print_hello();
        return 0;
    }

在编译时，我们需要指定静态库文件的搜索路径和要链接的库文件。假设`libexample.a`是我们的静态库文件，可以使用以下命令进行编译：

gcc -o program main.c -L/path/to/library -lexample

其中`-L/path/to/library`指定了静态库文件的搜索路径，`-lexample`指定要链接的静态库。

总结一下：首先，我们需要将多个目标文件打包成一个静态库文件，然后在编译时指定静态库的路径和名称。最后，我们可以通过调用静态库中的函数来使用其中的功能。希望这个例子能够帮助你更好地理解静态库的制作和使用过程。

### 三、动态库制作 ###

动态库是在程序运行时被加载的库文件，它可以被多个程序共享使用，减少了内存的占用。

#### 1. 动态库制作 ####

首先，我们需要创建两个源文件add.c和sub.c，分别实现加法和减法的功能。

**add.c：**

int add(int a, int b) {
        
        return a + b;
    }

**sub.c：**

int sub(int a, int b) {
        
        return a - b;
    }

然后，我们使用gcc命令将这两个源文件编译成目标文件，并使用-fPIC选项生成位置无关的代码。

$ gcc -c -fPIC add.c sub.c

同样生成add.o和sub.o文件。

接下来，我们使用gcc命令将目标文件打包成一个动态库文件libmath.so。

$ gcc -shared -o libmath.so add.o sub.o

#### 2. 使用动态库 ####

现在我们已经制作好了一个动态库libmath.so，接下来我们将使用这个动态库。

首先，我们创建一个main.c文件，调用动态库中的函数。

**main.c：**

#include <stdio.h>
    #include <dlfcn.h>
    
    int main() {
        
        void* handle = dlopen("./libmath.so", RTLD_LAZY);
        if (!handle) {
        
            fprintf(stderr, "Failed to open library: %s\n", dlerror());
            return 1;
        }
    
        int (*add)(int, int) = dlsym(handle, "add");
        int (*sub)(int, int) = dlsym(handle, "sub");
    
        int a = 10;
        int b = 5;
    
        int sum = add(a, b);
        int difference = sub(a, b);
    
        printf("Sum: %d\n", sum);
        printf("Difference: %d\n", difference);
    
        dlclose(handle);
    
        return 0;
    }
    /*
    首先，在main函数中，我们声明了一个void指针变量handle，用于存储打开动态库后返回的句柄。然后，我们使用dlopen函数打开动态库文件libmath.so，指定RTLD_LAZY标志表示在需要时才解析符号。如果打开动态库失败，我们使用dlerror函数获取错误信息并打印到stderr流上，然后返回1表示出错。
    
    接下来，我们使用dlsym函数获取动态库中的函数指针。dlsym函数的第一个参数是动态库的句柄，第二个参数是要获取的函数名。我们使用函数指针的方式来声明和初始化两个函数指针变量add和sub，分别指向动态库中的add函数和sub函数。
    
    然后，我们定义了两个整型变量a和b，并分别赋值为10和5。
    
    接下来，我们通过调用函数指针变量add和sub来调用动态库中的函数，得到加法和减法的结果，并分别赋值给sum和difference变量。
    
    最后，我们使用dlclose函数关闭动态库句柄，释放资源。
    
    
    */

然后，我们使用gcc命令将main.c文件与动态库链接起来生成可执行文件，并指定动态库的路径和名称。

$ gcc main.c -L. -ldl -o main

最后，我们运行可执行文件main。

$ ./main

输出结果：

Sum: 15
    Difference: 5

总结一下：首先，我们需要将多个目标文件编译成位置无关的代码，并使用gcc命令将它们打包成一个动态库文件。然后，在使用动态库的程序中，我们需要使用dlopen函数打开动态库，并使用dlsym函数获取动态库中的函数指针。最后，我们可以通过调用动态库中的函数来使用其中的功能。

#### 补充：动态库加载错误及解决方法 ####

如果动态库路径错误，可以按照以下方法解决：

1.  检查动态库文件的路径是否正确：确保指定的路径是动态库文件所在的准确路径。
2.  使用绝对路径或相对路径：可以使用绝对路径来指定动态库的路径，例如`/path/to/library/libexample.so`。或者，使用相对路径来指定动态库的路径，相对路径是相对于当前工作目录的路径，例如`./libexample.so`。
3.  设置LD\_LIBRARY\_PATH环境变量：可以通过设置LD\_LIBRARY\_PATH环境变量来指定动态库的搜索路径。例如，如果动态库文件在`/path/to/library`目录中，可以执行以下命令：
    
        export LD_LIBRARY_PATH=/path/to/library:$LD_LIBRARY_PATH
    
    这将把`/path/to/library`添加到动态库的搜索路径中。
4.  使用rpath选项：可以在链接时使用-rpath选项来指定动态库的搜索路径。例如，使用以下命令来编译和链接程序：
    
        gcc -o program main.c -L/path/to/library -Wl,-rpath=/path/to/library -lexample
    
    这将在程序中设置动态库的搜索路径为`/path/to/library`。

通过以上方法，您可以解决动态库路径错误的问题。请注意，在使用LD\_LIBRARY\_PATH环境变量或rpath选项时，确保指定的路径是正确的，并且动态库文件存在于该路径中。

### 四、总结 ###

本文详细介绍了GCC编译过程以及如何制作静态库和动态库。通过预处理、编译、汇编和链接四个阶段，我们可以将源代码转换成可执行文件或者库文件。静态库将多个目标文件打包成一个文件，程序在编译时会将静态库的代码复制到可执行文件中；而动态库是在程序运行时被加载的库文件，它可以被多个程序共享使用，减少了内存的占用。  
内容补充：

--------------------

## 补充：gcc使用技巧 ##

gcc是GNU Compiler Collection（GNU编译器套件）的缩写，是一个广泛使用的编程语言编译器。它支持多种编程语言，包括C、C++、Objective-C、Fortran、Ada和Go等。下面是gcc的常用参数和其作用的简要说明：

*  `-c`：只编译源文件，生成目标文件（.o文件），不进行链接操作。
 *  `-o`：指定输出文件的名称。
 *  `-I`：指定头文件的搜索路径。
 *  `-L`：指定库文件的搜索路径。
 *  `-l`：链接时使用的库文件。
 *  `-g`：生成调试信息，用于调试程序。
 *  `-Wall`：开启所有警告信息。
 *  `-Werror`：将警告视为错误。
 *  `-std`：指定使用的C或C++标准。
 *  `-O`：优化级别，包括`-O0`（无优化）、`-O1`（基本优化）、`-O2`（更多优化）和`-O3`（最大优化）等。
 *  `-shared`：生成一个共享库文件（动态库）。
 *  `-fPIC`：生成位置无关的代码，用于生成动态库。
 *  `-pthread`：链接多线程库。

[ed4c4c76039a44419d98d3428d4ada65.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/da7b89e6af5746a783f5c5d9faf0caa7.png
[b400b3a792f1497699f151b9ece56ccb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/ef7b01c54bb744dfa59d5cff0f24ebf9.png