关闭

解析“extern”

316人阅读 评论(0) 收藏 举报
分类:

1、 声明外部变量

现代编译器一般采用按文件编译的方式,因此在编译时,各个文件中定义的全局变量是

互相透明的,也就是说,在编译时,全局变量的可见域限制在文件内部。下面举一个简单的例子。创建一个工程,里面含有A.cppB.cpp两个简单的C++源文件:

//A.cpp

int i;

 

void main()

{

}

 

 

 

 

 

//B.cpp

int i;

 

 

      

这两个文件极为简单,在A.cpp中我们定义了一个全局变量i,在B中我们也定义了一个全局变量i

我们对AB分别编译,都可以正常通过编译,但是进行链接的时候,却出现了错误,错误提示如下:

Linking...

B.obj : error LNK2005: "int i" (?i@@3HA) already defined in A.obj

Debug/A.exe : fatal error LNK1169: one or more multiply defined symbols found

Error executing link.exe.

 

A.exe - 2 error(s), 0 warning(s)

 

 

 

 

 

       这就是说,在编译阶段,各个文件中定义的全局变量相互是透明的,编译A时觉察不到B中也定义了i,同样,编译B时觉察不到A中也定义了i

但是到了链接阶段,要将各个文件的内容“合为一体”,因此,如果某些文件中定义的全局变量名相同的话,在这个时候就会出现错误,也就是上面提示的重复定义的错误。

       因此,各个文件中定义的全局变量名不可相同。

 

      

       在链接阶段,各个文件的内容(实际是编译产生的obj文件)是被合并到一起的,因而,定义于某文件内的全局变量,在链接完成后,它的可见范围被扩大到了整个程序。

       这样一来,按道理说,一个文件中定义的全局变量,可以在整个程序的任何地方被使用,举例说,如果A文件中定义了某全局变量,那么B文件中应可以该变量。修改我们的程序,加以验证:

//A.cpp

 

void main()

{

    i = 100; //试图使用B中定义的全局变量

}

 

 

 

 

 

//B.cpp

int i;

 

 

 

       编译结果如下:

 

      

Compiling...

A.cpp

C:/Documents and Settings/wangjian/桌面/try extern/A.cpp(5) : error C2065: 'i' : undeclared identifier

Error executing cl.exe.

 

A.obj - 1 error(s), 0 warning(s)

 

 

 

 

 

 

 

       编译错误。

       其实出现这个错误是意料之中的,因为:文件中定义的全局变量的可见性扩展到整个程序是在链接完成之后,而在编译阶段,他们的可见性仍局限于各自的文件。

       编译器的目光不够长远,编译器没有能够意识到,某个变量符号虽然不是本文件定义的,但是它可能是在其它的文件中定义的。

      

       虽然编译器不够远见,但是我们可以给它提示,帮助它来解决上面出现的问题。这就是extern的作用了。

       extern的原理很简单,就是告诉编译器:“你现在编译的文件中,有一个标识符虽然没有在本文件中定义,但是它是在别的文件中定义的全局变量,你要放行!”

       我们为上面的错误程序加上extern关键字:

//A.cpp

 

extern int i;

void main()

{

    i = 100; //试图使用B中定义的全局变量

}

 

 

 

 

 

 

//B.cpp

int i;

 

 

 

       顺利通过编译,链接。

 

 

2、 C++文件中调用C方式编译的函数

 

C方式编译和C++方式编译

相对于CC++中新增了诸如重载等新特性,对于他们的编译,必然有一些重要的区别。

我们将下面的小程序分别按CC++方式编译,来探讨两种编译方式的区别。

int i;

 

int func(int t)

{

         return 0;

}

 

void main()

{

}

 

 

 

 

 

 

 

 

       C方式编译的结果:

COMM     _i  :  DWORD

 

PUBLIC    _func

 

PUBLIC    _main

 

 

 

 

 

       C++方式编译的结果:

PUBLIC    ?i@@3HA                                               ; i

 

PUBLIC    ?func@@YAHH@Z                                         ; func

 

PUBLIC    _main

 

 

 

 

 

       可见,C方式编译下,变量名和函数名之前被统一加上了一个下划线,而C++编译后的结果却复杂的多,i变成了?i@@3HAfunc变成了?func@@YAHH@ZC++中的这种看似复杂的命名规则是为C++中的函数重载,参数检查等特性服务的。

 

