减少C++代码编译时间的方法

c++ 的代码包含头文件和实现文件两部分，头文件一般是提供给别人（也叫用户）使用的，但是一旦头文件发生改变，不论多小的变化，所有引用他的文件就必需重新编译，编译就要花时间，如果你做的工程比较大（比方二次封装chrome这类的开发）,重新编译一次的时间就会白费上班的大部分时间，这样干了一天挺累的，但是你的老板说你没有产出，结果你被fired，是不是很怨啊，假如你早点看到这段文章，你就会比你的同事开发效率高那么少量，那样被fired就不会是你了，你说这篇文章是不是价值千金！开个玩笑：）

言归正传，怎么减少编译时间呢，我知道的就3个办法：

1. 删除不必要的#include,替代办法使用前向公告 (forward declared )

2. 删除不必要的一大堆私有成员变量，转而使用 “impl” 方法

3. 删除不必要的类之间的继承

为了讲清楚这3点，还是举个实例比较好,这个实例我会一步一步的改进（由于我也是一点一点摸索出来了，假如哪里说错了，你就放心的喷吧，我会和你在争论究竟的，呵呵）

现在先假设你找到一个新工作，接手以前某个程序员写的类，如下：

???? //??old.h: 这就是你接收的类
???? //
???? #include <iostream>
???? #include <ostream>
???? #include <list>

???? // 5 个分别是file , db, cx, deduce or error ，水平有限没有模板类
???? // 只用 file and cx 有虚函数.
???? #include "file.h"??// class file
???? #include "db.h"??// class db
???? #include "cx.h"??// class cx
???? #include "deduce.h"??// class deduce
???? #include "error.h"??// class error

???? class old : public file, private db {
???? public:
?????? old( const cx& );
?????? db??get_db( int, char* );
?????? cx??get_cx( int, cx );
?????? cx& fun1( db );
?????? error??fun2( error );
?????? virtual std::ostream& print( std::ostream& ) const;
???? private:
?????? std::list<cx> cx_list_;
?????? deduce?????? deduce_d_;
???? };
???? inline std::ostream& operator<<( std::ostream& os,const old& old_val )
???? { return old_val.print(os); }

这个类看完了，假如你已经看出了问题出在哪里，接下来的不用看了，你是高手，这些基本知识对你来说太小儿科，要是像面试时被问住了愣了一下，请接着看吧

先看怎样使用第一条：删除不必要的#include

这个类引用 5个头文件，那意味着那5个头文件所引用的头文件也都被引用了进来，实际上，不需要引用5 个，只需引用2个就完全可以了

1.删除不必要的#include,替代办法使用前向公告 (forward declared )

1.1删除头文件 iostream，我刚开始学习c++ 时照着《c++ primer》抄，只需看见关于输入，输出就把 iostream 头文件加上，几年过去了，现在我知道不是这样的，这里只是定义输出函数，只需引用ostream 就够了

1.2.ostream头文件也不要，替换为 iosfwd , 为什么，起因就是，参数和返回类型只需前向公告即可以编译通过，在iosfwd 文件里 678行（我的环境是vs2013，不同的编译环境具体位置可能会不相同，但是都有这句公告）有这么一句

typedef basic_ostream<char, char_traits<char> > ostream;

inline std::ostream& operator<<( std::ostream& os,const old& old_val )

{ return old_val.print(os); }

除此之外，要是你说这个函数要操作ostream 对象，那还是需要#include <ostream> , 你只说对了一半，确实，这个函数要操作ostream 对象，但是请看他的函数实现，

里面没有定义一个相似 std::ostream os, 这样的语句，话说回来，凡是出现这样的定义语句，就必需#include 相应的头文件了，由于这是请求编译器分配空间，而假如只前向公告 class XXX; 编译器怎样知道分配多大的空间给这个对象！

看到这里， old.h头文件可以升级如下了：

???? //??old.h: 这就是你接收的类
???? //
???? #include <iosfwd>??//新替换的头文件
???? #include <list>

???? // 5 个分别是file , db, cx, deduce or error，水平有限没有模板类
???? // 只用 file and cx 有虚函数.
???? #include "file.h"??// class file，作为基类不能删除，
????????????????????????// 删除了编译器就不知道实例化old 对象时分配多大的空间了
???? #include "db.h"??// class db，作为基类不能删除，同上
???? #include "cx.h"??// class cx
???? #include "deduce.h"??// class deduce
???? // error 只被用做参数和返回值类型，用前向公告替换#include "error.h"
???? class error；

???? class old : public file, private db {
???? public:
?????? old( const cx& );
?????? db??get_db( int, char* );
?????? cx??get_cx( int, cx );
?????? cx& fun1( db );
?????? error??fun2( error );
?????? virtual std::ostream& print( std::ostream& ) const;
???? private:
?????? std::list<cx> cx_list_; //??cx 是模版类型，既不是函数参数类型
?????????????????????????????? //??也不是函数返回值类型，所以cx.h 头文件不能删除
?????? deduce?????? deduce_d_; //??deduce 是类型定义，也不删除他的头文件
???? };
???? inline std::ostream& operator<<( std::ostream& os,const old& old_val )
???? { return old_val.print(os); }

