c++高级---C++声明、定义、类的定义、头文件作用、头文件重复引用，不具名空间以及编译器编译链接过程

C++声明、定义、类的定义、头文件作用、头文件重复引用，不具名空间

转自：http://www.cnblogs.com/rocketfan/archive/2009/10/02/1577361.html  

首先说我的补充：（对声明和定义的深入理解和总结）

关于声明和定义，具体指类、函数和变量（或对象）的声明和定义。（这里讨论的变量和函数都是全局的，不是类成员）

相同点：对编译器来说都是符号（编译器也只能识别他是个符合），声明就会在符合表中留下一列等待填充的空白，即不完整的等待填充一行，而定义就是符合表中完整的一行。在编译cpp成obj时，这里面变量、函数和类三种东西看成并列地位，即都是一个名字，符号表中的一列（可以先简单认为obj的符号表中只有两列即符号名字和地址）

不同点，在使用上这三种符合的声明和定义有所区分：【定义类和变量是原子性，定义类不是原子性，还要用这个类去定义别的东西】

（1）对于变量，由于变量的定义和声明是同一语句如int a; 所以规定声明必须使用extern关键字以区别是声明而不是定义。

（2）对于函数，由于定义有个大括号包住的函数体，而声明没有大括号的函数体，所以它的声明和定义不需要多余的如extern关键字，即带大括号的是定义，不带的是声明。

（3）对与类，在形式上和函数一样，名子带上大括号就是定义（定义一个类型），不带大括号的是声明。但他有特殊之处，即不能先声明类（即不带大括号），然后定义这个声明的类的实例，再在后面或在其它cpp文件中定义具体的类，而变量和函数是可以先声明然后在链接的时候从其它文件中找的。

类之所以不能这样干，是因为，定义一个东西的干的事情主要就是为这个东西分配具体大小的内存，如果先声明一个类，然后定义这个类的实例，编译时（还没链接），就无法确定给这个实例到底分配多大的内存空间。变量和函数可以这样干是因为不需要再定义这两个东西的实例，即他们两个本事就是原子性的实体了，不需要用他们去创建一个原子实体。从上面分析可以看出，只要不涉及分配内存的事情，都可以先声明类，然后使用类，定义类在后面或在其它cpp文件中，实际上类的声明主要用在先声明，然后定义这个声明好的类的指针或引用（这个两个东西实体一般都固定分配4个字节）。关于类的声明和定义参见：http://blog.csdn.net/abc78400123/article/details/7599466

 正是因为类的这个方面的特殊性，所以规定类的定义可以在多个cpp中，编译器不检查这中冲突（不得不这样做），而变量和函数是不行的（有的书上说类定义不占内存空间而函数和变量定义占内存空间，我认为这中说法不太好，实际上类和函数都在代码区也占内存空间，变量在数据区）。使用时也是把类定义在一个头文件中，在不同的cpp中展开，即完成了在不同的cpp中定义同一个类。我进一步猜测，也正因为这样，类定义体中不能像c#或java那样直接包含成员变量的定义并初始化，实际上类定义体中的所有东西都被认为是声明（要不然的话定义类的同时就会定义一堆其它的东西，就乱了，类体的作用就是为了描述定义这个类的实例时要分配多大的内存空间），即使函数实现在了类体中也被默认是inline内联的函数（对外不导出，也就是说其它cpp中看不见）。当然如果都用inline浪费空间，所以常常把函数声明写在类体中（达到描述这个类的作用就行了），而把成员函数具体定义（包括函数体）放在和这个类定义的头文件对应的cpp文件中，这也是为什么c++在定义类的时候分头文件和cpp文件，甚至有的书上说头文件中是类的声明，cpp文件中是类的实现（当然这种说法我也不很认同，他没分清是类的定义还是类体中东西的定义，严格的说头文件是类体中所有东东都必然是声明，cpp中是所有类体中东东的实现，类的实现完全可以不要，完全可以把函数全部称为inline的，完全可以把成员变量在构造函数被调用的时候分配内存并填充数据。类的定义就是类名加上大括号，所以类的定义都在头文件中，cpp才是这个类定义所在的头文件的附属，因为完全可以不要cpp而把函数实现都写成inline的）。

