C++ 关于声明，定义，类的定义，头文件作用，不具名空间

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

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的声

明，可以通过编译，但是如果在所有编译单元（任何一个.cpp文件）中没有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;

那么编译过程不会出错，但在链接过程中，由于目标代码中有两个全局域的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 则因为是内部链接特性，所以无法链接到。

4. 关于头文件。

//head.h

int x;

//source1.cc

#include “head.h”

//source2.cc

#include “head.h”

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

上面的例子编译时没有问题，而在链接时会因重复定义的全局变量x而出错。

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

那么如果 head.h 如下这么写呢，是否防止了x的链接时重定义出错呢？（注：这里应该引起注意，很多同学不明白头文件中

#ifndef ...#define...#endif 起作用的范围和时间）

//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的，但它的作用是防止头文件在同一编译单元被重复引用（#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! 所以类的定义可以写在头文件中！

C++ 中 static 和 anonymouse namespace 的差别 
记得以前一个同事问我为什么程序里使用了 anonymouse namespace ，想了想， 就回答说其实就是保持局部性（这也是我

的目的），然后就有人说为什么不用static，嗯，似乎这两个东西乍一看没什么区别，自己便Google了一下，发现有一个原因

就是 anonymouse namespace (无名空间)里的 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; 
} 

也有人认为使用 anonymouse namespace比较好，因为static的方式被C++98标准所批评，呵呵，总体来说，其实你完全

可以用anonymouse namespace代替static。

//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

};