解析C++中的内部连接与外部连接

在介绍C++中的内部连接与外部连接前,先说明一些概念。

1.声明

一个声明将一个名称引入一个作用域;

在c++中,在一个作用域中重复一个声明是合法的

以下都是声明:

 
 
  1. int foo(int,int); //函数前置声明
  2. typedef int Int; //typedef 声明
  3. class bar; //类前置声明
  4. extern int g_var; //外部引用声明
  5. class bar; //类前置声明
  6. typedef int Int; //typedef 声明
  7. extern int g_var; //外部引用声明
  8. friend test; //友员声明
  9. using std::cout; //名字空间引用声明
  10. friend test; //友员声明
  11. using std::cout; //名字空间引用声明
  12. int foo(int,int); //函数前置声明

在同一个作用域中你可以多次重复这些声明。

有两种声明不能重复,那就是类成员函数及静态数据成员的声明

 
 
  1. class foo 
  2.  static int i; 
  3.  static int i;//不可以 
  4.  public: 
  5. int foo(); 
  6. int foo();//不可以 
  7. };

2.定义

一个定义提供一个实体(类型、实例、函数)在一个作用域的唯一描述。

在同一作用域中不可重复定义一个实体。

以下都是定义。

 
 
  1. int y;
  2. class foo {...};
  3. struct bar {...};
  4. foo* p;
  5. static int i;
  6. enum Color{RED,GREEN,BLUE};
  7. const double PI = 3.1415;
  8. union Rep{...};
  9. void test(int p) {};
  10. foo a;
  11. bar b;

3.编译单元

当一个c或cpp文件在编译时,预处理器首先递归包含头文件,形成一个含有所有 必要信息的单个源文件,这个源文件就是一个编译单元。这个编译单元会被编译成为一个与cpp文件名同名的目标文件(.o或是.obj)。连接程序把不同编译单元中产生的符号联系起来,构成一个可执行程序。

4.自由函数

如果一个函数是自由函数,那么这个函数不是类的成员函数,也不是友元函数。

下面来看内部连接和外部连接

内部连接:如果一个名称对于它的编译单元来说是局部的,并且在连接时不会与其它编译单元中的同样的名称相冲突,那么这个名称有内部连接(注:有时也将声明看作是无连接的,这里我们统一看成是内部连接的)。

以下情况有内部连接:

a)所有的声明

b)名字空间(包括全局名字空间)中的静态自由函数、静态友元函数、静态变量的定义

c)enum定义

d)inline函数定义(包括自由函数和非自由函数)

e)类的定义

f)名字空间中const常量定义

g)union的定义

外部连接:在一个多文件程序中,如果一个名称在连接时可以和其它编译单元交互,那么这个名称就有外部连接。

以下情况有外部连接:

a)类非inline函数总有外部连接。包括类成员函数和类静态成员函数

b)类静态成员变量总有外部连接。

c)名字空间(包括全局名字空间)中非静态自由函数、非静态友元函数及非静态变量

下面举例说明:

a)声明、enum定义、union定义有内部连接

所有的声明、enum定义及union定义在编译后不会产生连接符号,也就是在不同编译单元中有相同名称的声明及enum、union定义并不会在连接时发生发现多个符号的错误。

 
 
  1. // main.cpp
  2. typedef int Int; //typedef 声明,内部连接
  3. enum Color{red}; //enum定义,内部连接
  4. union X //union定义,内部连接
  5. {
  6.  long a;
  7.  char b[10];
  8. };
  9. int main(void)
  10. {
  11. Int i = red;
  12. return i;
  13. }
  14. // a.cpp
  15. typedef int Int; //在a.cpp中重声明一个int类型别名,在连接时不会发生错误
  16. enum Color{blue}; //在a.cpp中重定义了一个enum Color,在连接时不会发生错误
  17. const Int i =blue; //const常量定义,内部连接
  18. union X //union定义,内部连接
  19. {
  20.  long a;
  21.  char b[10];
  22. };

b)名字空间中静态自由函数、静态友元函数、静态变量、const常量定义有内部连接

 
 
  1. // main.cpp
  2. namespace test
  3. {
  4.  int foo(); //函数声明,内部连接
  5.  static int i = 0; //名字空间静态变量定义,内部连接
  6.  static int foo() { return 0;} //名字空间静态函数定义,内部连接
  7. }
  8. static int i = 0; //全局静态变量定义,内部连接
  9. static int foo() {return 1;} //全局静态函数定义,内部连接
  10. const int k = 0; //全局const常量定义,内部连接
  11. int main(void)
  12. {
  13.  return 0;
  14. }
  15. //a.cpp
  16. namespace test
  17. {
  18.  int i = 0; //名字空间变量定义,外部连接
  19.  int foo() {return 0;} //名字空间函数定义,外部连接
  20. }
  21. int i = 0; //全局变量定义,外部连接
  22. int k = 0; //全局变量定义,外部连接
  23. int foo() { return 2;} //全局函数定义,外部连接