到目前为止，删除了少量代码，是不是心情很爽，据说看一个程序员的水平有多高，不是看他写了多少代码，而是看他少写了多少代码。

假如你对C++ 编程有更深一步的兴趣，接下来的文字你还是会看的，再进一步删除代码，但是这次要另辟蹊径了

2. 删除不必要的一大堆私有成员变量，转而使用 “impl” 方法

2.1.使用 “impl” 实现方式写代码，减少用户端代码的编译依赖

impl 方法简单点说就是把类的私有成员变量一律放进一个impl 类，而后把这个类的私有成员变量只保留一个impl* 指针，代码如下：

???? // file old.h
???? class old {
?????? // 公有和保护成员
?????? // public and protected members
???? private:
?????? // 私有成员，只需任意一个的头文件发生变化或者成员个数添加，
?????? // 减少，所有引用old.h的用户端必需重新编译
?????? // private members; whenever these change,
?????? // all client code must be recompiled
???? };

改写成这样：

???? // file old.h
???? class old {
?????? // 公有和保护成员
?????? // public and protected members
???? private:
?????? class oldImpl* pimpl_;
?????? //??替换原来的所有私有成员变量为这个impl指针，指针只要要前向公告即可以编译通过，
?????? //??这种写法将前向公告和定义指针放在了一起，完全可以。
?????? //??当然，也可以分开写
?????? //??a pointer to a forward-declared class
???? };

???? // file old.cpp
???? struct oldImpl {
?????? // 真正的成员变量隐藏在这里，随便变化，用户端的代码都不需要重新编译
?????? // private members; fully hidden, can be
?????? // changed at will without recompiling clients
???? };

不知道你看明白了没有，看不明白请随意写个类实验下，我就是这么做的，当然凡事也都有优缺点，下面简单比照下：

使用impl?实现类不使用impl实现类

优点类型定义与用户端隔离，?减少#include?的次数，提高编译速度，库端的类随便修改，用户端不需要重新编译直接，简单明了，不需要考虑堆分配，释放，内存泄漏问题

缺点对于impl的指针必需使用堆分配，堆释放，时间长了会产生内存碎片，最终影响程序运行速度，?每次调用一个成员函数都要经过impl->xxx()的一次转发库端任意头文件发生变化，用户端都必需重新编译

改为impl实现后是这样的：

???? // 只用 file and cx 有虚函数.
???? #include "file.h"
???? #include "db.h"
???? class cx;
???? class error；

???? class old : public file, private db {
???? public:
?????? old( const cx& );
?????? db??get_db( int, char* );
?????? cx??get_cx( int, cx );
?????? cx& fun1( db );
?????? error??fun2( error );
?????? virtual std::ostream& print( std::ostream& ) const;
???? private:
???? class oldimpl* pimpl; //此处前向公告和定义
???? };
???? inline std::ostream& operator<<( std::ostream& os,const old& old_val )
???? { return old_val.print(os); }

???? //implementation file old.cpp
???? class oldimpl{
???? std::list<cx> cx_list_;
???? deduce????????dudece_d_;
???? };

3. 删除不必要的类之间的继承

面向对象提供了继承这种机制，但是继承不要滥用， old class 的继承就属于滥用之一， class old 继承file 和 db 类，继承file是公有继承，继承db 是私有继承

，继承file 可以了解，由于file 中有虚函数， old 要重新定义它，但是根据我们的假设，只有file 和 cx 有虚函数，私有继承db 怎样解释？! 那么唯一可能的理由就是：

通过私有继承—让某个类不能当作基类去派生其余类，相似Java里final关键字的功能，但是从实例看，显然没有这个意图，所以这个私有继承完全不必要，应该改用包含的方式去使用db类提供的功能, 这样即可以

把”db.h”头文件删除，把db 的实例也可以放进impl类中，最终得到的类是这样的：

???? // 只用 file and cx 有虚函数.
???? #include "file.h"
???? class cx;
???? class error;
???? class db;
???? class old : public file {
???? public:
?????? old( const cx& );
?????? db??get_db( int, char* );
?????? cx?? get_cx( int, cx );
?????? cx& fun1( db );
?????? error??fun2( error );
?????? virtual std::ostream& print( std::ostream& ) const;
???? private:
?????? class oldimpl* pimpl; //此处前向公告和定义
??????};
??????inline std::ostream& operator<<( std::ostream& os,const old& old_val )
??????{ return old_val.print(os); }

???? //implementation file old.cpp
???? class oldimpl{
???? std::list<cx> cx_list_;
???? deduce????????dudece_d_;
???? };
小结一下：

这篇文章只是简单的详情了减少编译时间的几个办法：

1. 删除不必要的#include,替代办法使用前向公告 (forward declared )

2. 删除不必要的一大堆私有成员变量，转而使用 “impl” 方法

3. 删除不必要的类之间的继承

这几条希望对您有所帮助，喜欢文章的小伙伴可以支持一下！