1ms Faster
Quincy Jet
2021-08-05
Content

extern

extern关键字的含义， 用法以及在编译的时候是如何进行链接的

  1. 置于变量或者函数前: 表明该变量或者函数定义在别的文件中
  2. 在变量或者函数之前加上extern关键字表明这是一个声明, 其定义可能在其他文件处, 注意不能对变量进行初始化或者对函数进行定义, 否则表明这是一个定义而不是声明.

# extern + non-const var

最常见的用法，当链接器在一个全局变量声明前看到extern关键字，它会尝试在其他文件中寻找这个变量的定义。这里强调全局且非常量的原因是，全局非常量的变量默认是外部链接的。

//fileA.cpp
int i = 1;     //声明并定义全局变量i
 
//fileB.cpp
extern int i;  //声明i，链接全局变量
 
//fileC.cpp
extern int i = 2;    //错误，多重定义
int i;               //错误，这是一个定义，导致多重定义

main() {
  extern int i;    //正确
  int i = 5;       //正确，新的局部变量i;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# extern + const var

常量全局变量默认是内部链接的，所以想要在文件间传递常量全局变量需要在定义时指明extern，如下所示：

//fileA.cpp
extern const int i = 1;    //定义
 
//fileB.cpp                
extern const int i;        //声明
1
2
3
4
5
  • 默认情况下, const修饰的全局常量据有跟static相同的特性， const 对象仅在本文件内有效, 但是可以通过 extern 关键字来使得 const 对象在多个文件中共享. 如在.h文件中声明 extern const char g_str[]; 在.cpp中别忘了定义: const char g_str[ ] = "123456";

所以当const单独使用时它就与static相同，而当与extern一起合作的时候，它的特性就跟extern的一样了

所以对const没有什么可以过多的描述，只是要注意，const char* g_str = "123456" 与 const char g_str[] ="123465"是不同的， 前面那个const 修饰的是char 而不是g_str,它的g_str并不是常量，如果让char g_str遵守const的全局常量的规则，最好这么定义const char const g_str="123456". 这个话题在 const关键字中讨论

# extern 和 static

(1) extern 表明该变量在别的地方已经定义过了,在这里要使用那个变量.

(2) static 表示静态的变量，分配内存的时候, 存储在静态区,不存储在栈上面.

static 作用范围是内部连接的关系, 和extern有点相反.它和对象本身是分开存储的,extern也是分开存储的,但是extern可以被其他的对象用extern 引用,而static 不可以,只允许对象本身用它. 具体差别首先，static与extern是一对“水火不容”的家伙，也就是说extern和static不能同时修饰一个变量；其次，static修饰的全局变量声明与定义同时进行，也就是说当你在头文件中使用static声明了全局变量后，它也同时被定义了；最后，static修饰全局变量的作用域只能是本身的编译单元，也就是说它的“全局”只对本编译单元有效，其他编译单元则看不到它,如:

(1) test1.h:

#ifndef TEST1H
#define TEST1H
static char g_str[] = "123456";
void fun1();
#endif
1
2
3
4
5

(2) test1.cpp:

#include "test1.h"
void fun1() {  cout << g_str << endl; }
1
2

(3) test2.cpp

#include "test1.h"
void fun2() {  cout << g_str << endl; }
1
2

以上两个编译单元可以连接成功, 当你打开test1.obj时，你可以在它里面找到字符串"123456", 同时你也可以在test2.obj中找到它们，它们之所以可以连接成功而没有报重复定义的错误是因为虽然它们有相同的内容，但是存储的物理地址并不一样，就像是两个不同变量赋了相同的值一样，而这两个变量分别作用于它们各自的编译单元。 也许你比较较真，自己偷偷的跟踪调试上面的代码,结果你发现两个编译单元（test1,test2）的g_str的内存地址相同，于是你下结论static修饰的变量也可以作用于其他模块，但是我要告诉你，那是你的编译器在欺骗你，大多数编译器都对代码都有优化功能，以达到生成的目标程序更节省内存，执行效率更高，当编译器在连接各个编译单元的时候，它会把相同内容的内存只拷贝一份，比如上面的"123456", 位于两个编译单元中的变量都是同样的内容，那么在连接的时候它在内存中就只会存在一份了，如果你把上面的代码改成下面的样子，你马上就可以拆穿编译器的谎言:

test1.cpp:

#include "test1.h"
void fun1()
{
    g_str[0] = ''a'';
    cout << g_str << endl;
}
1
2
3
4
5
6

test2.cpp:

#include "test1.h"
void fun2() { cout << g_str << endl; }
1
2

main function:

void main(){
    fun1(); // a23456
    fun2(); // 123456
}
1
2
3
4

这个时候你在跟踪代码时，就会发现两个编译单元中的g_str地址并不相同，因为你在一处修改了它，所以编译器被强行的恢复内存的原貌，在内存中存在了两份拷贝给两个模块中的变量使用。正是因为static有以上的特性，所以一般定义static全局变量时，都把它放在原文件中而不是头文件，这样就不会给其他模块造成不必要的信息污染.

# extern "C"

  1. extern"C": 让编译器以 C 语言的命名规则来查找函数
  2. extern“C”的主要作用就是为了能够正确实现C++代码调用其他C语言代码。加上extern “C”后，会指示编译器这部分代码按C语言的进行编译，而不是C++的。由于C++支持函数重载，因此编译器编译函数的过程中会将函数的参数类型也加到编译后的代码中，而不仅仅是函数名；而C语言并不支持函数重载，因此编译C语言代码的函数时不会带上函数的参数类型，一般只包括函数名。因为 C++ 重载, 而 C 不重载, 函数名编译的结果都不一样, 因此如果 C++ 直接调用 C 的函数, 因为二者编译的不同, 就会失败.

在C++中，当与字符串连用时，extern指明当前声明使用了其他语言的链接规范，如extern "C"，就指明使用C语言的链接规范。原因是，C++语言在编译的时候为了解决函数的多态问题，会将函数名和参数联合起来生成一个中间的函数名称，而C语言则不会，因此会造成链接时无法找到对应函数的情况，此时C函数就需要用extern “C”进行链接指定，这告诉编译器，请保持我的名称，不要给我生成用于链接的中间函数名。C和C++对函数的处理方式是不同的.extern "C"是使C++能够调用C写作的库文件的一个手段，如果要对编译器提示使用C的方式来处理函数的话，那么就要使用extern "C"来说明。

// 声明printf函数使用C链接
extern "C" int printf(const char *fmt, ...);

//声明指定的头文件内所有的东西都使用 C 链接
extern "C" {
    #include <stdio.h>
}

// 声明函数ShowChar和GetChar使用 C 链接
extern "C" {
    char ShowChar(char ch);
    char GetChar(void);
}

// 定义函数 ShowChar 和 GetChar 使用 C 链接
extern "C" char ShowChar(char ch) {
    putchar(ch);
    return ch;
}

extern "C" char GetChar(void) {
    char ch;
    ch = getchar();
    return ch;
}

// 声明全局变量 errno 为C链接
extern "C" int errno;

//又比如，在程序中常见的代码段
#ifdef __cplusplus 
extern "C" { 
   #endif 

/**** some declaration or so *****/ 
#ifdef __cplusplus 
} 
#endif

//这里__cplusplus是cpp中的自定义宏，定义了这个宏就表明这是一段cpp的代码，也就是说，//上面的代码的含义是:如果这是一段cpp的代码，那么加入extern "C"{和}处理其中的代码。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
  • extern和static是一对矛盾的修饰符, 二者不能同时修饰一个变量, 因为static表明变量的链接性是内部的, 而extern恰好相反.

注意事项：

  • 不要把变量定义放入.h文件，这样容易导致重复定义错误

  • 尽量使用static关键字把变量定义限制于该源文件作用域，除非变量被设计成全局的。

  • 可以在头文件中声明一个变量，在用的时候包含这个头文件就声明了这个变量。

# 一些问题：

# 问题(1)：extern 变量

在一个源文件里定义了一个数组：char a[6];

在另外一个文件里用下列语句进行了声明：extern char *a；

请问，这样可以吗？

答案与分析：

1)、不可以，程序运行时会告诉你非法访问。原因在于，指向类型T的指针并不等价于类型T的数组。extern char *a声明的是一个指针变量而不是字符数组，因此与实际的定义不同，从而造成运行时非法访问。应该将声明改为extern char a[ ]。

