C++中头文件与源文件的做用详解

时间 2019-12-11

标签 c++ 中头文件详解栏目 C&C++ 繁體版

原文原文链接

1、C++ 编译模式html

一般，在一个 C++ 程序中，只包含两类文件―― .cpp 文件和 .h 文件。其中，.cpp 文件被称做 C++ 源文件，里面放的都是 C++ 的源代码；而 .h 文件则被称做 C++ 头文件，里面放的也是 C++ 的源代码。mysql

C++ 语言支持"分别编译"（separatecompilation）。也就是说，一个程序全部的内容，能够分红不一样的部分分别放在不一样的 .cpp 文件里。.cpp 文件里的东西都是相对独立的，在编译（compile）时不须要与其余文件互通，只须要在编译成目标文件后再与其余的目标文件作一次连接（link）就好了。好比，在文件 a.cpp 中定义了一个全局函数 "void a(){}"，而在文件 b.cpp 中须要调用这个函数。即便这样，文件 a.cpp 和文件 b.cpp 并不须要相互知道对方的存在，而是能够分别地对它们进行编译，编译成目标文件以后再连接，整个程序就能够运行了。ios

这是怎么实现的呢？从写程序的角度来说，很简单。在文件 b.cpp 中，在调用 "void a()" 函数以前，先声明一下这个函数 "voida();"，就能够了。这是由于编译器在编译 b.cpp 的时候会生成一个符号表（symbol table），像 "void a()" 这样的看不到定义的符号，就会被存放在这个表中。再进行连接的时候，编译器就会在别的目标文件中去寻找这个符号的定义。一旦找到了，程序也就能够顺利地生成了。程序员

注意这里提到了两个概念，一个是"定义"，一个是"声明"。简单地说，"定义"就是把一个符号完完整整地描述出来：它是变量仍是函数，返回什么类型，须要什么参数等等。而"声明"则只是声明这个符号的存在，即告诉编译器，这个符号是在其余文件中定义的，我这里先用着，你连接的时候再到别的地方去找找看它究竟是什么吧。定义的时候要按 C++ 语法完整地定义一个符号（变量或者函数），而声明的时候就只须要写出这个符号的原型了。须要注意的是，一个符号，在整个程序中能够被声明屡次，但却要且仅要被定义一次。试想，若是一个符号出现了两种不一样的定义，编译器该听谁的？sql

这种机制给 C++ 程序员们带来了不少好处，同时也引出了一种编写程序的方法。考虑一下，若是有一个很经常使用的函数 "void f() {}"，在整个程序中的许多 .cpp 文件中都会被调用，那么，咱们就只须要在一个文件中定义这个函数，而在其余的文件中声明这个函数就能够了。一个函数还好对付，声明起来也就一句话。可是，若是函数多了，好比是一大堆的数学函数，有好几百个，那怎么办？能保证每一个程序员均可以完彻底全地把全部函数的形式都准确地记下来并写出来吗？数据库

2、什么是头文件函数

很显然，答案是不可能。可是有一个很简单地办法，能够帮助程序员们省去记住那么多函数原型的麻烦：咱们能够把那几百个函数的声明语句全都先写好，放在一个文件里，等到程序员须要它们的时候，就把这些东西所有 copy 进他的源代码中。布局

这个方法当然可行，但仍是太麻烦，并且还显得很笨拙。因而，头文件即可以发挥它的做用了。所谓的头文件，其实它的内容跟 .cpp 文件中的内容是同样的，都是 C++ 的源代码。但头文件不用被编译。咱们把全部的函数声明所有放进一个头文件中，当某一个 .cpp 源文件须要它们时，它们就能够经过一个宏命令 "#include" 包含进这个 .cpp 文件中，从而把它们的内容合并到 .cpp 文件中去。当 .cpp 文件被编译时，这些被包含进去的 .h 文件的做用便发挥了。学习

举一个例子吧，假设全部的数学函数只有两个：f1 和 f2，那么咱们把它们的定义放在 math.cpp 里：ui

/* math.cpp */
double f1()
{
//do something here....
return;
}
double f2(double a)
{
//do something here...
return a * a;
}
/* end of math.cpp */

并把"这些"函数的声明放在一个头文件 math.h 中：

/* math.h */
double f1();
double f2(double);
/* end of math.h */

在另外一个文件main.cpp中，我要调用这两个函数，那么就只须要把头文件包含进来：

/* main.cpp */
#include "math.h"
main()
{
int number1 = f1();
int number2 = f2(number1);
}
/* end of main.cpp */

这样，即是一个完整的程序了。须要注意的是，.h 文件不用写在编译器的命令以后，但它必需要在编译器找获得的地方（好比跟 main.cpp 在一个目录下）main.cpp 和 math.cpp 均可以分别经过编译，生成 main.o 和 math.o，而后再把这两个目标文件进行连接，程序就能够运行了。

3、#include

