Effective C++ 读书笔记 Item31 将文件间的编译依存关系将至最低

朱雀 2020-07-05 02:31 647阅读 0赞

假设某一天你打开自己的C++程序代码，然后对某个类的实现做了小小的改动。提醒你，改动的不是接口，而是类的实现，也就是说，只是细节部分。然后你准备重新生成程序，心想，编译和链接应该只会花几秒种。毕竟，只是改动了一个类嘛！于是你点击了一下"Rebuild"，或输入make（或其它类似命令）。然而，等待你的是惊愕，接着是痛苦。因为你发现，整个世界都在被重新编译、重新链接！**这是C++特殊的一点，即使你在保持接口不变的情况下只改了类的内部实现，其他的项目文件仍然可能需要重新编译。**

C++的Class不仅规约了外部接口，也给出了内部实现：

class Person{
    public:
        // 外部接口
        Person(const string& name);
        string name() const;
    private:
        // 内部实现
        string _name;
        Date _birthday;
    };

基于`Person`的内部实现，它的类定义文件中应该包含这样的代码：

include<string>
    include"date.h"

> `<string>`中定义了`string`类，`date.h`中定义了`Date`类。

这些include在编译前都是要拷贝进来的！这使得Person与这些头文件产生了编译依赖。 只要这些头文件（以及它们依赖的文件）中的类定义发生改动，Person类便需要重新编译。

你可能会想到，在Person文件中，只引入string和Date的声明而不引入定义不就解决问题了么： 这样当我们更改Date的内部实现时Person便不会知道，也就不需要重新编译了。这个思路写出来的代码是这样的：

class string;
    class Date;
    class Person{
        ...
    };
    Person p;

编译通过不了！首先string是一个typedef：basic\_string<char>，你需要声明更多的东西才能合法地声明这样一个string。 另外当编译器运行到Person p;时要为Person分配空间，需要知道Person的大小，而Person的大小依赖于Date的大小。 所以编译器需要知道Date的内部实现！只声明Date是不够的。

# 使用指针代替对象 #

一个去除编译依赖的办法是：依赖项使用指针而不是对象，同时依赖于类的声明而非定义。比如我们把`_birthday`改成指针，并声明`class Date;`：

class Date;
    class Person{
        ...
    private:
        Date* _birthday;
    }

编译器为Person分配空间时，为其中的\_birthday分配指针大小的空间即可，不必知道Date的内部实现，此时只需要提供Date的声明即可。 Person依赖于Date的声明而不是定义，于是date.h不再是Person的编译依赖了。 另外，如果你只是在返回值或者参数用到了Date，也不需要引入Date的定义，声明它即可：

class Date;
    Date d;
    void func(Date d);

虽说对象作为函数参数还是传递引用比较好（见Item 20：传递常量引用比传值更好），但即使你传递的是对象，也不需要给出它的内部实现。

# 单独地提供声明 #

既然我们希望依赖于声明而非定义，那么我们需要为每个类单独地提供声明文件，和定义文件。 比如`date.h`便需要分为两个文件，一个是声明`class Date;`，一个是定义`class Date{}`。

// file: datefwd.h
    class Date;
     
    // file: date.h
    class Date{
        ...
    };

我们在`Person`中`include"datefwd.h"`即可，这样解除`Person`和`Date`内部实现（定义在`date.h`中）之间的编译依赖。

# 使用句柄类 #

C++中接口声明和内部实现必须同时引入， 但在Java等语言中便不存在这个问题。因为所有对象都是引用，比如Person中的Date只是一个引用，Person的大小与Date的实现无关， 只需要为Date分配一个引用大小的空间即可。在C++中，我们也可以使用"pImpl idiom"来实现这个策略：

class Person{
    public:
        Person(string& name);
        string name() const;
    private:
        shared_ptr<PersonImpl> pImpl;
    };
    Person::Person(string& name): pImpl(new PersonImpl(name)){}
    string Person::name(){
        return pImpl->name();
    }

相当于把实现放到了另外一个类中`PersonImpl`，这样的`Person`类称为句柄类（Handle class）。 这样，当`PersonImpl`的内部实现发生改变时，依赖于`Person`的代码不再需要重新编译了。

# 使用接口类 #

还记得虚函数吗？除了句柄类，还有另外一个方式来移除编译依赖：接口类。在Java或C\#中有接口的概念， 一个类可以实现若干个接口。但在C++中只有类的概念，但我们可以用只包含虚函数的类来定义一个接口：

class Person{
    public:
        virtual ~Person();
        virtual string name() const = 0;
        virtual string birthday() const = 0;
    };

> 接口类中的成员函数定义为纯虚函数即可，因为接口类中我们当然不打算放一个方法的实现进去。

这个Person接口类包含纯虚函数，是一个抽象类。客户不能实例化它，只能使用它的引用和指针。 然而客户一定需要某种方法来获得一个实例，比如工厂方法（见Item 13或者虚构造函数。 它们动态地创建对象，并返回对象指针（最好是智能指针，见Item 18）。

比如Person有一个实体类叫做RealPerson，那么Person中可以提供一个工厂方法create()：

class Person{
    public:
        static shared_ptr<Person> create(string& name);
    };
    shared_ptr<Person> Person::create(string& name){
        return shared_ptr<Person>(new RealPerson(name));
    }
    ...
    shared_ptr<Person> p(Person::create("alice"));

总结  
最小化编译依赖的一般做法是依赖于声明而非定义，这个想法可以通过句柄类或接口类来实现。库的声明应当包括“完整的”和“只有声明的”两种形式。

接口类和句柄类的设计隐藏了类的实现细节，减小了实现细节的改动对客户的影响。 但无论是接口类还是句柄类，都会造成一些代价：多一个pImpl指针的空间、虚函数表指针的空间、寻找虚函数的时间、间接调用的时间。

确实有人会因为这些代价而拒绝使用这些先进的技术，你会发现很难说服他们。这一点即便是Scott Meyers也没有办法：

> If so, you're reading the wrong book.