2)、例子分析如下，如果a[ ] = "abcd",则外部变量a=0x61626364 (abcd的ASCII码值)，*a显然没有意义

a指向的空间（0x61626364）没有意义，易出现非法内存访问。

3)、这提示我们，在使用extern时候要严格对应声明时的格式，在实际编程中，这样的错误屡见不鲜。

4)、extern用在变量声明中常常有这样一个作用，在*.*c文件中声明了一个全局的变量，这个全局的变量如果要被引用，就放在.h中并用extern来声明。

# 问题(2)：单方面修改extern函数原型

当函数提供方单方面修改函数原型时，如果使用方不知情继续沿用原来的extern申明，这样编译时编译器不会报错。但是在运行过程中，因为少了或者多了输入参数，往往会照成系统错误，这种情况应该如何解决？

答案与分析：

这种情况的处理没有一个很完美的方案，通常是提供方在自己的xxx_pub.h中提供对外部接口的声明，然后调用方include该头文件，从而省去extern这一步。以避免这种错误。

剑有双锋，对extern的应用，不同的场合应该选择不同的做法。

# 问题(3)：extern “C”

在C++环境下使用C函数的时候，常常会出现编译器无法找到obj模块中的C函数定义，从而导致链接失败的情况，应该如何解决这种情况呢？

