C++中的内部连接与外部连接前

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

1.声明

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

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

以下都是声明：

 
 
 
 

  
  
  
  
int foo(int,int); //函数前置声明   
typedef int Int; //typedef 声明   
class bar; //类前置声明   
extern int g_var; //外部引用声明   
class bar; //类前置声明   
typedef int Int; //typedef 声明   
extern int g_var; //外部引用声明   
friend test; //友员声明   
using std::cout; //名字空间引用声明   
friend test; //友员声明   
using std::cout; //名字空间引用声明   
int foo(int,int); //函数前置声明  

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

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

 
 
 
 

  
  
  
  
class foo    
{    
　static int i;    
　static int i;//不可以    
　public:    
int foo();    
int foo();//不可以    
};  

2.定义

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

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

以下都是定义。

 
 
 
 

  
  
  
  
int y;   
class foo {...};   
struct bar {...};   
foo* p;   
static int i;   
enum Color{RED,GREEN,BLUE};   
const double PI = 3.1415;   
union Rep{...};   
void test(int p) {};   
foo a;   
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定义并不会在连接时发生发现多个符号的错误。

 
 
 
 

  
  
  
  
// main.cpp   
typedef int Int; //typedef 声明，内部连接   
enum Color{red}; //enum定义,内部连接   
union X //union定义，内部连接   
{   
　long a;   
　char b[10];   
};   
int main(void)   
{   
Int i = red;   
return i;   
}   
// a.cpp   
typedef int Int; //在a.cpp中重声明一个int类型别名，在连接时不会发生错误   
enum Color{blue}; //在a.cpp中重定义了一个enum Color，在连接时不会发生错误   
const Int i =blue; //const常量定义，内部连接   
union X //union定义，内部连接   
{   
　long a;   
　char b[10];   
};  

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

 
 
 
 

  
  
  
  
// main.cpp   
namespace test   
{   
　int foo(); //函数声明，内部连接   
　static int i = 0; //名字空间静态变量定义，内部连接   
　static int foo() { return 0;} //名字空间静态函数定义，内部连接   
}   
static int i = 0; //全局静态变量定义，内部连接   
static int foo() {return 1;} //全局静态函数定义，内部连接   
const int k = 0; //全局const常量定义，内部连接   
int main(void)   
{   
　return 0;   
}   
//a.cpp   
namespace test   
{   
　int i = 0; //名字空间变量定义，外部连接   
　int foo() {return 0;} //名字空间函数定义，外部连接   
}   
int i = 0; //全局变量定义，外部连接   
int k = 0; //全局变量定义，外部连接   
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都有外部连接，在连接的时候就会出错。

看下面的例子:

 
 
 
 

  
  
  
  
//main.cpp   
class B //类定义，内部连接   
{   
　static int s_i; //静态类成员声明，内部连接    
　public:   
void foo() { ++s_i;} //类inline函数，内部连接   
};   
struct D    
{   
　void foo(); //类成员函数声明，内部连接   
};   
int B::s_i = 0; //类静态数据成员定义，外部连接   
void D::foo() //类成员函数定义，外部连接   
{    
　cout << "D::foo in main.cpp" <<endl;   
}   
int main() //main函数，全局自由函数，外部连接   
{   
　B b;   
　D d;   
　return 0;   
}   
//a.cpp   
class B   
{   
　int k;   
};   
struct D   
{   
　int d;   
};  

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

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

 
 
 
 

  
  
  
  
struct D //类定义   
{   
　int d;   
　void foo(); //类成员函数声明   
};   
void D::foo() //类成员函数定义，外部连接   
{   
　cout << " D::foo in a.cpp" <<endl;   
}  

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

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

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

 
 
 
 

  
  
  
  
// main.cpp   
inline int foo() { return 1;} //inline全局函数，内部连接   
class Bar //类定义，内部连接   
{   
　public:   
static int f() { return 2;} //inline 类静态函数，内部连接   
int g(int i) { return i;} //inline 类成员函数，内部连接   
};   
class Base   
{   
　public:   
inline int k()； //类成员函数声明，内部连接   
}；   
inline int Base::k(){return 5;} //inline 类成员函数，内部连接   
int main(void)   
{   
　return 0;   
}  

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

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

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

第二篇：

什么应该放在头文件里

头文件为相关声明提供了一个集中存放的位置。头文件一般包含类的定义、枚举的定义、extern变量的声明、函数的声明、const int的定义、inline函数的定义。使用或者定义这些实体的文件要包含适当的头文件。

头文件用于声明，而不用于定义

当设计头文件时，记住定义和声明的区别是很重要的。定义只可以出现一次，而声明可以出现多次。下列语句是定义，所以不应该放在头文件里：

Extern  int  ival  = 10 ;            // 有初始化，所以是定义

Double fica_rate;                // 没有extern关键字，所以也是定义

因为以上两个语句都是定义（其实还因为全局变量默认的连接类型是extern，即外连接），所以，当同一个程序中有两个或两个以上文件含有上述任一个定义都会导致多重定义链接错误。

因为头文件被设计用来包含在多个源文件中，所以不应该含有变量或者函数的定义。

对于头文件不应该含有定义这一规则，有三个例外：类定义、枚举的定义、值在编译时就已知的const对象、inline函数。这些实体可以在多个源文件中定义，只要每个源文件中的定义是相同的。

在头文件中定义这些实体，是因为编译器需要它们的定义（不只是声明）来产生代码。例如：为了产生能定义和使用类对象的代码，编译器需要知道组成该类型的数据成员。同样还需要知道能够在这些对象上执行的操作。而类定义正好提供了这些信息。

const对象（变量）默认是定义该变量的文件的局部变量，连接类型为内连接。所以，当多个源文件include包含同一个含有const对象定义的头文件时，不会产生多重定义的链接错误。这是因为，实质上每个包含该头文件的源文件都有了自己的const变量，都为它分配的存储空间，其名称和值都一样。同时，因为const变量默认连接类型是内连接，所以不会产生多重定义的链接错误。

在大部分的编译器实现中，编译器都会用相应的常量表达式来替换对这些const变量的使用。所以，在实践中不会有任何存储空间用于存储 用常量表达式初始化的const变量。

如果const变量不是用常量表达式初始化的，那么它就不应该在头文件中定义。它应该和其他的变量一样，应该定义在一个源文件中并初始化，在头文件中为它添加extern声明，以便被多个文件共享。

外连接

全局变量、全局函数默认是外连接的。

内连接

类定义、全局常量、const对象（变量）、typedef类型、宏定义 默认为内连接的。另外，定义时被显示加上static关键字的全局变量和全局函数，具有文件作用据，连接类型也为内连接。

默认为内连接的标识符，如果显示加上extern关键字，即变成外连接。

外连接标识符的使用

在使用外连接的实体的时候，可以include其定义所在的文件（错误的方法，产生链式错误：多重定义），还可以include其声明所在的文件。也可以采用第三种方法：直接在使用外连接实体的文件中，直接对外连接实体进行一次extern声明（若外连接实体类型为函数，则不用extern关键字，函数原型OK了）。