C++库二进制兼容Binary Compatible教程_内联函数无法访问 d 指针-CSDN博客

本文是从KDE的一个扫盲文翻译而来。说翻译其实也不是翻译，照着意思写而已，与原文并不严格对照。
我翻译了俩小时，大家仔细看看啊～

原文： http://techbase.kde.org/index.php?title=Policies/Binary_Compatibility_Issues_With_C%2B%2B

什么是二进制兼容

二进制兼容是针对动态链接库而言的。如果一个程序原来用旧版的库玩得很好，你偷偷给换成新版的库，他照样玩得很开心，甚至都不知道库换了，那你这个库就二进制兼容了。如果换了库就要重新编译一下才能继续玩，那叫源代码兼容（source compatible）。如果换了库就怎么也玩不转了，那叫不兼容。总地来说就是新的库文件保持和老的一样的二进制接口，让程序还得能直接找得着，用得了。

为啥要二进制兼容呢？当然为了省事儿。想象你发布软件的时候，如果不二进制兼容，就得所有文件重新发布一遍，多麻烦。当然也可以发布静态链接的软件，但那就更傻了，浪费时间资源不说，每次修改一个小bug就得重新下载所有文件。KDE就不傻，每一个大版本之内，比如4.2.x都二进制兼容，回头哪个文件有毛病下一个新版本补丁一下就好了，这也是没办法，让bug催的。

本文用的标准是GCC 3.4以上广泛使用的Itanium C++ ABI（程序二进制接口标准）。但不保证对所有编译器有效。

如何保证二进制兼容

要保证二进制兼容，修改源代码时一定要小心，有的事情能干，有的一定不能干。总的原则两条，第一，不改变编译器用于命名函数的关键结构，第二，不改变数据堆栈的长度和结构。

以下修改方法是安全的：