答案与分析：

C++语言在编译的时候为了解决函数的多态问题，会将函数名和参数联合起来生成一个中间的函数名称，而C语言则不会，因此会造成链接时找不到对应函数的情况，此时C函数就需要用extern “C”进行链接指定，这告诉编译器，请保持我的名称，不要给我生成用于链接的中间函数名。

下面是一个典型的用法：

//在.h文件的头上
#ifdef __cplusplus
#if __cplusplus
extern "C"{
#endif
#endif /* __cplusplus */

    …
    …

//.h文件结束的地方
#ifdef __cplusplus
#if __cplusplus
}
#endif
#endif /* __cplusplus */
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 问题(4)：extern 非 static 函数

常常见extern放在函数的前面成为函数声明的一部分，那么，C语言的关键字extern在函数的声明中起什么作用？

答案与分析：

如果函数的声明中带有关键字extern，仅仅是暗示这个函数可能在别的源文件里定义，没有其它作用。即extern int f(); 和 int f();两个函数声明没有明显的区别

当然，用处还是有的，就是在程序中取代include “*.h”来声明函数，在一些复杂的项目中，我比较习惯在所有的函数声明前添加extern修饰。关于这样做的原因和利弊可见下面的这个例子：“用extern修饰的全局变量”

(1) 在test1.h中有下列声明:

#ifndef TEST1H
#define TEST1H

extern char g_str[]; // 声明全局变量g_str
void fun1();

#endif
1
2
3
4
5
6
7

(2) 在test1.cpp中

#include "test1.h"
char g_str[] = "123456"; // 定义全局变量g_str
void fun1() { cout << g_str << endl; }
1
2
3

(3) 以上是test1模块， 它的编译和连接都可以通过,如果我们还有test2模块也想使用g_str,只需要在原文件中引用就可以了

#include "test1.h"
void fun2()  { cout << g_str << endl;  }
1
2

以上test1和test2可以同时编译连接通过，如果你感兴趣的话可以用ultraEdit打开test1.obj,你可以在里面找到"123456"这个字符串,但是你却不能在test2.obj里面找到，这是因为g_str是整个工程的全局变量，在内存中只存在一份,test2.obj这个编译单元不需要再有一份了，不然会在连接时报告重复定义这个错误!

(4) 有些人喜欢把全局变量的声明和定义放在一起，这样可以防止忘记了定义，如把上面test1.h改为

extern char g_str[] = "123456"; // 这个时候相当于没有extern
1

然后把test1.cpp中的g_str的定义去掉,这个时候再编译连接test1和test2两个模块时，会报连接错误，这是因为你把全局变量g_str的定义放在了头文件之后，test1.cpp这个模块包含了test1.h所以定义了一次g_str,而test2.cpp也包含了test1.h所以再一次定义了g_str,这个时候连接器在连接test1和test2时发现两个g_str。如果一定要把g_str的定义放在test1.h中的话，那么就把test2的代码中#include "test1.h"去掉 换成:

extern char g_str[];
void fun2()  { cout << g_str << endl;  }
1
2

这个时候编译器就知道g_str是引自于外部的一个编译模块了，不会在本模块中再重复定义一个出来，但是这样做会非常不方便，因为无法再在test2.cpp中使用#include "test1.h", 所以test1.h中声明的其他函数也无法使用了，除非都用extern修饰，声明的函数就要一大串，而且头文件的作用本来就是要给外部提供接口使用的，所以，只在头文件中做声明，真理总是这么简单粗暴。

#C++
Last updated: 2023/06/18, 16:23:56
const
pointer

← pointer→

Copyright © 2017-2023 Quincy Jet | MIT License