C++ DLL含自身返回值类的跨编译器导出方案问询

你提到的抽象类接口方案确实是C++跨编译器DLL导出的成熟方案，但遇到返回自身类型、传递自身类型参数的问题时，不用新增转换类或者大量修改代码，我们可以通过抽象接口+工厂模式+智能指针的组合来解决，核心思路是用抽象类的指针/引用替代具体类的直接传递，同时用工厂函数封装实例创建逻辑，避免暴露具体实现。

具体实现步骤 #

1. 定义公共抽象接口（跨编译器头文件） #

这个头文件只包含纯虚函数和必要的类型定义，不涉及任何具体实现，所有编译器都能解析一致的接口：

#pragma once
#include <deque>
#include <ostream>

// 用别名统一类型，避免重复定义
using DigitList = std::deque<short int>;

// 抽象接口类，无任何导出标记（因为我们不直接导出类）
class IUnsignedBigint {
public:
    virtual ~IUnsignedBigint() = default;

    // 核心方法：替代原类的成员函数，参数和返回值用接口指针/智能指针
    virtual DigitList getDigits() const = 0;

    // 算术运算：返回接口指针，参数也用接口指针
    virtual IUnsignedBigint* add(const IUnsignedBigint* other) const = 0;
    virtual IUnsignedBigint* subtract(const IUnsignedBigint* other) const = 0;
    virtual IUnsignedBigint* multiply(const IUnsignedBigint* other) const = 0;
    virtual IUnsignedBigint* divide(const IUnsignedBigint* other) const = 0;
    virtual IUnsignedBigint* modulus(const IUnsignedBigint* other) const = 0;

    // 比较运算
    virtual bool equals(const IUnsignedBigint* other) const = 0;
    virtual bool greaterThan(const IUnsignedBigint* other) const = 0;
    virtual bool lessThan(const IUnsignedBigint* other) const = 0;

    // 赋值运算：修改当前实例
    virtual void assign(const IUnsignedBigint* other) = 0;
    virtual void addAssign(const IUnsignedBigint* other) = 0;
    virtual void subtractAssign(const IUnsignedBigint* other) = 0;
    virtual void multiplyAssign(const IUnsignedBigint* other) = 0;
    virtual void divideAssign(const IUnsignedBigint* other) = 0;
    virtual void modulusAssign(const IUnsignedBigint* other) = 0;

    // 自增自减
    virtual IUnsignedBigint& preIncrement() = 0;
    virtual IUnsignedBigint& preDecrement() = 0;
    virtual IUnsignedBigint* postIncrement() = 0;
    virtual IUnsignedBigint* postDecrement() = 0;

    // 幂运算
    virtual IUnsignedBigint* exponent(const IUnsignedBigint* other) const = 0;

    // 友元输出的替代方法
    virtual void print(std::ostream& os) const = 0;
};

// 工厂函数：导出C风格函数（跨编译器调用约定一致）
#ifdef UNSIGNEDBIGINT_EXPORTS
#define UNSIGNEDBIGINT_API __declspec(dllexport)
#else
#define UNSIGNEDBIGINT_API __declspec(dllimport)
#endif

// 创建实例的工厂函数，返回接口指针
extern "C" UNSIGNEDBIGINT_API IUnsignedBigint* CreateUnsignedBigint();
extern "C" UNSIGNEDBIGINT_API IUnsignedBigint* CreateUnsignedBigint(int value);
extern "C" UNSIGNEDBIGINT_API IUnsignedBigint* CreateUnsignedBigint(const DigitList& digits);
extern "C" UNSIGNEDBIGINT_API IUnsignedBigint* CreateUnsignedBigint(const IUnsignedBigint* other);

// 销毁实例的函数（必须由DLL负责销毁，避免跨编译器内存管理问题）
extern "C" UNSIGNEDBIGINT_API void DestroyUnsignedBigint(IUnsignedBigint* ptr);

2. DLL中的具体实现类 #

在DLL内部实现具体类，继承抽象接口，不需要导出这个类：

#include "IUnsignedBigint.h"
#include <algorithm>

// 具体实现类，仅在DLL内部可见
class UnsignedBigintImpl : public IUnsignedBigint {
private:
    DigitList digits;