也正是因为类的这个方面的特殊性，类定义（类名加上大括号）中的所要成员变量都不能直接初始化，因为他们被认为是声明（虽然没有extern），只起描述这个类的作用。对于类中的静态成员变量和常量成员变量也是先声明，然后在cpp中定义静态变量和常变量并初始化（这里要注意声明static和const的变量不用初始化，而定义这两个东西的时候必须同时初始化，引用和他们两个类似）

 说了这么多，有点绕，简单点可以认为，类定义体中（即大括号中）包含的全部是其它实体的描述，不能定义类的同时定义了其它的东西（个别少见情况除外，但不违背这里描述的原理），在使用类的成员时，再根据这个描述去其它obj中找到对应的实体。而包含在类体中的成员就看成是个描述（或就是个头衔名），这个描述具体定义在外部，只不过定义在外部的成员的名字都加上了一个姓：类名。从编译器和连接器的角度来看，这个头衔名包含在类体中的姓类名的成员函数（或变量）和全局的函数（或变量）没什么区别，都是函数（或变量）。而类定义体中也不是定义了新的东西，他只不过包含了在其它地方定义好了的东西的描述或引用头衔而已。总之类定义就是描述作用（这个描述就是给new关键字看的），描述这个类的实例将占多大内存，将具有什么功能而已。类体中并没有定义新的东西，类体也是个外包，包含了在其它地方定义好了的东西的描述。

 

 

下面是原网页的内容： 

1.  编译单元，一个.cc，或.cpp作为一个编译单元.生成.o

2.  普通数据类型的定义，声明，函数的定义声明（类函数是一样的)

• extern int x; //变量是声明，并未实际分配地址，未产生实际目标代码

      void print(); // 函数声明，  未产生实际目标代码

      如int x; int x = 3 ; void print() {}; //均为定义产生了实际目标代码。

• 声明不产生实际的目标代码，它的作用是告诉编译器，OK，我在该编译单元后面，或者其它编译单元会有这个x变量，print函数的定义。否则编译器如果发现程序用到x，print，而前面没有声明会报错。如果有声明，而没有定义，那么链接的时候会报错未定义。
• 比较常见的是我在source.cc中调用print()，而head.h中声明print（），而source.cc 中include

       head.h从而就有了print的声明，可以通过编译，但是如果在所有编译单元中没有print函数的定义，那么链 

       接的时候source.o单元就会出错，因为它试图用print函数但是找不到print的定义。

        //head.h

       void pirnt();

       //source.cc

       void foo() {

            print();

       }

• 由于声明不产生实际代码，所以可以有多个重复声明的存在。

       //source1.cc

       extern int x;

       //source2.cc

       extern int x;

      甚至同一个编译单元也可以有多各个重复声明

      //source1.cc

      extern int x;

      extern int x;

      而普通变量定义，函数定义是不允许的。

3. 同一编译单元内部的重名符号在编译期就被阻止了，而不同编译单元之间的重名符号要到链接器才会被发

     现。 

     如果你在一个 source1.cc中

     //source1.cc

     int x;

     int x;

     出现两次 int x; int x;即两个x的定义，会编译报错,x重复定义。

     如果你的

     //source1.cc

     int x;

     //source2.cc

     int x;

     g++ –o test source1.cc source2.cc

     那么编译过程不会出错，在链接过程，由于目标代码中有两个全局域的x，会链接出错，x重定义。

     不同的编程人员可能会写不同的模块，那么很容易出现这种情况，如何避免呢，namespace可以避免重名。

     google 编程规范鼓励使用不具名空间

     //source1.cc

     namespace {

     int x;

     }

     //source2.cc

     namespace {

     int x;

     }

     OK,现在不会链接出错了因为两个x不重名了，当然对于这个简单的例子只在source1.cc中用不具名命名空间就可

     避免链接出差了。

  //注

     //source1.cc

     namespace {

     int x;

     }

    //source1.cc

    static int x;

   有什么区别呢，看上去效果一样，区别在于不具名空间的x仍然具有外链接，但是由于它是不具名的，所以别的单元没办法链接到，如果

   namespace haha{

   int x;

   }  

   则在别的单元可以用haha::x访问到它，static 则因为是内部链接特性，所以无法链接到。

