C++ 内链接 外链接

　　编译的时候(假如编译器是VS)，是以源文件cpp文件为单位，编译成一个个的obj文件，然后再通过链接器把不同的obj文件链接起来。如果一些变量或函数的定义是内连接的话，链接器链接的时候就不会拿它们去与obj比较看有没有重复定义，一个源文件中即使是extern声明的变量或函数也不能使用另外一个源文件中的内连接的变量或函数。而如果是外连接的话则需要在不同的obj中比较是否有重定义。除了做这样的检查外，链接器还会查看通过extern修饰的变量或函数声明在其他obj中的定义。综上定义如下：

内部连接：如果一个名称对于它的编译单元（经过预处理后的cpp文件）来说是局部的，并且在连接的时候不可能与其它编译单元中的同样的名称相冲突，则这个名称具有内部连接.即具有内部连接的名称不会被带到目标文件中。

外部连接：在一个多文件程序中,如果一个名称在连接时可以和其他编译单元交互,那么这个名称就具有外部连接。即具有外部连接的名称会引入到目标文件中，由连接程序进行处理。这种符号在整个程序中必须是唯一的。

以下情况是内连接:

　　1.所有的声明

　　2.命名空间(包括全局命名空间)中的静态自由（非类的成员函数，也非友元函数）函数、静态友元函数、静态变量的定义

　　3.enum定义

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

　　5.类的定义

　　6.命名空间中const常量定义

　　7.union的定义

以下情况是外连接:

1.类非inline函数总是外连接。包括类成员函数和类静态成员函数

2.类静态成员变量总是外连接。

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

下面举例说明：

　　1.声明、enum定义、union定义是内连接

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

// main.cpp

typedef int Int;           //typedef 声明，内连接

enum Color{ red };     //enum定义,内连接

union X                    //union定义，内连接
{
       long a;
       char b[];
};

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[];
};              

2.命名空间中静态自由函数、静态友元函数、静态变量、const常量定义是内连接

// main.cpp

namespace test
{
    int foo();     //函数声明，内连接

    static int i = ;     //命名空间静态变量定义，内连接

    static int foo() { return ;}     //命名空间静态函数定义，内连接

}

static int i = ;         //全局静态变量定义，内连接

static int foo() {return ;}     //全局静态函数定义，内连接

const int k = ;         //全局const常量定义，内连接

int main(void)
{
    return ;
}

//a.cpp

namespace test
{
    int i = ;     //命名空间变量定义，外连接

    int foo() {return ;}     //命名空间函数定义，外连接

}

int i = ; 　　//全局变量定义，外连接

int k = ; 　　//全局变量定义，外连接

int foo()     //全局函数定义，外连接
{
    return ;
}  

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

5.类定义总是内连接，而非inline类成员函数定义总是外连接，不论这个成员函数是静态、虚拟还是一般成员函数，类静态数据成员定义总是外连接。

　　类的定义有内部连接。如果不是，想象一下你在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 = ;     //类静态数据成员定义，外连接

void D::foo()     //类成员函数定义，外连接
{
    cout << "D::foo in main.cpp" <<endl;
}

int main()         //main函数，全局自由函数，外连接
{
    B b;
    D d;
    return ;
}

//a.cpp

class B
{
    int k;
};

struct D
{
    int d;
};    

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

1.类的非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错。

2.类静态成员变量总是外连接。

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

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

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

// main.cpp

inline int foo()          //inline全局函数，内连接
{
    return ;
} 

class Bar             //类定义，内连接
{
public:
    static int f() { return ;}     //inline 类静态函数，内连接
    int g(int i) { return i;}     //inline 类成员函数，内连接
};

class Base
{
public:
    inline int k();         //类成员函数声明，内连接
};

inline int Base::k()        //inline 类成员函数，内连接
{
    return ;
} 

int main(void)
{
    return ;
}        

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