    // 原私有方法保留，内部使用
    UnsignedBigintImpl removeIrrelevantZeros(UnsignedBigintImpl num) const {
        // 原实现逻辑
        while (!num.digits.empty() && num.digits.front() == 0) {
            num.digits.pop_front();
        }
        if (num.digits.empty()) {
            num.digits.push_back(0);
        }
        return num;
    }

public:
    // 构造函数，和原类一致
    UnsignedBigintImpl() : digits{0} {}
    UnsignedBigintImpl(int value) {
        // 原构造逻辑
        if (value == 0) {
            digits.push_back(0);
            return;
        }
        while (value > 0) {
            digits.push_front(value % 10);
            value /= 10;
        }
    }
    UnsignedBigintImpl(const DigitList& d) : digits(d) {
        *this = removeIrrelevantZeros(*this);
    }
    UnsignedBigintImpl(const IUnsignedBigint* other) : digits(other->getDigits()) {}

    // 实现接口的纯虚函数
    DigitList getDigits() const override { return digits; }

    IUnsignedBigint* add(const IUnsignedBigint* other) const override {
        const auto& otherDigits = other->getDigits();
        UnsignedBigintImpl result;
        // 原add逻辑实现，操作result.digits
        // ...
        return new UnsignedBigintImpl(result);
    }

    // 其他接口方法的实现，都转换成操作内部的UnsignedBigintImpl实例
    // 比如subtract、multiply等，逻辑和原类一致，最后返回new UnsignedBigintImpl(结果)

    bool equals(const IUnsignedBigint* other) const override {
        return digits == other->getDigits();
    }

    void print(std::ostream& os) const override {
        for (short digit : digits) {
            os << digit;
        }
    }

    // 其他方法实现...
};

// 工厂函数的实现
extern "C" UNSIGNEDBIGINT_API IUnsignedBigint* CreateUnsignedBigint() {
    return new UnsignedBigintImpl();
}

extern "C" UNSIGNEDBIGINT_API IUnsignedBigint* CreateUnsignedBigint(int value) {
    return new UnsignedBigintImpl(value);
}

extern "C" UNSIGNEDBIGINT_API void DestroyUnsignedBigint(IUnsignedBigint* ptr) {
    delete dynamic_cast<UnsignedBigintImpl*>(ptr);
}

3. 客户端封装（简化使用） #

为了让客户端使用起来和原类差不多，我们可以封装一个智能指针包装类，或者用std::unique_ptr配合自定义删除器：

#include "IUnsignedBigint.h"
#include <memory>

// 自定义删除器，调用DLL的销毁函数
struct BigintDeleter {
    void operator()(IUnsignedBigint* ptr) const {
        DestroyUnsignedBigint(ptr);
    }
};

using UniqueBigint = std::unique_ptr<IUnsignedBigint, BigintDeleter>;

// 封装工厂函数，返回智能指针
inline UniqueBigint MakeBigint() {
    return UniqueBigint(CreateUnsignedBigint());
}

inline UniqueBigint MakeBigint(int value) {
    return UniqueBigint(CreateUnsignedBigint(value));
}

// 重载运算符，让使用方式接近原类
inline UniqueBigint operator+(const UniqueBigint& a, const UniqueBigint& b) {
    return UniqueBigint(a->add(b.get()));
}

inline std::ostream& operator<<(std::ostream& os, const UniqueBigint& num) {
    num->print(os);
    return os;
}

为什么这个方案可行？ #

1. 抽象接口的兼容性：纯虚函数的虚表结构在C++标准中是隐含一致的，不同编译器生成的虚表布局不会有差异，所以接口指针可以跨编译器传递。
2. C风格导出函数：用extern "C"导出的工厂函数和销毁函数，使用的是C调用约定（cdecl），这是所有编译器都支持的，避免了C++名字修饰的差异。
3. 智能指针管理生命周期：客户端不需要手动管理内存，自定义删除器确保实例由DLL销毁，避免跨编译器内存分配/释放不兼容的问题。
4. 最小代码修改：原类的内部逻辑几乎不需要改动，只需要把对外的接口转换成纯虚函数，然后在具体实现类中调用原逻辑即可。

注意事项 #

• 如果你需要完全兼容不同厂商的STL（比如MSVC和GCC混合使用），建议把STL容器参数换成C风格数组；如果只是同厂商不同版本编译器，直接用STL容器是没问题的。
• 所有涉及到类传递的地方，都用接口指针/智能指针，不要直接传递具体类对象。
• 销毁实例必须调用DLL提供的DestroyUnsignedBigint函数，不能直接delete，因为不同编译器的内存分配器可能不一样。

内容的提问来源于stack exchange，提问作者me'