MSVC下导出含抽象基类智能指针参数的DLL成员函数报错C2280

咱们先把你遇到的C2280错误根源理清楚：这个错误提示你尝试引用已删除的函数，针对std::unique_ptr<Base>来说，核心原因有两个——一是unique_ptr本身不支持拷贝，你可能在参数传递时触发了它的拷贝构造（已被显式删除）；二是跨DLL边界时，抽象基类的析构函数可见性、智能指针删除器的兼容性出了问题。下面一步步给你解决：

1. 修正抽象基类的析构函数 #

抽象基类的析构函数必须是虚函数，最好定义为纯虚但提供实现——这样既能保证它是抽象类，又能让unique_ptr的删除器正确调用派生类的析构函数。如果析构函数不是虚的，unique_ptr销毁时会直接调用基类非虚析构，不仅会导致派生类资源泄漏，跨DLL边界时编译器还会因为无法确定析构函数地址而报错。

示例修改Base类：

class Base {
public:
    // 纯虚析构，必须在cpp文件中提供实现
    virtual ~Base() = 0;

    // 其他纯虚接口
    virtual void doSomething() = 0;
};

// 在cpp文件中实现纯虚析构
Base::~Base() {}

2. 调整函数参数的传递方式 #

std::unique_ptr是独占所有权的智能指针，完全不支持拷贝。如果你的DLL类成员函数参数是传值的std::unique_ptr<Base>，编译器会尝试调用它的拷贝构造函数（已删除），直接触发C2280。你需要改成以下两种方式之一：

方式A：传递右值引用（转移所有权） #

如果函数需要接管unique_ptr的所有权，用右值引用：

class DLLEXP MyDllClass {
public:
    void processObject(std::unique_ptr<Base>&& obj) {
        if (obj) {
            obj->doSomething();
            // 可以将obj存储到类成员中，完成所有权转移
        }
    }
};

调用时需要用std::move转移所有权：

std::unique_ptr<Base> ptr = std::make_unique<Derived>(); // Derived是Base的派生类
MyDllClass dllObj;
dllObj.processObject(std::move(ptr));
// 此时ptr已经为空，所有权转移到了DLL函数内部

方式B：传递const左值引用（仅访问，不转移所有权） #

如果函数只需要访问对象，不需要接管所有权，用const引用：

class DLLEXP MyDllClass {
public:
    void processObject(const std::unique_ptr<Base>& obj) {
        if (obj) {
            obj->doSomething();
        }
    }
};

调用时直接传值即可，不会触发所有权转移：

std::unique_ptr<Base> ptr = std::make_unique<Derived>();
MyDllClass dllObj;
dllObj.processObject(ptr);
// ptr仍然持有对象所有权

3. 确保DLL和EXE使用相同的CRT版本 #

跨DLL边界使用标准库对象（比如std::unique_ptr）时，必须保证DLL和EXE使用完全相同的CRT版本（比如都是多线程调试 DLL (/MDd)用于Debug，多线程 DLL (/MD)用于Release）。否则，标准库的内部实现可能不一致，导致内存管理错误或者函数调用失败。

在MSVC中设置路径：
项目属性 → C/C++ → 代码生成 → 运行库，选择相同的选项。

4. （可选）自定义删除器解决跨DLL边界问题 #

如果上面的方法还不行，可能是std::default_delete<Base>在DLL和EXE中的实现不一致导致的。这时候可以自定义一个删除器，让删除器的实现由DLL提供，确保两边都用同一个删除器：

头文件中定义删除器和别名 #

// 自定义删除器
struct BaseDeleter {
    void operator()(Base* ptr) const;
};

// 使用自定义删除器的unique_ptr别名
using UniqueBasePtr = std::unique_ptr<Base, BaseDeleter>;

DLL的cpp文件中实现删除器 #

void BaseDeleter::operator()(Base* ptr) const {
    delete ptr; // 这里的delete会正确调用派生类析构，因为Base的析构是虚的
}

修改DLL成员函数参数类型 #

class DLLEXP MyDllClass {
public:
    void processObject(UniqueBasePtr&& obj) {
        if (obj) {
            obj->doSomething();
        }
    }
};

这样，无论EXE还是DLL，都使用同一个删除器实现，彻底避免了跨边界的兼容性问题。

完整示例代码 #

DLL端的class.h #

#ifdef DLLFILE
#define DLLEXP __declspec(dllexport)
#else
#define DLLEXP __declspec(dllimport)
#endif

class Base {
public:
    virtual ~Base() = 0;
    virtual void doSomething() = 0;
};

// 自定义删除器（可选）
struct BaseDeleter {
    void operator()(Base* ptr) const;
};
using UniqueBasePtr = std::unique_ptr<Base, BaseDeleter>;

class DLLEXP MyDllClass {
public:
    // 方式A：转移所有权的右值引用参数
    void processObject(std::unique_ptr<Base>&& obj);
    // 自定义删除器版本
    void processObject(UniqueBasePtr&& obj);
};

DLL端的class.cpp #

#define DLLFILE
#include "class.h"

// 实现Base的纯虚析构
Base::~Base() {}

// 实现自定义删除器（如果使用的话）
void BaseDeleter::operator()(Base* ptr) const {
    delete ptr;
}

void MyDllClass::processObject(std::unique_ptr<Base>&& obj) {
    if (obj) {
        obj->doSomething();
    }
}

void MyDllClass::processObject(UniqueBasePtr&& obj) {
    if (obj) {
        obj->doSomething();
    }
}

EXE端的调用代码 #

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

// 派生类实现
class Derived : public Base {
public:
    void doSomething() override {
        // 自定义业务逻辑
    }
};

int main() {
    std::unique_ptr<Base> ptr = std::make_unique<Derived>();
    MyDllClass dllObj;
    // 调用方式A的函数，转移所有权
    dllObj.processObject(std::move(ptr));

    // 如果用自定义删除器的版本
    UniqueBasePtr customPtr(new Derived);
    dllObj.processObject(std::move(customPtr));

    return 0;
}

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