二进制兼容和 ABI 兼容

// 原始版本
class MyClass {
public:
    void func1(int a);
    void func2(double b);
private:
    int member1;
    double member2;
};

// ❌ 破坏兼容性的修改
class MyClass {
public:
    void func1(int a, int b);        // 改变函数签名
    void func3(double b);            // 重命名函数
    void func2(double b);
private:
    double member2;                  // 改变成员顺序
    int member1;
    float member3;                   // 添加成员
};

// ✅ 保持兼容性的修改
class MyClass {
public:
    void func1(int a);               // 保持原有接口
    void func2(double b);
    void func3(float c);             // 添加新函数
private:
    int member1;                     // 保持成员顺序
    double member2;
    // 可以添加新的私有成员和私有方法
    float private_member3;
    void private_method();
};

// ===== 头文件：Foo.h =====
class Foo {
public:
    Foo();
    ~Foo();

    // 移动构造和赋值（C++11）
    Foo(Foo&& other) noexcept;
    Foo& operator=(Foo&& other) noexcept;

    // 禁用拷贝构造和赋值（或提供深拷贝实现）
    Foo(const Foo&) = delete;
    Foo& operator=(const Foo&) = delete;

    void publicMethod();
    int getValue() const;
    void setValue(int value);

private:
    class FooImpl;  // 前向声明
    FooImpl* d;     // D 指针
};

// ===== 实现文件：Foo.cpp =====
#include "Foo.h"
#include <iostream>

// 实现类定义
class Foo::FooImpl {
public:
    explicit FooImpl(Foo* q) : q(q), value(42) {}

    void publicMethodImpl() {
        std::cout << "Implementation method called, value: " << value << std::endl;
        // 可以通过 Q 指针访问接口类的公共方法
        // q->getValue(); // 但要避免无限递归
    }

    int getValue() const { return value; }
    void setValue(int val) { value = val; }

private:
    Foo* q;     // Q 指针，指向接口类
    int value;  // 具体的数据成员

    // 更多私有实现细节...
};

// 接口类实现
Foo::Foo() : d(new FooImpl(this)) {}

Foo::~Foo() {
    delete d;
}

Foo::Foo(Foo&& other) noexcept : d(other.d) {
    other.d = nullptr;
    if (d) d->q = this;  // 更新 Q 指针
}

Foo& Foo::operator=(Foo&& other) noexcept {
    if (this != &other) {
        delete d;
        d = other.d;
        other.d = nullptr;
        if (d) d->q = this;  // 更新 Q 指针
    }
    return *this;
}

void Foo::publicMethod() {
    d->publicMethodImpl();
}

int Foo::getValue() const {
    return d->getValue();
}

void Foo::setValue(int value) {
    d->setValue(value);
}

// 使用智能指针的现代实现
#include <memory>

class Foo {
public:
    Foo();
    ~Foo();  // 仍需要声明，因为 unique_ptr 需要完整类型才能析构

    // 移动语义
    Foo(Foo&&) noexcept;
    Foo& operator=(Foo&&) noexcept;

    void publicMethod();

private:
    class FooImpl;
    std::unique_ptr<FooImpl> d;  // 使用智能指针
};

// 实现文件
Foo::Foo() : d(std::make_unique<FooImpl>()) {}
Foo::~Foo() = default;  // 智能指针自动管理内存
Foo::Foo(Foo&&) noexcept = default;
Foo& Foo::operator=(Foo&&) noexcept = default;

// ❌ 避免在 DLL 边界传递 STL 容器
void library_function(const std::vector<int>& data);  // 危险

// ✅ 使用稳定的接口
void library_function(const int* data, size_t size);  // 安全

// ✅ 保持兼容的扩展方式
class LibraryClass {
public:
    // 保持原有接口
    void originalMethod();

    // 添加新接口，使用默认参数
    void enhancedMethod(int param = 0);

    // 或者添加重载版本
    void enhancedMethod(int param, bool flag);

private:
    // 使用 PIMPL 隐藏实现变更
    class Impl;
    std::unique_ptr<Impl> pImpl;
};

// C 风格 opaque handle（头文件）
#ifdef __cplusplus
extern "C" {
#endif
typedef struct MyResource MyResource; // 不暴露内部布局

MyResource* create_resource();
void destroy_resource(MyResource*);
int resource_do_work(MyResource*, int param);
#ifdef __cplusplus
}
#endif

// Foo.h
class Foo {
public:
    Foo();
    ~Foo();
    void doSomething();
private:
    class Impl;
    Impl* impl_; // 或 std::unique_ptr<Impl>
};

// Foo.cpp 中定义 Impl，客户端无需重新编译 Foo.h 修改 Impl 即可改变实现。

class Adapter {
public:
    virtual void run() = 0;
    virtual ~Adapter() = default;
};
class AdapterV1 : public Adapter { void run() override { /* v1 实现 */ } };
class AdapterV2 : public Adapter { void run() override { /* v2 实现 */ } };

static const HostAPI* g_host = nullptr;
static std::unique_ptr<Adapter> g_adapter;

extern "C" int plugin_init(const HostAPI* host) {
    g_host = host;
    if (!g_host) return -1;
    if (g_host->api_version >= 2) g_adapter = std::make_unique<AdapterV2>();
    else g_adapter = std::make_unique<AdapterV1>();
    if (g_host->log) g_host->log("plugin initialized");
    return 0;
}