extern "C" 详解

Sam之前在提供BTX库时，需要提供一个 BTX.h文件。按照标准头文件的写法：
#ifndef _BTX_H
#define _BTX_H
#ifdef __cplusplus
extern "C" {
#endif

//xxxxxx
extern functionA();

#ifdef __cplusplus
}
#endif

#endif
也就是说：将所有function 声明和 struct定义全放在里面了。但corner建议只将function声明放在其中。并且，不需要再次声明：extern functionA();
所以研究一下#extern "C"

众所周知：
#ifndef _BTX_H
#define _BTX_H
//xxxx
#endif
编译宏用来防止重复引用。

下面将仔细研究#extern.（这部分引用CSDN：keen资源，觉得他讲的足够清楚了）


extern 作用1：声明外部变量
现代编译器一般采用按文件编译的方式，因此在编译时，各个文件中定义的全局变量是
互相透明的，也就是说，在编译时，全局变量的可见域限制在文件内部。

例1：
创建一个工程，里面含有A.cpp和B.cpp两个简单的C++源文件：
//A.cpp:
int iRI;
int main()
{
//.....
}

//B.cpp
int iRI;

gcc A.cpp -c
gcc B.cpp -c
编译出A.o, B.o都没有问题。
但当gcc A.o B.o -o test时，
main.o:(.bss+0x0): multiple definition of `iRI'
b.o:(.bss+0x0): first defined here
报错：重定义。
（但Sam有个非常意外的发现：当同样的代码，使用A.c B.c.并使用gcc编译时，竟然不会报重定义的错误，非常不明白是怎么回事。）
这就是说，在编译阶段，各个文件中定义的全局变量相互是透明的，编译A时觉察不到B中也定义了i，同样，编译B时觉察不到A中也定义了i。
但是到了链接阶段，要将各个文件的内容“合为一体”，因此，如果某些文件中定义的全局变量名相同的话，在这个时候就会出现错误，也就是上面提示的重复定义的错误。因此，各个文件中定义的全局变量名不可相同。

但如果用下列方式：在B.cpp中定义iRI;在A.cpp中直接使用。则编译A.cpp时就无法通过。
//A.cpp
int main()
{
iRI=64;
}

//B.cpp
int iRI;

gcc A.cpp -c
was not declared in this scope.
因为编译器按照文件方式编译，所以编译A.cpp时，并不知道B.cpp中定义了iRI。
也就是说：文件中定义的全局变量的可见性扩展到整个程序是在链接完成之后，而在编译阶段，他们的可见性仍局限于各自的文件。
解决方案如下：
编译器的目光不够长远，编译器没有能够意识到，某个变量符号虽然不是本文件定义的，但是它可能是在其它的文件中定义的。
虽然编译器不够远见，但是我们可以给它提示，帮助它来解决上面出现的问题。这就是extern的作用了。
extern的原理很简单，就是告诉编译器：“你现在编译的文件中，有一个标识符虽然没有在本文件中定义，但是它是在别的文件中定义的全局变量，你要放行！”
//A.cpp:
extern int iRI;
int main()
{
iRI = 64;
//.....
}

//B.cpp
int iRI;
这样编译就能够通过。
extern int iRI; //并未分配空间，只是通知编译器，在其它文件定义过iRI。


extern 作用2：在C++文件中调用C方式编译的函数
C方式编译和C++方式编译
相对于C，C++中新增了诸如重载等新特性。所以全局变量和函数名编译后的命名方式有很大区别。
int a;
int functionA();
对于C方式编译：
int a;=> _a
int functionA(); => _functionA
对于C++方式编译：
int a; =>xx@xxx@a
int functionA(); => xx@xx@functionA
可以看出，因为要支持重载，所以C++方式编译下，生成的全局变量名和函数名复杂很多。与C方式编译的加一个下划线不同。
于是就有下面几种情况：
例2：C++调用C++定义的全局变量
//A.cpp:
extern int iRI;
int main()
{
iRI = 64;
//.....
}
//B.cpp
int iRI;
gcc A.cpp -c
gcc B.cpp -c
gcc A.o B.o -o test
那么在编译链接时都没问题。

例3：C++调用C定义的全局变量
//A.cpp:
extern int iRI;
int main()
{
iRI = 64;
//.....
}
//B.c
int iRI;
编译时没有问题，
gcc A.cpp -c
gcc B.c -c
但链接时，gcc B.o A.o -o test
则会报iRI没有定义。为什么呢？
因为gcc看到A.cpp，就使用C++方式编译，看到B.c，就使用C方式编译。
所以在A.cpp中的iRI=>XXX@XXX_iRI;
而B.c中iRI=〉_iRI;
所以在链接时，A.cpp想找到XXX@XXX_iRI，当然找不到。所以就需要告诉编译器，iRI是使用C方式编译的。
//A.cpp:
extern "C"
{
int iRI;
}
int main()
{ iRI = 64;
//.....
}
//B.c
int iRI;
这样，当编译A.cpp时，编译器就知道iRI为C方式编译的。就会使用 _iRI。这样B.c提供的_iRI就可以被A.cpp找到了。

例4：C++调用C定义的function
//A.cpp
extern int functionA();

int main()
{
functionA();
}

//B.c
int functionA()
{
//....
}
gcc A.cpp -c
gcc B.c -c
都没有问题。但同样的，gcc A.o B.o -o test
则报错，找不到functionA();
这是因为gcc将A.cpp认为是C++方式编译，B.c是C方式编译。
所以functionA在B.c中为：_functionA. 在A.cpp中为：XX@XXX_functionA
所以在链接时A.cpp找不到XX@XX_function.
于是需要通知编译器，functionA()是C方式编译命名的。
//A.cpp
extern "C"
{
int functionA();
}
int main()
{
functionA();
}

//B.c
int functionA()
{
//....
}
于是，编译链接都可以通过。

Sam的具体应用：
另外：Sam这次是写了一个Linux 下Bluetooth库。libBTX.so. 这个库需要C，C++都可以使用。
但Sam这个库是C方式编译的。libBTX.so下，functionA()=>_functionA
所以C程序调用时没有问题，C++则会有问题。
所以需要在这个库提供的头文件中加入：
#ifndef _BTX_H
#define _BTX_H

#ifdef __cplusplus
extern "C" {
#endif

//xxxxxx


#ifdef __cplusplus
}
#endif
则当C程序下使用这个库时，
#include "BTX.h"
因为是C方式编译，所以不会进入#ifdef __cplusplus
当C++程序调用这个库，
#include "BTX.h"
则C++编译器可以进入#ifdef __cplusplus
所以extern "C"被启用。
这表示下面BTX所提供的function为C方式编译的。则C++程序也能够将functionA()编译为_functionA.这样就可以找到libBTX.so所提供的function.


最终结论：
Corner所得很对，只需要把function()放在extern "C" { ....} 内，但Sam的做法好象也没错。因为很多Linux程序也是这样做的。
同时,
extern "C"
{
functionA();
}//不止是声明，并且还指出：这个function请用C方式编译。所以不需要再次extern.
所以Corner的建议也是非常有道理的。
exter "C"
{
extern functionA();
}//这样做没什么太大意义。