一C++ 编译模式

通常在一个 C++ 程序中只包含两类文件 .cpp 文件和 .h 文件其中.cpp 文件被称作 C++ 源文件里面放的都是 C++ 的源代码而 .h 文件则被称作 C++ 头文件里面放的也是 C++ 的源代码

C++ 语言支持"分别编译"separatecompilation也就是说一个程序所有的内容可以分成不同的部分分别放在不同的 .cpp 文件里.cpp 文件里的东西都是相对独立的在编译compile时不需要与其他文件互通只需要在编译成目标文件后再与其他的目标文件做一次链接link就行了比如在文件 a.cpp 中定义了一个全局函数 "void a(){}"而在文件 b.cpp 中需要调用这个函数即使这样文件 a.cpp 和文件 b.cpp 并不需要相互知道对方的存在而是可以分别地对它们进行编译编译成目标文件之后再链接整个程序就可以运行了

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

注意这里提到了两个概念一个是"定义"一个是"声明"简单地说"定义"就是把一个符号完完整整地描述出来它是变量还是函数返回什么类型需要什么参数等等而"声明"则只是声明这个符号的存在即告诉编译器这个符号是在其他文件中定义的我这里先用着你链接的时候再到别的地方去找找看它到底是什么吧定义的时候要按 C++ 语法完整地定义一个符号变量或者函数而声明的时候就只需要写出这个符号的原型了需要注意的是一个符号在整个程序中可以被声明多次但却要且仅要被定义一次试想如果一个符号出现了两种不同的定义编译器该听谁的 这种机制给 C++ 程序员们带来了很多好处同时也引出了一种编写程序的方法考虑一下如果有一个很常用的函数 "void f() {}"在整个程序中的许多 .cpp 文件中都会被调用那么我们就只需要在一个文件中定义这个函数而在其他的文件中声明这个函数就可以了一个函数还好对付声明起来也就一句话但是如果函数多了比如是一大堆的数学函数有好几百个那怎么办能保证每个程序员都可以完完全全地把所有函数的形式都准确地记下来并写出来吗

二什么是头文件

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

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

举一个例子吧假设所有的数学函数只有两个f1 和 f2那么我们把它们的定义放在 math.cpp 里

/* 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然后再把这两个目标文件进行链接程序就可以运行了

三#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" 就行了


四头文件中应该写什么

通过上面的讨论我们可以了解到头文件的作用就是被其他的 .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 文件包含这个函数成员就被重定义了

五头文件中的保护措施

考虑一下如果头文件中只包含声明语句的话它被同一个 .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++ 头文件和源文件的区别

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

  • 1系统自带的头文件用尖括号括起来这样编译器会在系统文件目录下查找
  • 2用户自定义的文件用双引号括起来编译器首先会在用户目录下查找然后在到 C++ 安装目录比如 VC 中可以指定和修改库文件查找路径Unix 和 Linux 中可以通过环境变量来设定中查找最后在系统文件中查找

#include "xxx.h"我一直以为 "" 和 <> 没什么区别但是 tinyxml.h 是非系统下的都文件所以要用 ""

二头文件如何来关联源文件

这个问题实际上是说已知头文件 "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://blog.csdn.net/qq_35038153/article/details/71293265