* 增加非虚函数，增加signal/slots，构造函数什么的。
* 增加枚举enum或增加枚举中的项目。
* 重新实现在父类里定义过的虚函数 (就是从这个类往上数的第一个非虚基类），理论上讲，程序还是找那个基类要这个虚函数的实现，而不是找你新写的函数要，所以是安全的。但是这可不怎么保准儿，尽量少用。（好多废话，结论是少用）
      o 有一个例外: C++有时候允许重写的虚函数改变返回类型，在这种情况下无法保证二进制兼容。
* 修改内联函数，或者把内联函数改成非内联的。这也很危险，尽量少用。
* 去掉一个私有非虚函数。如果在任何内联函数里用到了它，你就不能这么干了。
* 去掉私有的静态成员。同样，如果内联函数引用了它，你也不能这么干。
* 增加私有成员。
* 修改函数参数的缺省值。（这个脑残：修改了缺省值肯定要重新编译，怎么可能二进制兼容）
* 增加新类。
* 对外开放一个新类。
* 增减类的友元声明。
* 修改保留成员的类型。
* 把原来的成员位宽扩大缩小，但扩展后不得越过边界（char和bool不能过8位界，short不能过16位界，int不过32位界，以此类推）这个也接近闹残：原来没用到的那么几个位我扩来扩去当然没问题，可是这样实在是不让人放心。

以下修改方法是严格禁止的：

* 对于已经存在的类：
      o 本来对外开放了，现在想收回来不开放
      o 换爹 (加爹，减爹，重新给爹排座次).
* 对于类模板来说：
      o 修改任何模板参数（增减或改变座次）
* 对于函数来说：
      o 不再对外开放
      o 彻底删掉
      o 改成内联的(把代码从类定义外头移到头文件的类定义里头也算改内联)。
      o 改变函数特征串：
            + 修改参数，包括增减参数或函数甚至是成员函数的const/volatile描述符。如果一定要这么干，增加一个新函数吧。
            + 把private改成protected或者public。如果一定要这么干，增加一个新函数吧。
            + 对于非成员函数，如果用extern "C"声明了，可以很小心地增减函数参数而不破坏二进制兼容。
* 对于虚成员函数来说：
      o 给没虚函数或者虚基类的类增加虚函数
      o 修改有别的类继承的基类
      o 修改虚函数的前后顺序
      o 如果一个函数不是在往上数头一个非虚基类中声明的，覆盖它会造成二进制不兼容。
      o 如果虚函数被覆盖时改变了返回类型，不要修改它。
* 对于非私有静态函数和非静态的非成员函数：
      o 改成不开放的或者删除
      o 修改类型或者const/violate
* 对于非静态成员函数:
      o 增加新成员
      o 给非静态成员重新排序或者删除
      o 修改成员的类型, 有个例外就是修改符号：signed/unsigned改来改去，不影响字节长度。

要修改函数参数，只能增加一个新函数。这时候你一定要标上，等出大版本不要二进制兼容时，把这俩函数合一块：

void fun( int a );
void fun( int a, int b ); //等不用二进制兼容的，这俩合成一个 void fun(int a, int b=0);

复制代码

为了保持一个类的扩展空间，应该遵守下列规则：

* 使用d-pointer指针指向私有类
* 即使没什么事儿可做，也要弄一个像回事似的非内联的虚析构函数。
* 对于显示部件，甭管有没有事可做，也要把所有的event函数都写了，占个位子先。
* 所有的构造函数都不要内联。
* 写拷贝初始化函数和赋值函数的时候，尽量不要内联。当然如果不能进行值拷贝的时候就没办法了，比如QObject子类都不行。

类库开发守则：

开发类库的人最头疼的就是无法给类增加数据成员，因为这样会破坏类的长度结构，甚至连累所有的子类。

一个解决办法就是利用位标志。比如你原来设计了一个类，里面有这么几个enum或者bool类型：

uint m1 : 1;
uint m2 : 3;
uint m3 : 1;

你要是把它改成这样也不会破坏二进制兼容：

uint m1 : 1;
uint m2 : 3;
uint m3 : 1;
uint m4 : 2; // new member

究其原因，是本来已经占用了足够的位数，增加一个位标志并没有让数据字节长度增加。注意尽量不要用最后一位，有的编译器会出问题的。

使用d-pointer

使用位标志和占位变量只是旁门左道。d-pointer是Qt开发者发明的一个保护二进制兼容的办法，也是Qt如此成功的原因之一。

假如你要声明一个类Foo的话，先声明一个它的私有类，用向前引用的方法：

class FooPrivate;

在类Foo里，声明一个指向FooPrivate的指针：

private:
FooPrivate* d;

FooPrivate类本身在实现文件.cpp里定义，不需要头文件：

class FooPrivate {
public:
FooPrivate()
: m1(0), m2(0)
{}
int m1;
int m2;
QString s;
};

在类Foo的构造函数里，创建一个FooPrivate的实例：

d = new FooPrivate;

当然别忘记在析构函数里删掉它：

delete d;

还有一个技巧，在大部分环境下，把d-pointer声明成const是比较明智的。这样可以避免意外修改和拷来拷去，避免内存泄露：

private:
FooPrivate* const d;

这样，你可以修改d指向的内容，但是不能修改指针本身。

有时候，一些成员并不适合放在私有数据对象里。比如比较常用的对象，放在里面就很麻烦。内联函数也无法访问d-pointer指向的数据。另外，所有d-pointer里存储的对象都是私有的，要共有／保护访问，就要弄个get/set函数，跟Java那样：

QString Foo::string() const
{
return d->s;
}
void Foo::setString( const QString& s )
{
d->s = s;
}

常见的问题：

我的类没有d-pointer，我还想加新成员，这可怎么是好啊？

有空的位标志，预留变量没？要是都没有就麻烦了。不过麻烦不代表没有办法，如果你类继承自QObject，你可以把成员类挂到其中一个child上，然后想办法找这个child。还有更不要脸的办法，就是用一个哈西表保存你的对象和新成员的对应关系，要引用的时候上哈西表里找。比如说你可以用QHash或者QPtrDict。
对于忘记设计d-pointer的类，最标准的弥补做法是：
* 设计一个私有类FooPrivate.
* 创建一个静态的哈西表 static QHash<Foo *, FooPrivate>.
* 很不幸的是大部分编译器都是闹残，在创建动态链接库的时候都不会自动创建静态对象，所以你要用Q_GLOBAL_STATIC宏来声明这个哈西表才行:

//为了二进制兼容: 增加一个真正的d-pointer
Q_GLOBAL_STATIC(QHash<Foo *,FooPrivate>, d_func);
static FooPrivate* d( const Foo* foo )
{
FooPrivate* ret = d_func()->value( foo, 0 );
if ( ! ret ) {
ret = new FooPrivate;
d_func()->insert( foo, ret );
}
return ret;
}
static void delete_d( const Foo* foo )
{
FooPrivate* ret = d_func()->value( foo, 0 );
delete ret;
d_func()->remove( foo );
}

这样你就可以在类里自由增减成员对象了，就好像你的类拥有了d-pointer一样，只要调用d(this)就可以了：

d(this)->m1 = 5;

* 析构函数也要加入一句:

delete_d(this);

* 记得加入二进制兼容(BCI）的标志，下次大版本发布的时候赶紧修改过来。
* 下次设计类的时候，别再忘记加入d-pointer了。

如何覆盖已实现过的虚函数？

前文说过，如果爹类已经实现过虚函数，你覆盖是安全的：老的程序仍然会调用父类的实现。假如你有如下类函数：

void C::foo()
{
B::foo();
}

B::foo()被直接调用。如果B机成了A，A中有foo()的实现，B中却没有foo()的实现，则C::foo()会直接调用A::foo()。如果你加入了一个新的B::foo()实现，只有在重新编译以后，C::foo()才会转为调用B::foo()。
一个善解人意的例子:

B b; // B 继承 A
b.foo();

如果B的上一版本链接库根本没B::foo()这个函数，你调用foo()时一般不会访问虚函数表，而是直接调用A::foo()。

如果你怕用户重新编译时造成不兼容，也可以把A::foo() 改为一个新的保护函数 A::foo2()，然后用如下代码修补:

void A::foo()
{
if( B* b = dynamic_cast< B* >( this ))
b->B::foo(); // B:: 很重要
else
foo2();
}
void B::foo()
{
// 新的函数功能
A::foo2(); // 有可能要调用父类的方法
}

所有调用B类型的函数foo()都会被转到 B::foo().只有在明确指出调用A::foo()的时候才会调用A::foo()。

增加新类

拓展类功能的简单方法是在类上增加新功能的同时保留老功能。但是这样也限制了使用旧版链接库的类进行升级。对于那些小的要求高性能的类来说，要升级的时候，重新写一个类完全代替原来的才是更好的办法。

给非基类增加虚函数

对于那些没有其他类继承的类，可以增加一个相似的类，实现新的功能，然后修改应用程序使用这些新的功能。