C++ 中 static 和 anonymouse namespace 的差别

2009-01-02 14:54  |  分类： 桌面应用开发

记得以前一个同事问我为什么程序里使用了 anonymouse namespace ，想了想 就回答说其实就是保持局部性（这也是我的目的），然后就有人说为什么不用static，嗯 似乎这两个东西乍一看没什么区别，自己便Google了一下，发现有一个原因就是 anonymousenamespace 里的 member 都是有外部链接的，只不过永远都不能被外部link到！而 static 就明确为根本没有外部链接！此时就出现问题了，在模板里无类型的参数必须是有外部链接的才可以，否则编译无法通；比如：
template <void fn()>
class Foobar
{};

namespace
{
void abc()
{
wcout<<_T(”abc”)<<endl;
};
}
static void efg()
{
wcout<<_T(”efg”)<<endl;
};
int _tmain(int argc, _TCHAR* argv[])
{
Foobar<abc>xyz //! ;这一行可以通过
Foobar<efg>rst; //! 注意这一行编译不过
return 0;
}
也有人认为使用 anon namespace比较好，因为static的方式被C++98标准所批评，呵呵 总体来说 ，其实你完全可以用anony namespace代替static。

4.  关于头文件。

     //head.h

     int x;

     //source1.cc

     #include “head.h”

     //source2.cc

     #include “head.h” 

     头文件不被编译，.cc中的引用 include “ head.h”其实就是在预编译的时候将head.h中的内容插入到.cc中。

     所以上面的例子如果

         g++ –o test source1.cc source2.cc， 同样会链时发现重复定义的全局变量x。

     因此变量定义，包括函数的定义不要写到头文件中，因为头文件很可能要被多个.cc引用。

     那么如果我的head.h如下这么写呢，是否防止了x的链接时重定义出错呢？

     //head.h

     #ifndef _HEAD_H_

     #define _HEAD_H_

     int x;

     #endif

     //source1.cc

     #include “head.h”

     //source2.cc

     #include “head.h” 

        现在是否g++ –o test source1.cc source2.cc就没有问题了呢，答案是否定的。

      所有的头文件都是应该如上加#ifndef    #endif的，但它的作用是防止头文件在同一编译单元被重复引用。

      就是说防止可能的

     //source1.cc

     #include “head.h”

     #include “head.h”

     这种情况，当然我们不会主动写成上面的形式但是，下面的情况很可能发送

     //source1.cc

     #include “head.h”

     #inlcude “a.h”

     //a.h

     #include “head.h”

     这样就在不经意见产生了同一编译单元的头文件重复引用，于是soruc1.cc 就出现了两个int x;定义。

     但是对于不同的编译单元source1.cc,source2.cc他们都是还会引用head.h的，即使#ifndef #endif的存在。