在全局名字空间中,main.cpp中定义了静态变量i,常量k,及静态自由函数foo等,这些都有内部连接。如果你将这些变量或函数的static或是const修饰符去掉,在连接时就会现multiply defined symbols错误,它们与a.cpp中的全局变量、全局函数发生冲突。

c)类定义总有内部连接,而非inline类成员函数定义总有外部连接,不论这个成员函数是静态、虚拟还是一般成员函数,类静态数据成员定义总有外部连接。

1.类的定义有内部连接。如果不是,想象一下你在4个cpp文件中include定义了类Base的头文件,在4个编译单元中的类Base都有外部连接,在连接的时候就会出错。

看下面的例子:

 
 
  1. //main.cpp
  2. class B //类定义,内部连接
  3. {
  4.  static int s_i; //静态类成员声明,内部连接 
  5.  public:
  6. void foo() { ++s_i;} //类inline函数,内部连接
  7. };
  8. struct D 
  9. {
  10.  void foo(); //类成员函数声明,内部连接
  11. };
  12. int B::s_i = 0; //类静态数据成员定义,外部连接
  13. void D::foo() //类成员函数定义,外部连接
  14.  cout << "D::foo in main.cpp" <
  15. }
  16. int main() //main函数,全局自由函数,外部连接
  17. {
  18.  B b;
  19.  D d;
  20.  return 0;
  21. }
  22. //a.cpp
  23. class B
  24. {
  25.  int k;
  26. };
  27. struct D
  28. {
  29.  int d;
  30. };

在这个例子中,main.cpp与a.cpp中都有class B和class D的定义,但在编译这两个cpp文件时并不发生link错误。

2.类的非inline成员函数(一般,静态,虚拟都是)总有外部连接,这样当你include了某个类的头文件,使用这个类的函数时,就能连接到正确的类成员函数上,继续以上面为例子,如果把a.cpp中的struct D改为

 
 
  1. struct D //类定义
  2. {
  3.  int d;
  4.  void foo(); //类成员函数声明
  5. };
  6. void D::foo() //类成员函数定义,外部连接
  7. {
  8.  cout << " D::foo in a.cpp" <
  9. }

这时main.cpp与a.cpp中的D::foo都有外部连接,在连接就会出现multiply defined symbols错。

3.类的静态数据成员有外部连接,如上例的B::s_i,这样当你在main.cpp中定义了类静态数据成员,其它编译单元若使用了B::s_i,就会连接到main.cpp对应编译单元的s_i。

d)inline函数总有内部连接,不论这个函数是什么函数

 
 
  1. // main.cpp
  2. inline int foo() { return 1;} //inline全局函数,内部连接
  3. class Bar //类定义,内部连接
  4. {
  5.  public:
  6. static int f() { return 2;} //inline 类静态函数,内部连接
  7. int g(int i) { return i;} //inline 类成员函数,内部连接
  8. };
  9. class Base
  10. {
  11.  public:
  12. inline int k(); //类成员函数声明,内部连接
  13. };
  14. inline int Base::k(){return 5;} //inline 类成员函数,内部连接
  15. int main(void)
  16. {
  17.  return 0;
  18. }

如果你的Base类是定义在Base.h中,而Base的inline 函数是在Base.cpp中定义的,那么在main.cpp中include "Base.h"编译不会出现问题,但在连接时会找不到函数k,所以类的inline函数***放到头文件中,让每一个包含头文件的cpp都能找到inline函数。

现在对c++中的连接有了一个认识,能清楚的知道是什么原因产生连接时错误。当你在连接时产生连接不到的错误,这说明所有的编译单元都没有这个实体的外部连接;当你在连接时发现有多个连接实体,这说明有多个编译单元提供了同名的有外部连接的实体。同时,在进行程序设计时,也要注意不要使只有本编译单元用到的函数、类、变量等有外部连接,减少与其它编译单元的连接冲突。

不过在这里没有说明template函数及template class的连接性,并且对一些特别的情况也没有作出说明(比如inline函数不能被inline)。

文章名称:解析C++中的内部连接与外部连接
网页链接:http://www.shufengxianlan.com/qtweb/news31/431631.html

网站建设、网络推广公司-创新互联,是专注品牌与效果的网站制作,网络营销seo公司;服务项目有等

广告

声明:本网站发布的内容(图片、视频和文字)以用户投稿、用户转载内容为主,如果涉及侵权请尽快告知,我们将会在第一时间删除。文章观点不代表本网站立场,如需处理请联系客服。电话:028-86922220;邮箱:631063699@qq.com。内容未经允许不得转载,或转载时需注明来源: 创新互联