#include 是一个来自 C 语言的宏命令，它在编译器进行编译以前，即在预编译的时候就会起做用。#include 的做用是把它后面所写的那个文件的内容，完完整整地、一字不改地包含到当前的文件中来。值得一提的是，它自己是没有其它任何做用与副功能的，它的做用就是把每个它出现的地方，替换成它后面所写的那个文件的内容。简单的文本替换，别无其余。所以，main.cpp 文件中的第一句（#include"math.h"），在编译以前就会被替换成 math.h 文件的内容。即在编译过程将要开始的时候，main.cpp 的内容已经发生了改变：

/* ~main.cpp */
double f1();
double f2(double);
main()
{
int number1 = f1();
int number2 = f2(number1);
}
/* end of ~main.cpp */

很少很多，刚恰好。同理可知，若是咱们除了 main.cpp 之外，还有其余的不少 .cpp 文件也用到了 f1 和 f2 函数的话，那么它们也统统只须要在使用这两个函数前写上一句 #include "math.h" 就好了。

4、头文件中应该写什么

经过上面的讨论，咱们能够了解到，头文件的做用就是被其余的 .cpp 包含进去的。它们自己并不参与编译，但实际上，它们的内容却在多个 .cpp 文件中获得了编译。经过"定义只能有一次"的规则，咱们很容易能够得出，头文件中应该只放变量和函数的声明，而不能放它们的定义。由于一个头文件的内容其实是会被引入到多个不一样的 .cpp 文件中的，而且它们都会被编译。放声明固然没事，若是放了定义，那么也就至关于在多个文件中出现了对于一个符号（变量或函数）的定义，纵然这些定义都是相同的，但对于编译器来讲，这样作不合法。

因此，应该记住的一点就是，.h头文件中，只能存在变量或者函数的声明，而不要放定义。即，只能在头文件中写形如：extern int a; 和 void f(); 的句子。这些才是声明。若是写上 inta;或者 void f() {} 这样的句子，那么一旦这个头文件被两个或两个以上的 .cpp 文件包含的话，编译器会立马报错。（关于 extern，前面有讨论过，这里再也不讨论定义跟声明的区别了。）

可是，这个规则是有三个例外的:

一，头文件中能够写 const 对象的定义。由于全局的 const 对象默认是没有 extern 的声明的，因此它只在当前文件中有效。把这样的对象写进头文件中，即便它被包含到其余多个 .cpp 文件中，这个对象也都只在包含它的那个文件中有效，对其余文件来讲是不可见的，因此便不会致使多重定义。同时，由于这些 .cpp 文件中的该对象都是从一个头文件中包含进去的，这样也就保证了这些 .cpp 文件中的这个 const 对象的值是相同的，可谓一箭双雕。同理，static 对象的定义也能够放进头文件。
二，头文件中能够写内联函数（inline）的定义。由于inline函数是须要编译器在遇到它的地方根据它的定义把它内联展开的，而并不是是普通函数那样能够先声明再连接的（内联函数不会连接），因此编译器就须要在编译时看到内联函数的完整定义才行。若是内联函数像普通函数同样只能定义一次的话，这事儿就难办了。由于在一个文件中还好，我能够把内联函数的定义写在最开始，这样能够保证后面使用的时候均可以见到定义；可是，若是我在其余的文件中还使用到了这个函数那怎么办呢？这几乎没什么太好的解决办法，所以 C++ 规定，内联函数能够在程序中定义屡次，只要内联函数在一个 .cpp 文件中只出现一次，而且在全部的 .cpp 文件中，这个内联函数的定义是同样的，就能经过编译。那么显然，把内联函数的定义放进一个头文件中是很是明智的作法。
三，头文件中能够写类（class）的定义。由于在程序中建立一个类的对象时，编译器只有在这个类的定义彻底可见的状况下，才能知道这个类的对象应该如何布局，因此，关于类的定义的要求，跟内联函数是基本同样的。因此把类的定义放进头文件，在使用到这个类的 .cpp 文件中去包含这个头文件，是一个很好的作法。在这里，值得一提的是，类的定义中包含着数据成员和函数成员。数据成员是要等到具体的对象被建立时才会被定义（分配空间），但函数成员倒是须要在一开始就被定义的，这也就是咱们一般所说的类的实现。通常，咱们的作法是，把类的定义放在头文件中，而把函数成员的实现代码放在一个 .cpp 文件中。这是能够的，也是很好的办法。不过，还有另外一种办法。那就是直接把函数成员的实现代码也写进类定义里面。在 C++ 的类中，若是函数成员在类的定义体中被定义，那么编译器会视这个函数为内联的。所以，把函数成员的定义写进类定义体，一块儿放进头文件中，是合法的。注意一下，若是把函数成员的定义写在类定义的头文件中，而没有写进类定义中，这是不合法的，由于这个函数成员此时就不是内联的了。一旦头文件被两个或两个以上的 .cpp 文件包含，这个函数成员就被重定义了。

5、头文件中的保护措施