5. 关于类的声明和定义。

    class A;  //类的声明

    类的声明和普通变量声明一样，不产生目标代码，可以在同一，以及多个编译单元重复声明。

   class A {

   };  //类的定义

   类的定义就特殊一点了，可能会有疑问，为什么不能把int x;这样的变量定义放到.h中（见4）但是可以把  

   类的定义放在头文件中重复引用呢？同时类的函数非inline定义(写在类定义里面的函数是inline，除外）不能写在 

  头文件中呢。

  这是因为类的定义，只是告诉编译器，类的数据格式是如何的，实例话后对象该占多大空间。

  类的定义也不产生目标代码。因此它和普通变量的声明唯一的区别是不能在同一编译单元内出现多次。

  //source1.cc

   class A;

   class A;  //类重复声明，OK

   class A{

   };

   class A{

   };       

   class A{

       int x;

  };    //同一编译单元内，类重复定义，会编译时报错,因为编译器不知道在该编译单元，A a；的话要生产怎样的a.

         //如果class A{};定义在head.h ，而head.h 没有 

         //#ifndef  #endif 就很可能在同一编译单元出现类重复定义的编译错误情况。

 

但是在不同编译单元内，类可以重复定义,因为类的定义未产生实际代码。

  //source1.cc

  class A{

  }

  //source2.cc

  class A{

  }                      //不同编译单元，类重复定义，OK。所以类的定义可以写在头文件中！

                                

      //source1.cc

      class A{

     

      }

      //source2.cc

      class A{

          int x;

      }                      //不同编译单元,OK

 

   6. 总结

       1.在头文件中写变量的声明，函数声明，类的定义，inline函数，不要出现变量定义，类的函数非inline定义，函数定

         义。

         即在头文件中不要出现可能产生目标代码的东东。

       2.为了防止在一个编译单元内部头文件重复引用，所有头文件都要加上#ifndef   #endif

       3.鼓励在.cc中使用不具名namespace，可以有效防止不同编译单元命名冲突。

       4.相关更专业详细的介绍可以看<<大规模C++程序设计>>的第一章，会有极其好的完整介绍。

          其中提到类的定义是具有内部链接特性的，即它不是声明

          不能在同一编译单元重复出现，但是它具有内部链接，（所谓内部链接指的是该名称对于所在编译单元是局部的，在链接时不会与其他编译单元中同样 

            的名称产生命名冲突）,所以类如果要在单个编译单元之外使用它必须被定义在一个头文件中。

          对于声明和定义，书中给出的定义是：

         一个声明将一个名称引入程序，一个定义提供了一个实体（例如，类型，实例，函数）在一个程序中的唯一描述。

        5. 前面第一条说的不是很确切，按照<<大规模C++程序设计>>中的说法

            理论上头文件中可以放所有具有内部链接的东西，包括具有内部链接的定义。如

            static int x;

            static void print() {};

            但是不提倡这么做，因为每一个包含这个头文件的.cc就对应要开辟一个空间存储这个x，就是说不同编译单元都引入static int x;由于是内部链接，所以互不影响彼此。

           甚至你采用namespace也是如此，如

           在.h中

           namespace myspace {

                static int x;

           }

           不同.cc文件中都引入该头文件，在各自编译单元中调用的myspace::x也是不同的互不影响的！

            书中提到

            const int width = 3;  //见书的23页

            这样的const变量也要避免出现在头文件中，不过类似以前c语言中

            在头文件中

            #define width  3

            还是很常用的啊。难道也要在

            .h中

            extern const int width;

            .cc中

             const int width = 5;

             这样虽然可以，不过好麻烦啊，我倒觉得在.h中定义类似const int width =3 问题不大，难道编译器不会做些特殊的处理优化吗，也要每个单元分配一个单独空间？

             不过倒是也可以利用下面的方法在.h中声明一批const 变量。注意和普通static 变量不同，类的成员静态变量，静态函数是具有外部链接的。如果

static const  int  SUCCESS = 0; ,SUCCESS不是 const 仅仅是 static int，那么是不可以在类内初始化的（编译出错)，需要在某个.cc文件中初始话，因为它是具有外部链接的。(在GOOGLE编程规范中，提到禁止使用类类型的全局变量，静态成员变量视为全局变量，也禁止使用类类型）

    class code   

    {

public:

   static const result_code SUCCESS = 0;//program ended successfully

   static const result_code INVALID_ADDRESS = 1;//wrong addres

   static const result_code READ_FAIL = 2;//cannot read

   static const result_code WRITE_FAIL = 3;//cannot write

   static const result_code UNKNOWN_ACTION = 4;//dunno...

   static const result_code NOT_FOUND = 5;//key not found in paragraph

   static const result_code NO_WRITE = 6;//no write since modification

   static const result_code SYNTAX_ERR = 7;//command syntax error

   static const result_code EMPTY_CLIP = 8;//the clipboard is empty

    };

 

 

 

 

 

 

下面是C++编译链接过程

转自：http://blog.csdn.net/changyang208/article/details/8642288

GCC的编译过程

总体来说，C/C++源代码要经过：预处理、编译、汇编和链接，四步才能变成相应平台下的可执行文件。

File: hw.c

 

[cpp]  view plain copy

1. #include <stdio.h>  
2.   
3. int main(int argc, char *argv[])  
4. {  
5.   printf("Hello World!\n");  
6.   return 0;  
7. }  

如果用gcc编译，只需要一个命令就可以生成可执行文件hw：

gcc -o hw.exe  hw.c

接下来我们按照编译顺序看看编译器每一步都做了什么：

cpp hw.c -o hw.i  // 预处理 gcc -E hello.c -o hello.i


cc1 hw.i -o hw.s    // 编译 gcc -S hello.i -o hello.s 


as hw.s -o hw.o     // 汇编 gcc -c hello.s -o hello.o


ld hw.o -o hw.exe   // 链接 gcc hello.o -o hello.exe

第一步，预处理，主要处理以下指令：宏定义指令，条件编译指令，头文件包含指令。 预处理所完成的基本上是对源程序的“替代”工作。经过此种替代，生成一个没有宏定义、没有条件编译指令，头文件都被展开（递归展开）的文件。

第二步，编译，就是把C/C++代码“翻译”成汇编代码。

第三步，汇编，就是将生成的汇编代码翻译成符合一定格式的机器代码，在Linux上一般表现为ELF目标文件。

第四步，链接，将生成的目标文件和系统库文件进行链接，最终生成了可以在特定平台运行的可执行文件。为什么还要链接系统库中的某些目标文件（crt1.o, crti.o等）呢？这些目标文件都是用来初始化或者回收C运行时环境的，比如说堆内存分配上下文环境的初始化等，实际上crt也正是C RunTime的缩写。这也暗示了另外一点：程序并不是从main函数开始执行的，而是从crt中的某个入口开始的，在Linux上此入口是_start。而且默认情况下，ld是将这些系统库文件（本身也是动态库）都是以动态链接方式加入应用程序的，如果要以静态连接的方式进行，需要显示的指定ld命令的参数-static。

此外，还有一个优化阶段。优化处理是编译系统中一项比较艰深的技术。它涉及到的问题不仅同编译技术本身有关，而且同机器的硬件环境也有很大的关系。优化一部分是对中间代码的优化。 这种优化不依赖于具体的计算机。另一种优化则主要针对目标代码的生成而进行的。对于前一种优化，主要的工作是删除公共表达式、循环优化（代码外提、强度削弱、变换循环控制条件、已知量的合并等）、复写传播，以及无用赋值的删除，等等。 后 一种类型的优化同机器的硬件结构密切相关，最主要的是考虑是如何充分利用机器的各个硬件寄存器存放的有关变量的值，以减少对于内存的访问次数。另外，如何 根据机器硬件执行指令的特点（如流水线、RISC、CISC、VLIW等）而对指令进行一些调整使目标代码比较短，执行的效率比较高。

目标文件的三个表：未解决符号表，导出符号表和地址重定向表

1、编译：编译器对源文件进行编译，就是把源文件中以文本形式存在的源代码翻译成机器语言形式的目标文件的过程，在这个过程中，编译器会进行一系列的语法检查。如果编译通过，就会把对应的CPP转换成OBJ文件。

2、目标文件：由编译所生成的文件，以机器码的形式包含了编译单元里所有的代码和数据，还有一些其它信息，如未解决符号表，导出符号表和地址重定向表等。目标文件是以二进制的形式存在的。

目标文件由段组成。通常一个目标文件中至少有两个段： 
代码段：该段中所包含的主要是指令，该段一般是可读和可执行的，但一般却不可写。 
数据段：主要存放程序中要用到的各种全局变量或静态数据。一般数据段都是可读，可写，可执行的。 

      根据C++标准，一个编译单元（Translation Unit）是指一个.cpp文件以及它所include的所有.h文件，.h文件里面的代码将会被扩展到.cpp文件里，然后编译器编译该.cpp文件生成一个.obj文件。当编译器将一个工程里的所有.cpp文件都编译完毕后，再由链接器进行链接，成为一个.exe或库文件。

下面让我们来分析一下编译器的工作过程，假设我们有一个A.cpp文件，如下定义：

    int n =1;

    void FunA()

    {

       ++n;

    }

   它编译出来的目标文件A.obj就会有一个区域（或者说是段），包含以上的数据和函数，其中就有n、FunA，以文件偏移量形式给出可能就是下面这种情况：

   偏移量   内容    长度

   0x0000    n      4

   0x0004   FunA    ??

   注意：这只是说明，与实际目标文件的布局可能不一样，??表示长度未知，目标文件的各个数据可能不是连续的，也不一定是从0x0000开始。

   FunA的内容可能如下：

    0x0004 inc DWORD PTR[0x0000]

    0x00?? ret

   有另外一个B.cpp文件，定义如下：

    externint n;

    voidFunB()

    {

       ++n;

    }

   它对应的B.obj的二进制应该是：

   偏移量   内容    长度

   0x0000   FunB    ??

   这里为什么没有n的空间呢，因为n被声明为extern，这个extern关键字就是告诉编译器n已经在别的编译单元里定义了，在这个单元里就不要定义了。由于编译单元之间是互不相关的，所以编译器就不知道n究竟在哪里，所以在函数FunB就没有办法生成n的地址，那么函数FunB中就是这样的：

    0x0000 inc DWORD PTR[????]

    0x00?? ret

   解析????的工作就只能由链接器来完成了。为了能让链接器知道哪些地方的地址没有填好（????），目标文件中有一个表来告诉链接器，这个表就是“未解决符号表”，也就是unresolved symbol table。同样，提供n的目标文件也要提供一个“导出符号表”，也就是exprot symbol table，来告诉链接器自己可以提供哪些地址。

   到这里我们已经知道，一个目标文件不仅要提供数据和二进制代码，还至少要提供两个表：未解决符号表和导出符号表，来告诉链接器自己需要什么和自己能提供些什么。那么这两个表是怎么建立对应关系的呢？这里就有一个新的概念：符号。在C/C++中，每一个变量及函数都会有自己的符号，如变量n的符号就是n，函数的符号会更加复杂，假设FunA的符号就是_FunA（根据编译器不同而不同）。

   A.obj的导出符号表为

   符号      地址

      n       0x0000

 _FunA   0x0004

   未解决符号为空（因为他没有引用别的编译单元里的东西）。

   B.obj的导出符号表为

   符号    地址

_FunB   0x0000

   未解决符号表为

   符号    地址

     n      0x0001

   这个表告诉链接器，在本编译单元0x0001位置有一个地址，该地址不明，但符号是n。

   在链接的时候，链接在B.obj中发现了未解决符号，就会在所有的编译单元中的导出符号表去查找与这个未解决符号相匹配的符号名，如果找到，就把这个符号的地址填到B.obj的未解决符号的地址处。如果没有找到，就会报链接错误。在此例中，在A.obj中会找到符号n，就会把n的地址填到B.obj的0x0001处。

   但是，这里还会有一个问题，如果是这样的话，B.obj的函数FunB的内容就会变成inc DWORDPTR[0x000]（因为n在A.obj中的地址是0x0000）。由于每个编译单元的地址都是从0x0000开始，那么最终多个目标文件链接时就会导致地址重复。所以链接器在链接时就会对每个目标文件的地址进行调整。在本例中，假如B.obj的0x0000被定位到可执行文件的0x00001000上，而A.obj的0x0000被定位到可执行文件的0x00002000上，那么实现上对链接器来说，A.obj的导出符号地地址都会加上0x00002000，B.obj所有的符号地址也会加上0x00001000。这样就可以保证地址不会重复。

   既然n的地址会加上0x00002000，那么FunA中的inc DWORDPTR[0x0000]就是错误的，所以目标文件还要提供一个表，叫地址重定向表，address redirect table。

   总结一下：

   目标文件至少要提供三个表：未解决符号表，导出符号表和地址重定向表。

   未解决符号表：列出了本单元里有引用但是不在本单元定义的符号及其出现的地址。

   导出符号表：提供了本编译单元具有定义，并且可以提供给其他编译单元使用的符号及其在本单元中的地址。

   地址重定向表：提供了本编译单元所有对自身地址的引用记录。

链接器的工作顺序：

   当链接器进行链接的时候，首先决定各个目标文件在最终可执行文件里的位置。然后访问所有目标文件的地址重定义表，对其中记录的地址进行重定向（加上一个偏移量，即该编译单元在可执行文件上的起始地址）。然后遍历所有目标文件的未解决符号表，并且在所有的导出符号表里查找匹配的符号，并在未解决符号表中所记录的位置上填写实现地址。最后把所有的目标文件的内容写在各自的位置上，就生成一个可执行文件。

   实际链接的时候会更加复杂，目标文件都会把数据，代码分成好几个区，重定向是按区进行，但原理都是一样的。

重温C/C++中的特性：

   extern：这就是告诉编译器，这个变量或函数在别的编译单元里定义了，也就是要把这个符号放到未解决符号表里面去。

   static：如果static位于全局函数或者全局变量的声明前面，表明该编译单元不导出这个函数或变量，因此这个符号不能在别的编译单元中使用。

默认链接属性：对于函数和变量，默认链接是外部链接，对于const变量，默认内部链接。

外部链接的利弊：外部链接的符号在整个程序范围内都是可以使用的，这就要求其他编译单元不能导出相同的符号（不然就会报duplicated external symbols）。

内部链接的利弊：内部链接的符号不能在别的编译单元中使用。但不同的编译单元可以拥有同样的名称的符号。

 为什么常量默认为内部链接，而变量不是?

        这就是为了能够在头文件里如const int n = 0这样的定义常量。由于常量是只读的，因此即使每个编译单元都拥有一份定义也没有关系。如果一个定义于头文件里的变量拥有内部链接，那么如果出现多个编译单元都定义该变量，则其中一个编译单元对该变量进行修改，不会影响其他单元的同一变量，会产生意想不到的后果。

为什么头文件里一般只可以有声明不能有定义?

    头文件可以被多个编译单元包含，如果头文件里面有定义的话，那么每个包含这头文件的编译单元都会对同一个符号进行定义，如果该符号为外部链接，则会导致duplicatedexternal symbols链接错误。因此如果头文件里要定义，必须保证定义的符号只能具有内部链接。

为什么类的静态成员变量不可以就地初始化?

    由于class的声明通常是在头文件里，如果允许这样做，其实就相当于在头文件里定义了一个非const变量。 

头文件里内联函数被拒绝会怎样？

    如果定义于头文件里的内联函数被拒绝，那么编译器会自动在每个包含了该头文件的编译单元里定义这个函数，并且不导出符号。

如果被拒绝的内联函数里定义了静态局部变量，这个变量会被定义于何处？

     早期的编译器会在每个编译单元里定义一个，并因此产生错误的结果，较新的编译器会解决这个问题，手段未知。

在C++环境下使用C函数的时候，常常会出现编译器无法找到C函数定义，从而导致链接失败的情况，应该如何解决这种情况呢？
　　C++语言在编译的时候为了解决函数的多态问题，会将函数名和参数联合起来生成一个中间的函数名称，而C语言则不会，因此会造成链接时找不到对应函数的情况，此时C函数就需要用extern “C”进行链接指定，这告诉编译器，请保持我的名称，不要给我生成用于链接的中间函数名。例如，假设某个函数的原型为：
　　void foo( int x, int y );
　　该函数被C编译器编译后在符号表中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字（不同的编译器可能生成的名字不同，但是都采用了相同的机制，生成的新名字称为“mangled name”）。
　　_foo_int_int这样的名字包含了函数名、函数参数数量及类型信息，C++就是靠这种机制来实现函数重载的。