库的二进制兼容

对于一个已经发布的库，如果在库的某个接口类中增加了一个成员，并重新发布该库，如果使用该库的程序直接替换该库后运行时会导致程序崩溃，解决办法就是重新编译应用程序，这是因为，新库中某些接口类及继承于它的类内存布局都已变化，但是旧的应用程序是根据之前的类内存布局，在编译期间分配好了内存，如果不重新编译程序，那么就会导致访问一个数据时，其可能已被覆盖，从而导致崩溃。
所以二进制兼容是指如果自己的程序使用了第三方模块，二进制兼容可以保证在第三方模块修改之后，自己的程序可以不用重新编译就能够兼容修改后的第三方模块。

实现方法

它其实就是pimpl设计模式的具体应用。在了解二进制兼容实现方法前，引入两个概念：主类和私有类。我把二进制库提供给第三方程序的接口类称为主类，把二进制程序内部使用的类称作私有类。只要不修改主类的成员，无论怎么修改二进制库，都可以做到二进制兼容。为直观说明二进制兼容的优势，举个例子，假如我们写了一个库，提供了如下的接口：

class Interface{
public:
    Interface(){m_greeting="hello\n";}
    void say(){
        std::cout<<m_greeting;
    }
private:
    std::string m_greeting;
}

接下来我们因为新的需求，需要对库进行修改，修改如下：

class Interface{
public:
    Interface(){m_greeting="hello\n";m_name="mike";}
    void say(){
        std::cout<<m_greeting+m_name;
    }
private:
    std::string m_greeting;
    std::string m_name;
}

这时候，由于主类成员发生了修改，我们不仅要重新编译库，还要重新编译所有基于这个库的程序。

接下来我们对上述代码进行重构，修改成二进制兼容模式，二进制兼容的实现方式类似于设计模式中的Pimpl，关键点就是在主类中定义一个指向私有类的指针，简单实现方式如下：

//导出类 interface.h
class Interface{
public:
    Interface(){m_ptr = new ClassPrivate;}
    ~Interface(){delete m_ptr;}
    void say(){
        if(m_ptr!=nullptr){m_ptr->say();}
    }
private:
    ClassPrivate* m_ptr;
}
//私有类 classprivate.h
class ClassPrivate{
public:
    ClassPrivate(){m_greeting="hello\n";}
    void say(){std::cout<<m_greeting;}
private:
    std::string m_greeting;
}

当需求发生变动，我们只需要作出如下修改：

class ClassPrivate{
public:
    ClassPrivate(){m_greeting="hello\n";m_name="mike";}
    void say(){std::cout<<m_greeting+m_name;}
private:
    std::string m_greeting;
    std::string m_name;
}

因为我们没有修改主类Interface，只是对私有类进行了修改，因此不需要重新编译基于该库的程序，缩短了编译流程。

好处

私有的结构体可以随意改变，而不需要重新编译整个工程项目
隐藏实现细节
头文件中没有任何实现细节，可以作为API使用
原本在头文件的实现部分转移到乐源文件，所以编译速度有所提高

Qt中Q和D指针实现

d指针是在主类中使用的，主类获取私有类或类中私有变量的指针
q指针是在私有数据类中使用的，来获取主类对象指针
Q_DECLARE_PRIVATE宏和Q_D宏配合用来在主类中访问私有类对象

#define Q_DECLARE_PRIVATE(Class) \
    inline Class##Private* d_func() { return reinterpret_cast<Class##Private *>(qGetPtrHelper(d_ptr)); } \
    inline const Class##Private* d_func() const { return reinterpret_cast<const Class##Private *>(qGetPtrHelper(d_ptr)); } \
    friend class Class##Private;
#define Q_D(Class) Class##Private * const d = d_func()

Q_DECLARE_PUBLIC宏和Q_Q宏配合用来在私有类中访问主类对象

Q_DECLARE_PUBLIC宏和Q_Q宏
#define Q_DECLARE_PUBLIC(Class)                           \
    inline Class* q_func() { return static_cast<Class *>(q_ptr); } \
    inline const Class* q_func() const { return static_cast<const class*>(q_ptr); } \
    friend class Class;
#define Q_Q(Class) Class * const q = q_func()

如下为一个完整例子：

// myclass.h
#ifndef MYCLASS_H
#define MYCLASS_H
#include <QtCore/QObject>
class MyClassPrivate;
class MyClass: public QObject
{
  Q_OBJECT
public:
  MyClass(QObject *parent = 0);
  virtual ~MyClass();
  void dummyFunc();
private:
  MyClassPrivate * const d_ptr;
  Q_DECLARE_PRIVATE(MyClass);
};
#endif // MYCLASS_H
// myclass.cpp
#include "myclass.h"
class MyClassPrivate
{
public:
  MyClassPrivate(MyClass *parent)
    : q_ptr(parent)
  {
  }
  void foobar()
  {
    Q_Q(MyClass);
    emit q->dummySignal();
  }
private:
  MyClass * const q_ptr;
  Q_DECLARE_PUBLIC(MyClass);
};
MyClass::MyClass(QObject *parent)
  : QObject(parent)
  , d_ptr(new MyClassPrivate(this))
{
}
MyClass::~MyClass()
{
  Q_D(MyClass);
  delete d;
}
void MyClass::dummyFunc()
{
  Q_D(MyClass);
  d->foobar();
}

Qt的D与Q指针

Qt的D与Q指针

库的二进制兼容

实现方法

好处

Qt中Q和D指针实现

推荐阅读更多精彩内容