多文件程序中的函数调用

       一般情况下,工程中的文件都是CPP文件(以及头文件)。如下面的程序仅包含两个文件:A.CPPB.CPP

//A.CPP

void func();

 

void main()

{

         func();

}

 

 

 

 

 

//B.CPP

void func()

{

}

 

 

 

 

       程序的结构是这样的:在文件B.CPP中定义了一个函数void func()main函数位于文件A.CPP,在main函数中调用了B中定义的函数func()

       要在A中调用B中定义的函数,必须要加上该函数的声明。如本例中的void func();就是对函数func()的声明。

如果没有声明的话,编译A.CPP时就会出错。因为编译器的目光只局限于被编译文件,必须通过加入函数声明来告诉编译器:“某个函数是定义在其它的文件中的,你要放行!”,这一点跟用extern来声明外部全局变量是一个道理。

       需要注意的是,一般的程序都是通过包含头文件来完成函数的声明。拿本例来说,一般是创建一个头文件B.H,在头文件中加入声明语句void func(); 并且在A.CPP中加入包含语句:#include “B.H”

       C++程序中,头文件的功能从函数声明被扩展为类的定义。

 

不同编译方式下的函数调用

       如果在工程中,不仅有CPP文件,还有以C方式编译的C文件,函数调用就会有一些微妙之处。我们将B.CPP改作B.C

 

 

 

//A.CPP

void func();

 

void main()

{

         func();

}

 

 

 

 

 

 

//B.C

void func()

{

}

 

 

 

 

       A.CPPB.C分别编译,都没有问题,但是链接时出现错误。

Linking...

A.obj : error LNK2001: unresolved external symbol "void __cdecl func(void)" (?func@@YAXXZ)

Debug/A.exe : fatal error LNK1120: 1 unresolved externals

Error executing link.exe.

 

A.exe - 2 error(s), 0 warning(s)

 

 

 

 

 

原因就在于不同的编译方式产生的冲突。

 

       对于文件A,是按照C++的方式进行编译的,其中的func()调用被编译成了

call    ?func1@@YAXXZ    

 

 

如果B文件也是按照C++方式编译的,那么B中的func函数名也会被编译器改成?func1@@YAXXZ,这样的话,就没有任何问题。

       但是现在对B文件,是按照C方式编译的,B中的func函数名被改成了_func,这样一来,A中的call ?func1@@YAXXZ这个函数调用就没有了着落,因为在链接器看来,B文件中没有名为?func1@@YAXXZ的函数。

       事实是,我们编程者知道,B文件中有A中调用的func函数的定义,只不过它是按照C方式编译的,故它的名字被改成了_func。因而,我们需要通过某种方式告诉编译器:“B中定义的函数func()经编译后命名成了_func,而不是?func1@@YAXXZ,你必须通过call _func来调用它,而不是call ?func1@@YAXXZ。”简单的说,就是告诉编译器,调用的func()函数是以C方式编译的,fun();语句必须被编译成call _func;而不是call ?func1@@YAXXZ

      

       我们可以通过extern关键字,来帮助编译器解决上面提到的问题。

       对于本例,只需将A.CPP改成如下即可:

//A.CPP

extern "C"

{

         void func();

}

void main()

{

         func();

}

 

      

 

 

 

 

 

 

       察看汇编代码,发现此时的func();语句被编译成了call _func

3、 补充

2一样,仍然是CC++混合编程的情形,考虑下面的程序:

//A.CPP

 

extern int i;

 

void main()

{

         i = 100;

}

 

 

 

 

 

 

 

//B.C

int i;

 

 

       程序很简单:在文件B.C中定义了一个全局变量i,在A.CPP中使用了这个全局变量。

       编译没有问题,链接时却出现错误:

Linking...

A.obj : error LNK2001: unresolved external symbol "int i" (?i@@3HA)

Debug/A.exe : fatal error LNK1120: 1 unresolved externals

Error executing link.exe.

 

A.exe - 2 error(s), 0 warning(s)

 

 

 

 

 

      

       这是因为,在C方式编译下,i被重命名为_i,而在C++方式下,i会被重命名为?i@@3HA

