• C++头文件的作用

    2019-07-14 01:41:58
    通常,在一个C++程序中,只包含两类文件——.cpp文件和.h文件。其中,.cpp文件被称作C++源文件,里面放的都是C++的源代码;而.h文件则被称作C++头文件,里面放的也是C++的源代码。 C++支持“分别编译”(separate ...

    C++编译模式

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

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

    这是怎么实现的呢?
    在文件b.cpp中,在调用“void a()”函数之前,先声明一下这个函数“void a();”,就可以了。这是因为编译器在编译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();的句子。这些才是声明。如果写上int a;或者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使得编译器可以根据这个名字是否被定义,再决定要不要继 续编译该头文中后续的内容。这个方法虽然简单,但是写头文件时一定记得写进去。

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

    这个问题实际上是说,已知头文件“a.h”声明了一系列函数(仅有函数原型,没有函数实现),“b.cpp”中实现了这些函数,那么如果我想在“c.cpp”中使用“a.h”中声明的这些在“b.cpp”中实现的函数,通常都是在“c.cpp”中使用#include “a.h”,那么c.cpp是怎样找到b.cpp中的实现呢?

    其实.cpp和.h文件名称没有任何直接关系,很多编译器都可以接受其他扩展名。
    谭浩强老师的《C程序设计》一书中提到,编译器预处理时,要对#include命令进行“文件包含处理”:将headfile.h的全部内容复制到#include “headfile.h”处。
    这也正说明了,为什么很多编译器并不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中指定的那个可以执行文件中。

    在VC中,一帮情况下不需要自己写makefile,只需要将需要的文件都包括在project中,VC会自动帮你把makefile写好。
    通常,编译器会在每个.o或.obj文件中都去找一下所需要的符号,而不是只在某个文件中找或者说找到一个就不找了。因此,如果在几个不同文件中实现了同一个函数,或者定义了同一个全局变量,链接的时候就会提示“redefined”.

    #ifndef

    头文件中的#ifndef是一个很关键的东西。#ifndef的作用:防止多个源文件同时包含同一个头文件时产生的声明冲突。
    一般格式:

    #ifndef <标识>
    #define <标识>
    ...
    ...
    #endif
    

    <标识>在理论上来说可以是自由命名的,但每个头文件的这个<标识>都应该是唯一的。标识的命名规则一般是头文件名全大写,前后加下划线,并把文件名中的“.”也变成下划线,如:stdio.h:

    #ifndef _STDIO_H_
    #define _STDIO_H_
    ...
    ...
    #endif
    

    .hpp文件

    .hpp文件的实质就是将.cpp的实现代码混入.h头文件中,定义与实现都包含在同一个文件,则该类的调用者只需要include该hpp文件即可,无需再将cpp加入到project中进行编译。而实现代码将直接编译到调用者的obj文件中,不再生成单独的obj,采用hpp将大幅减少调用project中的cpp文件数与编译次数,也不用再发布烦人的lib与dll,因此非常适合用来编写公用的开源库。

    1. 是Header Plus Plus的缩写
    2. 是一般模板类的头文件
    3. 一般来说,.h里面只有声明,没有实现,而.hpp里声明和实现都有,后者可以减少.cpp的数量
    4. .h里面可以有using namespace std,而.hpp里面则无

    .hpp要注意的问题:

    1. 不可包含全局对象和全局函数
      由于hpp本质上是作为.h被调用者include,所以当hpp文件中存在全局对象或者全局函数时,若该hpp被多个调用者include,将在链接时导致符号重定义错误。要避免这种情况,需要去除全局对象,将全局函数封装为类的静态方法。
    2. 类之间不可以循环调用
      在.h和.cpp场景中,当两个类或者多个类之间有循环调用关系时候,只要预先在头文件中做被调用类的声明即可,如下:
    class B;
    class A 
    

    reference:
    http://blog.chinaunix.net/uid-24118190-id-75239.html

    展开全文
  • c++头文件的简单使用

    2016-04-16 00:15:09
    c++的文件分为两个部分,头文件.h和执行文件.cpp,一个c++文件可以由多个头文件和执行文件组成,头文件不会被编译,但它的内容会被编译,当.cpp文件编译时,包含的头文件内容会被合到相应的.cpp文件中进行编译,c++...

    c++的文件分为两个部分,头文件.h和执行文件.cpp,一个c++文件可以由多个头文件和执行文件组成,头文件不会被编译,但它的内容会被编译,当.cpp文件编译时,包含的头文件内容会被合到相应的.cpp文件中进行编译,c++支持分别编译,一个.cpp文件中可以使用另一个.cpp的函数,但是它们之间的编译可以是独立的,此时只需要在使用的那个.cpp文件中声明需要的那个函数就行,声明与定义是不同的两个概念,声明只需要写出函数的形式,表明有这么个东西就行,定义需要完整地描述函数的实现过程,如果需要声明的东西太多,我们就可以将它们都放在头文件里,这样,只需要在.cpp里#include "头文件名"就可以使用包含的函数了,下面是一个简单的例子,实现的平台是linux ubuntu 14.04:

    建立三个文档:main.cpp、print.cpp、header.h,具体内容如下:

    -------------main.cpp---------------

    #include "header.h"
    int main()
    {
    char ch = 'a';
    print(ch);
    }

    ------------print.cpp----------------

    #include<iostream>
    using namespace std;
    void print(char ch)
    {
    //a ++;
    cout << ch << endl;
    }

    ---------header.h-------------

    void print(char);

    在linux下进入文件所在目录,然后用“g++ main.cpp -c”和“g++ print.cpp -c”编译.cpp文件,编译完成后会生成print.o和main.o两个目标文件,用“g++ print.o main.o -o ch”进行链接,最后用“./ch”运行文件,结果如下:


    头文件中不能出现定义的语句,因为声明可以进行多次,但是定义如果进行多次就会出现重定义的问题,试想如果只是在一个.cpp文件包含头文件还好,如果同时有多个.cpp文件包含同一个头文件的话,那么编译器便不知道应该听从那个定义了,如下所示,我们在头文件header.h中定义一个变量a,在main.cpp和print.cpp中同时包含该头文件,结果在链接的时候便会提示重定义问题:


    头文件中只能包含变量或者函数的声明,如:“extern int a;“和“void f();”,但有三种情况除外,const对象的定义、inline内联函数的定义、类的定义。

    1) const对象默认非extern,只在被包含文件中可见,在其他文件不可见,不会导致重定义,且const值不可更改,所有文件看到的值相同,同理stacic对象也可以定义;

    2) 内联函数不会单独进行编译,编译器会在遇到时进行内联展开,所以编译器需要看到内联函数的完整定义,c++规定,内联函数可以进行多次定义,但是在一个.cpp文件中只能出现一次,且在所有.cpp文件中定义相同,所以内联函数可以在头文件中定义。

    3) 编译器需要在类完全可见的情况下才能对类的对象进行布局,如,类的内存布局,一般情况下,把类的定义放在头文件中,而把函数成员的实现代码放在一个.cpp文件中。

    上述例外可以在不同的源文件多次定义,但是不能在同一个源文件中多次定义,为了确保同一.cpp文件不会包含多次头文件的定义,可以在头文件中使用

    #ifndef *** //名字任意取,不重复就好,一般用对应头文件名的全大写来表示,如,HEADER_H

    #define ***

    ...

    #endif

    来保证头文件不会被重复定义,下面是一个实际的例子,header.h里面已经包含了temp.h,main.cpp同时包含了header.h和temp.h,不使用#ifndef的结构,temp.h会被重复包含,其中的内容就会重定义,使用#ifndef结构,在编译前会先检查temp.h是否已经定义,若定义过则不再定义,可很好地防止重定义的情况。

    -------------main.cpp---------------

    #include "header.h"
    #include "temp.h"
    int main()
    {
    char ch = 'a';
    print(ch);
    }

    ------------print.cpp----------------

    #include<iostream>
    using namespace std;
    void print(char ch)
    {
    cout << ch << endl;
    }

    ---------header.h-------------

    #ifndef   _bbb_   
    #define   _bbb_ 
    #include "temp.h"
    void print(char);
    class b{};
    #endif

    ---------temp.h--------------

    #ifndef   _aaa_   
    #define   _aaa_   
    class aaa{};  
    #endif

    --------------------------------


    参考文献:http://www.cnblogs.com/lidabo/archive/2012/04/17/2454568.html

    展开全文
  • c++与c头文件的区别

    2018-03-03 21:35:25
    第一部分保留了c中的头文件风格,即大部分c的头文件都可以在c++中使用,也可以自定义c类型头文件c++中使用 第二部分c的标准头文件c++中去掉了.h后缀,添加了c前缀,如math.h改为cmath 第三部分就是c++自身的...

    c的头文件都是以.h结尾,如stdio.h、math.h

    c++的头文件:

    第一部分保留了c中的头文件风格,即大部分c的头文件都可以在c++中使用,也可以自定义c类型头文件在c++中使用

    第二部分c的标准头文件在c++中去掉了.h后缀,添加了c前缀,如math.h改为cmath

    第三部分就是c++自身的头文件,不带后缀,如iostream,其最大的不同就是c++类型头文件可以包含命名空间,而.h后缀的则不行


    展开全文
  • C++头文件的作用

    2019-04-14 17:31:47
    通常,在一个C++程序中,只包含两类文件——.cpp文件和.h文件。其中,.cpp文件被称作C++源文件,里面放的都是C++的源代码;而.h文件则被称作C++头文件,里面放的也是C++的源代码。 C+ +语言支持“分别编译”...

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

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

    这是怎么实现的呢?从写程序的角度来讲,很简单。在文件b.cpp中,在调用 “void a()”函数之前,先声明一下这个函数“void a();”,就可以了。这是因为编译器在编译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();的句子。这些才是声明。如果写上int a;或者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使得编译器可以根据这个名字是否被定义,再决定要不要继 续编译该头文中后续的内容。这个方法虽然简单,但是写头文件时一定记得写进去。 

     

    转自:http://blog.csdn.net/nicky_zs/article/details/2166048#comments

    展开全文
  • C++编译时,教科书中写道:#include “headfile.h”优先在当前目录查找头文件;#include 从系统默认路径查找头文件。先前以为系统默认路径是环境变量$PATH指定的路径,在系统上一查,傻了眼: -bash-3.2$ echo$PATH ...

    C++编译时,教科书中写道:#include “headfile.h”优先在当前目录查找头文件;#include < headfile.h>从系统默认路径查找头文件。先前以为系统默认路径是环境变量$PATH指定的路径,在系统上一查,傻了眼:

    -bash-3.2$ echo$PATH

    /usr/local/bin:/bin:/usr/bin:/sbin:/usr/sbin:/usr/X11R6/bin:/usr/java/j2re1.4.0/bin:/usr/atria/bin:/ccase/bin:/home/devcomp/bin

    全是bin目录,$PATH是运行可执行文件时的搜索路径,与include头文件的搜索路径无关,可能不少人犯了我这样的错误。

     

    头文件:

    1.      #include“headfile.h”

    搜索顺序为:

    ①先搜索当前目录

    ②然后搜索-I指定的目录

    ③再搜索gcc的环境变量CPLUS_INCLUDE_PATH(C程序使用的是C_INCLUDE_PATH)

    ④最后搜索gcc的内定目录

    /usr/include

    /usr/local/include

    /usr/lib/gcc/x86_64-redhat-linux/4.1.1/include

     

    各目录存在相同文件时,先找到哪个使用哪个。

    2.      #include<headfile.h>

    ①先搜索-I指定的目录

    ②然后搜索gcc的环境变量CPLUS_INCLUDE_PATH

    ③最后搜索gcc的内定目录

    /usr/include

    /usr/local/include

    /usr/lib/gcc/x86_64-redhat-linux/4.1.1/include

     

    与上面的相同,各目录存在相同文件时,先找到哪个使用哪个。这里要注意,#include<>方式不会搜索当前目录!

     

    这里要说下include的内定目录,它不是由$PATH环境变量指定的,而是由g++的配置prefix指定的(知道它在安装g++时可以指定,不知安装后如何修改的,可能是修改配置文件,需要时再研究下):

    -bash-3.2$ g++ -v

    Using built-inspecs.

    Target:x86_64-redhat-linux

    Configured with:../configure --prefix=/usr --mandir=/usr/share/man--infodir=/usr/share/info --enable-shared --enable-threads=posix--enable-checking=release --with-system-zlib --enable-__cxa_atexit--disable-libunwind-exceptions --enable-libgcj-multifile--enable-languages=c,c++,objc,obj-c++,java,fortran,ada--enable-java-awt=gtk --disable-dssi --enable-plugin--with-java-home=/usr/lib/jvm/java-1.4.2-gcj-1.4.2.0/jre--with-cpu=generic --host=x86_64-redhat-linux

    Thread model:posix

    gcc version 4.1.2 20080704(Red Hat 4.1.2-46)

     

    在安装g++时,指定了prefix,那么内定搜索目录就是:

    Prefix/include

    Prefix/local/include

    Prefix/lib/gcc/--host/--version/include

    编译时可以通过-nostdinc++选项屏蔽对内定目录搜索头文件。

     

    库文件:

    编译的时候:

    ①gcc会去找-L

    ②再找gcc的环境变量LIBRARY_PATH

    ③再找内定目录/lib /usr/lib/usr/local/lib 这是当初compilegcc时写在程序内的(不可配置的?)

     

    运行时动态库的搜索路径:

    动态库的搜索路径搜索的先后顺序是:

    ①编译目标代码时指定的动态库搜索路径(这是通过gcc 的参数"-Wl,-rpath,"指定。当指定多个动态库搜索路径时,路径之间用冒号":"分隔)

    ②环境变量LD_LIBRARY_PATH指定的动态库搜索路径(当通过该环境变量指定多个动态库搜索路径时,路径之间用冒号":"分隔)

    ③配置文件/etc/ld.so.conf中指定的动态库搜索路径;

    ④默认的动态库搜索路径/lib;

    ⑤默认的动态库搜索路径/usr/lib。

    (应注意动态库搜寻路径并不包括当前文件夹,所以当即使可执行文件和其所需的so文件在同一文件夹,也会出现找不到so的问题,类同#include<header_file>不搜索当前目录)

     

    参考资源:http://my.oschina.net/alphajay/blog/4953?from=rss

    展开全文
  • 1. #include是标准的C++头文件,任何符合标准的C++开发环境都有这个头文件。 当使用时,相当于在c中调用库函数,使用的是全局命名空间,也就是早期的c++实现;当使用的时候,该头文件没有定义全局命名空间,必须...
  • 新手在写C++程序定义类的时候,可能会犯一个错误,就是在main函数文件里定义很多类,一个文件中包含很多函数,这样程序看起来很冗杂。今天总结一下如何在C++中使用头文件来定义一个类,并在另一个文件中进行引用。 ...
  • 通常,在一个C++程序中,只包含两类文件——.cpp文件和.h文件。其中,.cpp文件被称作C++源文件,里面放的都是C++的源代码;而.h文件则被称作C++头文件,里面放的也是C++的源代码。 C+ +语言支持“分别编译”...
  • C++头文件包含注意点
  • C++头文件一览

    2018-07-23 10:05:54
    #include &lt;assert.h&gt; 设定插入点 #include &lt;ctype.h&gt; 字符处理 #include &lt;errno.h&gt; 定义错误码 #include &lt;float.h&gt; 浮点数处理 ......
  • c++ string头文件详解

    2018-12-09 21:42:45
    之所以抛弃char*的字符串而选用C++标准程序库中的string类,是因为他和前者比较起来,不必 担心内存是否足够、字符串长度等等,而且作为一个类出现,他集成的操作函数足以完成我们大多数情况下(甚至是100%)的需要。...
  • C/C++避免头文件重复包含的方法1. #ifndef2. #pragma once3. 混合使用 在实际的编程过程中,因为会使用多个文件,所以在文件中不可避免的要引入一些头文件,这样就可能会出现一个头文件被 include 多次,在C/C++中...
  • ... 1. 头文件的作用 ...在进行编译的过程中,C++的编译器只会对cpp文件进行编译,.h文件不会参与编译,而是被包含到引用了头文件的cpp文件中。例如,#include "A.h",这样有一个好处,就是在一处进...
  • 头文件不得包含函数入口,头文件不可以单独编译成一个程序,仅仅包含程序片段或者定义常,变量。 头文件专为源代码调用而写的静态包含文件,可被源代码文件中#include编译预处理指令解释,如果将头文件完整,拷贝...
  • C/C++头文件一览 C #include //设定插入点 #include //字符处理 #include //定义错误码 #include //浮点数处理 #include //对应各种运算符的宏 #include //定义各种数据类型最值的常量 #include //定义本地...
  • C++头文件的命名规则,因为C++是从C语言发展而来的,为了与C兼容,C++保留了C语言中的一些规定,其中就包括用.h作为后缀的头文件,比如大家所熟悉的:stdio.h、math.h和string.h等。但后来ANSI/ISO C++建议头文件...
  • c++头文件结构

    2017-08-21 10:57:25
    c++头文件是十分重要的,头文件是不能被编译的。c++使用通过“#include”(编译预处理指令),来使用头文件。可以简单理解成,在.cpp中的#include"1.h"指令把1.h中的代码在编译前添加到了1.cp
  • c++如何写头文件.h

    2017-10-31 17:16:02
    按照本人现在的应用水平删减改编自博客:http://blog.csdn.net/guoyong10721073/article/details/25245293一、C++编译模式通常,在一个C++程序中,只包含两类文件——.cpp文件和.h文件。其中,.cpp文件被称作C++...
1 2 3 4 5 ... 20
收藏数 207,977
精华内容 83,190