理解 C++ 中的头文件和源文件的感化

发布日期:2019-07-23 19:42:32 阅读数: 601次 来源: 作者:

一、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
本文由亚博编辑整理亚博手机app