因而,我们只用extern int i;来声明还不够,必须告诉编译器,全局变量i是以C方式编译的,

它会被重命名为_i,而不是?i@@3HA

 

       我们修改A.CPP,如下:

//A.CPP

 

extern "C"

{

         int i;

}

void main()

{

 

         i = 100;

}

 

 

 

 

 

 

 

 

 

       程序正常通过编译和链接。

       我们察看一下汇编代码,发现语句i = 100;被编译成了mov  DWORD PTR _i, 100


http://blog.csdn.net/gobitan/article/details/1532769  souce url

在实际工作中可能经常要进行C和C++的混合编程,C++调用C语言的代码通常都比较容易,但也有一些细节需要注意。C要调用C++的代码就略为麻烦一些,因为C不支持面向对象的特征。
首先我们来看一下C++调用C语言的代码。要让你的C代码既能被C代码又能被C++调用虽说容易,但是还是有需要注意的地方。现有三个文件分别如下:
/* file TestC.h */
#ifndef TESTC_H
#define TESTC_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
int add(int a, int b);
      
#ifdef __cplusplus
}
#endif
 
#endif /* TESTC_H */
 
 
/* file TestC.c */
 
#include "TestC.h"
 
int add(int a, int b)
{
    return (a + b);
}
 
 
/* file TestCpp.cpp */
#include "stdio.h"
#include "TestC.h"
 
int main()
{
       printf("add = %d/n", add(2, 5));
      
       return 0;
}
说明:
file TestC.h是C的头文件,file TestC.c是其实现文件,file TestCpp.cpp是调用C函数的C++文件。
文件TestC.h中的TESTC_H定义是为了头文件保护,” #ifdef __cplusplus”这个不能缺少,你可以去查看C的标准库头文件中都有这个,如”stdio.h”。有了这个宏编译器就知道现在是C还是C++在调用它。
为什么要区分C与C++调用呢?其深层次原因是因为C和C++编译器在编译和链接时对于函数的处理不一样。C++为了支持函数重载在编译时会加入函数参数及类型信息。如上面的add方法,C编译器编译后在符号库中的名字为_add,而C++编译器则会产生像_add_int_int之类的名字。C++正是依靠这种机制实现了函数的重载。
extern关键字表示将函数或变量声明为全局类型,与之相对应的是static。static限定函数或变量的作用域为本文件。extern还有一个作用就是与”C”连在一起使用,即extern “C”通知编译器将extern “C”所包含的代码按照C的方式编译和链接。
 
下面我们就来看看如何在C语言中使用C++的代码(包括C++类的方法)。为了简单起见,我将类的定义和实现放在一个文件中(通常应该是将分别放在.h和.cpp文件中)。自定义类文件(这里省略了头文件保护等其它细节)如下:
//* file TestClass.h */
 
class HJH
{
public:
    int add(int a, int b)
       {
              return (a + b);
       }
};
 
将C++类封装为C函数的文件(为了简略也将声明和实现放在了同一个文件中)如下:
/* file TestCpp.cpp */
 
#include "TestClass.h"
 
extern "C" int add_cpp(int a, int b);
 
int add_cpp(int a, int b)
{
       HJH hjh;
 
       return hjh.add(a, b);      
}
 
实际调用C++代码的C文件如下:
/*file TestC.c */
#include "stdio.h"
 
extern int add_cpp(int a, int b);
 
int main()
{
       printf("add_cpp = %d/n", add_cpp(2, 5));
      
       return 0;
}
上面的过程很清晰,就是用一个函数将C++类的使用封装起来,然后将它外部声明为C函数就可以了。
文件TestClass.h定义并实现了一个类,该类只有一个add方法。文件TestCpp.cpp定义并实现了一个函数add_cpp,函数中定义了一个HJH类对象并调用了该对象的add方法。然后将add_cpp函数进行外部声明为C。
TestC.c文件中为了使用add_cpp函数,也需要进行外部声明。这是为了通知编译器说明这个函数是在其他文件中实现(注意在C文件中的extern后面不可加”C”)。当这三个文件一起编译链接时,编译器就可以找到add_cpp的具体实现。

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:76492次
    • 积分:1333
    • 等级:
    • 排名:千里之外
    • 原创:40篇
    • 转载:88篇
    • 译文:6篇
    • 评论:0条