考虑一下，若是头文件中只包含声明语句的话，它被同一个 .cpp 文件包含再屡次都没问题――由于声明语句的出现是不受限制的。然而，上面讨论到的头文件中的三个例外也是头文件很经常使用的一个用处。那么，一旦一个头文件中出现了上面三个例外中的任何一个，它再被一个 .cpp 包含屡次的话，问题就大了。由于这三个例外中的语法元素虽然"能够定义在多个源文件中"，可是"在一个源文件中只能出现一次"。设想一下，若是 a.h 中含有类 A 的定义，b.h 中含有类 B 的定义，因为类B的定义依赖了�� A，因此 b.h 中也 #include了a.h。如今有一个源文件，它同时用到了类A和类B，因而程序员在这个源文件中既把 a.h 包含进来了，也把 b.h 包含进来了。这时，问题就来了：类A的定义在这个源文件中出现了两次！因而整个程序就不能经过编译了。你也许会认为这是程序员的失误――他应该知道 b.h 包含了 a.h ――但事实上他不该该知道。

使用 "#define" 配合条件编译能够很好地解决这个问题。在一个头文件中，经过 #define 定义一个名字，而且经过条件编译 #ifndef...#endif 使得编译器能够根据这个名字是否被定义，再决定要不要继续编译该头文中后续的内容。这个方法虽然简单，可是写头文件时必定记得写进去。

C++ 头文件和源文件的区别

1、源文件如何根据 #include 来关联头文件

一、系统自带的头文件用尖括号括起来，这样编译器会在系统文件目录下查找。

二、用户自定义的文件用双引号括起来，编译器首先会在用户目录下查找，而后在到 C++ 安装目录（好比 VC 中能够指定和修改库文件查找路径，Unix 和 Linux 中能够经过环境变量来设定）中查找，最后在系统文件中查找。
#include "xxx.h"（我一直觉得 "" 和 <> 没什么区别，可是 tinyxml.h 是非系统下的都文件，因此要用 ""）

2、头文件如何来关联源文件

这个问题其实是说，已知头文件 "a.h" 声明了一系列函数，"b.cpp" 中实现了这些函数，那么若是我想在 "c.cpp" 中使用 "a.h" 中声明的这些在 "b.cpp"中实现的函数，一般都是在 "c.cpp" 中使用 #include "a.h"，那么 c.cpp 是怎样找到 b.cpp 中的实现呢？

其实 .cpp 和 .h 文件名称没有任何直接关系，不少编译器均可以接受其余扩展名。好比偶如今看到偶们公司的源代码，.cpp 文件由 .cc 文件替代了。

在 Turbo C 中，采用命令行方式进行编译，命令行参数为文件的名称，默认的是 .cpp 和 .h，可是也能够自定义为 .xxx 等等。

谭浩强老师的《C 程序设计》一书中提到，编译器预处理时，要对 #include 命令进行"文件包含处理"：将 file2.c 的所有内容复制到 #include "file2.c" 处。这也正说明了，为何不少编译器并不 care 到底这个文件的后缀名是什么----由于 #include 预处理就是完成了一个"复制并插入代码"的工做。

编译的时候，并不会去找 b.cpp 文件中的函数实现，只有在 link 的时候才进行这个工做。咱们在 b.cpp 或 c.cpp 中用 #include "a.h" 其实是引入相关声明，使得编译能够经过，程序并不关心实现是在哪里，是怎么实现的。源文件编译后成生了目标文件（.o 或 .obj 文件），目标文件中，这些函数和变量就视做一个个符号。在 link 的时候，须要在 makefile 里面说明须要链接哪一个 .o 或 .obj 文件（在这里是 b.cpp 生成的 .o 或 .obj 文件），此时，链接器会去这个 .o 或 .obj 文件中找在 b.cpp 中实现的函数，再把他们 build 到 makefile 中指定的那个能够执行文件中。

在 Unix下，甚至能够不在源文件中包括头文件，只须要在 makefile 中指名便可（不过这样大大下降了程序可读性，是个很差的习惯哦^_^）。在 VC 中，一帮状况下不须要本身写 makefile，只须要将须要的文件都包括在 project中，VC 会自动帮你把 makefile 写好。

一般，C++ 编译器会在每一个 .o 或 .obj 文件中都去找一下所须要的符号，而不是只在某个文件中找或者说找到一个就不找了。所以，若是在几个不一样文件中实现了同一个函数，或者定义了同一个全局变量，连接的时候就会提示 "redefined"。

综上所诉

.h文件中能包含：

类成员数据的声明，但不能赋值
类静态数据成员的定义和赋值，但不建议，只是个声明就好。
类的成员函数的声明
非类成员函数的声明
常数的定义：如：constint a=5;
静态函数的定义
类的内联函数的定义

不能包含：

1．全部非静态变量（不是类的数据成员）的声明

2。默认命名空间声明不要放在头文件，using namespace std;等应放在.cpp中，在 .h 文件中使用 std::string

您可能感兴趣的文章:

文章同步发布： https://www.geek-share.com/detail/2769307191.html