外部连接，内部连接，源文件的组织

一、前提：

1. 声明和定义

  一个声明将一个名称引入一个作用域; 在c++中，在一个作用域中重复一个声明是合法的。

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

 

   类型

        简单类型和复合类型：

            声明： typedef int  INT32;

            定义：

                 struct A{

                      int i;

                 };

                 union B{

                 };

 

                 int  C[10];

         类：

            声明：class bar;

            定义：class bar {

                        int a;

                        bar ();

                      };

            实现：

                      bar::bar()

                      {

                           a = 1;

                      }

   类型的类型：

        模板类：

             声明：

                     template <class T> class Z;

             定义：

                     template <class T>

                     class Z

                     {

                     }

 

             实例化： Z<int>;

   变量:

         声明： extern int i;

         定义： int i;

   常量：

         声明:

         定义：const float pi = 3.141593;

 

   友元：

      类友元：

         声明：friend test;

         定义：

      函数友元：

         声明：friend void f();

         定义：

 

   函数

       非inline 函数：

               声明：int foo(int,int);

                定义：int foo(int x,int y)

                         {

                         }

        inline 函数：

   名字空间：

   模板：

          函数模版：

                1. 函数模板声明：

                    template <typename  type> type min(Type t1,Type t2);

                2. 函数模板定义：

                    template <typename type>

                    type min(Type t1,Type t2)

                    {

                          

                    }

           类模板：

                1. 类模板的声明

                2. 类模板的定义

                3. 类模板的实现

2.自由函数

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

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

 

二 内部连接和外部连接

 

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

    以下情况有内部连接:

         a)所有的声明

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

         c)enum定义  union的定义 struct 的定义

         d)类的定义

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

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

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

         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;

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

 

 

三 外部连接和内部连接 与 源文件的组织

 

具有外连接的名字，为了保证只被定义一次，一般都放在一个编译单元内，即.cpp或者其他suffix的非头文件的文件里。

 

具有内部连接的名字，可以在多个编译单元内定义，而互不影响。但是为了保证在多个编译单元内对某个名字定义的一致性（非定义的唯一性），最好将这些具有内部连接特性而且需要在多个单元内使用而且要保持一致的名字定义在.h 的头文件中。

 

先从编译器和连接器角度来，分析类型和函数的连接性和源文件组织。

 1. 类型：

 首先类型具有内连接性，他只在编译单元内定义的时候才能够使用。编译以后，所有定义为该类型的变量，都分配了该类型的大小的内存，生成binary文件后，类型定义已经不复存在，只有在编译的时候存在。

          对同一名字的类型，为了保证在多个编译单元内有一致性，需要在各个单元有一致的定义，这样才能够保证有一样的变量大小，才能够互相操作。这就要求它在最好定义在一个头文件中，多个编译单元都包含这个头文件，这样这些编译单元就可以互操作了。

请看下面的例子：

       t1.h

    struct t{
         int a;
         int b;
     };

      f.cpp

#include "t1.h"
#include <iostream>
using namespace std;

void f(struct t v)
{
    cout<<v.a<<endl;
    cout <<v.b<<endl;
}

   t2.h

struct t
{
    int a;
};

void f(struct t vt);

main.cpp

#include "t2.h"

int main(int argc, char* argv[])
{
    t vt;
    vt.a = 1;
    f(vt);
}

 

2.函数：

     函数编译完成后是一组指令，如果在多个单元都有对一个名字定义的话，当连接这些编译单元的时候，由于存在同名的多个定义，在调用函数的地方，就会不知道到应该跳到那个地方去。

     因此，需要将函数的声明写到头文件里面去，将定义放在一个编译单元内部，从而保证对这个名字的使用都是执行同一组指令。

 

3.变量

     变量编译完成后就是对一块内存。变量的名字就是对应于这块内存的首地址。因此必须保证具有外连接的变量，一个名字只对应一个定义，不然就会连接的时候就无法对一个变量名字分配一个唯一的地址。

4. 类

 类中的函数应该都是声明。 类实现中的函数才是函数的定义。