这两者都是为了降低文件之间的编译依存

1编译依存

class class_name{

member1 m_m1;

member2 m_m2;

public:

member1 get_member_1() const{};

member2 get_member_2() const{];

};

假设上面的头文件是file.h,当file1.h发生变化，或者file中的class_name的实现发生变化时，所有包含file。h的文件都得重新编译，当file。h被很多文件包含时，即使只是对class_name做了很小的改动，也要花费大量的编译时间。

2Handler class

handle class只是提高了所有的接口，同时包含了一个指向真正实现类的指针，真正的实现类包含在了另一个文件中，当药修改这个类的时候，只有file。h会引起重新编译，而包含了file。h的其他文件不会重新编译

#include"file1.h" //contain member1
#include"file2.h" //contain member2
#include"implement.h"

class class_name
{
  class_impl* implement; //一般会用shared pointer

public:
 member1 get_member_1()const
 {
   return implement->get_member_1();
 }

 member2 get_member_2() const
 {
   return implement->get_member_2();
 }
};

下面是是implement.h的实现

class class_impl
{
  member1 m_1;
  member2 m_2;
public;
  member1 get_member_1()const {}
  member2 get_member_2()const {}
};

2、interface class

这是制作handle class的另外一种方法

首先声明class是抽象基类，一般里面的接口都是纯虚函数，然后提供一个static的create函数，这个函数返回该抽象类的某个具体的子类的对象，函数声明中的返回值仍然是该抽象类的指针或引用。具体子类在另外一个文件中声明。

class Base
{
public:
    virtual ~Base() {}
    
    void DoSomething()
    {
        StepOne();
        StepTwo();
    }
private:
    virtual void StepOne() = 0;
    virtual void StepTwo() = 0;
};

class Derived : public Base
{
private:
    virtual void StepOne()
    {
        cout << "Derived StepOne： do something." << endl;
    }
    virtual void StepTwo()
    {
        cout << "Derived StepTwo： do something." << endl;
    }
};

Handle class && Interface class