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
- #include <stdio.h>
- int main(int argc, char *argv[])
- {
- printf("Hello World!\n");
- return 0;
- }
如果用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文件。
目标文件由段组成。通常一个目标文件中至少有两个段：
代码段：该段中所包含的主要是指令，该段一般是可读和可执行的，但一般却不可写。
数据段：主要存放程序中要用到的各种全局变量或静态数据。一般数据段都是可读，可写，可执行的。
下面让我们来分析一下编译器的工作过程，假设我们有一个A.cpp文件，如下定义：
_FunB