C++关于编译链接方面的问题

骑猪看日落 2022-08-07 11:44 283阅读 0赞

C++关于编译链接方面的问题，包括如下：

1：什么样的函数以及变量可以定义在头文件中

2：extern "C"的作用

3：防止重复包含的宏的作用

4：函数之间是怎么链接起来的

我认为，这些问题不难，书上基本上都有，但要是没有真正思考过，就凭死记硬背，也就是只能“嘴上说说”而已，遇到问题还真棘手，所以我觉得有必要说一下。

**C/C++的编译链接过程**

其实，“编译”这个词大多数时候，我们指的是由一堆.h,.c,.cpp文件生成链接库或者可执行文件的过程。但是拿C/C++来说，其实这是很模糊的，由一堆C/C++文件生成应用程序包括**预处理---编译文件---链接**(写的比较粗糙，不影响本文论述)。

首先，要明白什么是编译单元，一个编译单元可以认为是一个.c或者.cpp文件，每一个编译单元首先会经过预处理得到一个临时的编译单元，这里称为tmp.cpp，预处理会把.c或者.cpp直接或者间接包含的其它文件(不只局限于.h文件，只要是\#include即可)的内容替换进来，并展开宏调用等。

下面首先看一个例子：

a.h

**\[html\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \#ifndef A\_H\_
2.  \#define A\_H\_
3.  
4.  static int a = 1;
5.  void fun();
6.  
7.  \#endif

#ifndef A_H_
    #define A_H_                                                                                                          
                                                                                                                          
    static int a = 1;
    void fun();                                                                                                           
    
    #endif

a.cpp

**\[cpp\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \#include "a.h"
2.  
3.  
4.  static void hello\_world()
5.  \{
6.  \}

#include "a.h"
    
    
    static void hello_world()
    {
    }

只有a.h和a.cpp这两个文件，及其简单。首先通过g++的-E参数得到a.cpp预处理之后的内容

**\[plain\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  coderchen@coderchen:~/c++$ g++ -E a.cpp > tmp.cpp

coderchen@coderchen:~/c++$ g++ -E a.cpp > tmp.cpp

查看tmp.cpp

1.  \# 1 "a.cpp"
2.  \# 1 "<built-in>"
3.  \# 1 "<command-line>"
4.  \# 1 "a.cpp"
5.  \# 1 "a.h" 1
6.  
7.  
8.  
9.  static int a = 1;
10. void fun();
11. \# 2 "a.cpp" 2
12. 
13. 
14. static void hello\_world()
15. \{
16. \}

# 1 "a.cpp"
    # 1 "<built-in>"
    # 1 "<command-line>"
    # 1 "a.cpp"
    # 1 "a.h" 1
    
    
    
    static int a = 1;
    void fun();
    # 2 "a.cpp" 2
    
    
    static void hello_world()
    {
    }

tmp.cpp就是只经过预处理得到的文件，这个文件才是编译器能够真正看到的文件。这个过程就是 **预处理。**

**其中\#define A\_H\_的作用是防止重复包含a.h这个头文件**，很多人都知道这一点，但是再仔细问，我见过大多数人都说不清楚。

**这种宏是为了防止一个编译单元(cpp文件)重复包含同一个头文件。它在预处理阶段起作用，预处理器发现a.cpp内已经定义过A\_H\_这个宏的话，在a.cpp中再次发现\#include "a.h"的时候就不会把a.h的内容替换进a.cpp了。**  
编译器看到tmp.cpp的时候，会编译成一个obj文件，最后由链接器对这一个对obj文件进行链接，从而得到可执行程序。

编译错误和连接错误

编译错误指的是一个cpp编译单元在编译时发生的错误，这种错误一般都是语法错误，拼写错误，参数不匹配等。

以main.cpp为例(只有一个main函数)

1.  int main()
2.  \{
3.  hello\_world();
4.  \}

int main()                                                                                                            
    {                                                                                                                     
      hello_world();                                                                                                      
    }

编译(加-c参数表示只编译不链接)

1.  coderchen@coderchen:~/c++$ g++ -c -o main.o main.cpp
2.  main.cpp: In function ‘int main()’:
3.  main.cpp:4: error: ‘hello\_world’ was not declared in this scope

coderchen@coderchen:~/c++$ g++ -c -o main.o main.cpp
    main.cpp: In function ‘int main()’:
    main.cpp:4: error: ‘hello_world’ was not declared in this scope

这种错误就是编译，原因是hello\_world函数未声明，把 **void hello\_world();**这条语句加到main函数前面，再次编译

1.  coderchen@coderchen:~/c++$ g++ -c -o main.o main.cpp
2.  coderchen@coderchen:~/c++$

coderchen@coderchen:~/c++$ g++ -c -o main.o main.cpp
    coderchen@coderchen:~/c++$

编译成功，虽然我们调用了hello\_world函数，却没有定义这个函数。好，接下来，我们把这个main.o文件链接下，

1.  coderchen@coderchen:~/c++$ g++ -o main main.o
2.  main.o: In function \`main':
3.  main.cpp:(.text+0x7): undefined reference to \`hello\_world()'
4.  collect2: ld returned 1 exit status

coderchen@coderchen:~/c++$ g++ -o main main.o
    main.o: In function `main':
    main.cpp:(.text+0x7): undefined reference to `hello_world()'
    collect2: ld returned 1 exit status

看到了吧，链接器ld报出了链接错误，原因是hello\_world这个函数找不到。这个例子很简单，基本上可以区分出编译错误和链接错误。我们再添加一个hello\_world.cpp

1.  void hello\_world()
2.  \{
3.  \}

void hello_world()
    { 
    }

编译

1.  coderchen@coderchen:~/c++$ g++ -c -o hello\_world.o hello\_world.cpp

coderchen@coderchen:~/c++$ g++ -c -o hello_world.o hello_world.cpp

链接

1.  coderchen@coderchen:~/c++之所以$ g++ -o main main.o hello\_world.o

coderchen@coderchen:~/c++之所以$ g++ -o main main.o hello_world.o

ok，我们的main程序已经生成了，我们经历了预处理---编译---链接的过程。

有的人说为什么不需要写一个hello\_world.h的头文件，声明hello\_world函数，然后再让main.cpp包含hello\_world.h呢？这样写自然是标准的做法，不过预处理过后，和我们现在写的一样的，预处理会把hello\_world.h的内容替换到main.cpp中。

**问题：在链接的时候，main.o怎么知道hello\_world函数定义在hello\_world.o中呢？**

答案：main.o不知道hello\_world函数定义在那个obj文件中，每个obj文件都有一个导出符号表，对于这个例子，hello\_world.o的导出符号表中有hello\_world这个函数，而main.o需要用到这个函数，可以想象就像几个插槽一样。链接器通过扫描obj文件发现这个函数定义在hello\_world.o中，然后就可以链接了。

**问题：为什么函数不能定义在头文件中？**

这个问题是不恰当的，因为用inline和static修饰的函数可以定义在头文件中，而inline修饰的函数必须定义在头文件中。

如果函数定义在头文件中，并且有多个cpp文件都包含了这个头文件的话，那么这些cpp文件生成的obj文件的导出符号表中都有这个头文件中定义的函数，单文件编译的时候是不会出错的，但是链接的时候就会报错。链接器发现了多个函数实体，但却无法确定应该使用哪一个。这是一个链接错误。

inline修饰的函数，通常都不会存在函数实体，即便编译器没有对其内联，那么obj文件也不会导出inline函数，所以链接不会出错。

static修饰的函数，只能由定义它的编译单元调用，也不会导出。如果头文件中顶一个static修饰的函数，就相当于多个obj文件中都顶一个了一个一模一样的函数，大家各用各的，互补干扰。

**问题：什么样的变量可以定义在头文件中？**

其实变量于函数很类似，由static或const修饰的变量可以定义在头文件中。

static修饰的变量于static修饰的函数一样，道理同上。

const修饰的变量默认是不会进入导出符号表的，相当于每个obj中都定义了一个一模一样的const变量，各用各的。而const可以再用extern修饰，如果用extern const修饰的变量定义在头文件中，那么就会出现链接错误，原因就是“想一想extern是干嘛的”

**问题：extern "C"是干嘛的？**

如果有人回答“兼容C和C++”，我只能说“这是一个正确答案，但我不知道你是否真的知道”。

首先要知道C不支持重载，C++支持重载，C++为了支持重载，引入了函数重命名的机制，就像下面这样：

1.  int hello\_world(type1 param);
2.  int hello\_world(type2 param);

int hello_world(type1 param);
    int hello_world(type2 param);

通常第一个函数会被编译成hello\_world\_type1这样子，第二个函数会被编译成hello\_world\_type2这样子。 **不管是定义的地方还是调用的地方，都会把函数改成同样的名字，所以链接器可以正确的找到函数实体。**

而我们写C++程序的时候，通常会引入由c编写的库(gcc编译的c文件)，而c不支持重载，自然不会对函数重命名。而我们在C++中调用的地方很可能会重命名，这就造成了调用的地方(C++编译)和定义的地方(C编译)函数名不一致的情况，这也是一种链接错误。

所以我们经常会看到在C++中用extern "C" \{ \#include "some\_c.h" \}这种代码。这就是告诉c++编译器，some\_c.h中的函数要按照c的方式编译，不要重命名，这样在链接的时候就ok了。

[view plain]: http://blog.csdn.net/qq575787460/article/details/18671137#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/167318
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/167318/fork