C++ 智能指针跨 DLL 使用指南：把握模块边界的要点与常见坑

跨模块边界的基本概念

内存分配与析构的跨边界问题

在跨 DLL 的场景下，内存分配、对象生命周期与堆的归属成为核心关注点。不同模块如果使用不同的运行时库或不同的堆实现，直接通过智能指针在边界之外传递对象可能导致不可预期的崩溃或内存泄漏。理解这一点是把握模块边界的第一步。

另一方面，析构时的执行上下文也需要关注。一个在 DLL 中创建的对象，如果交给外部模块管理其生命周期，析构阶段的执行地点和内存回收策略必须保持一致，否则容易产生跨堆的安全问题。这也是跨 DLL 使用智能指针时最常遇到的坑之一。

本文的核心主题聚焦在“C++ 智能指针跨 DLL 使用指南：把握模块边界的要点与常见坑”这一命题上，强调如何通过设计和实现来降低风险、避免常见误区。

跨 DLL 调用的常见坑

运行时库不一致是最常见的导致崩溃的原因之一：同一进程中如果一个模块使用 /MD，而另一个模块使用 /MT，内存分配与释放就可能发生错位。确保所有模块采用相同的运行时库，是避免崩溃的基础。

跨边界的对象删除也要谨慎：直接在调用方删除来自 DLL 的对象，可能在 DLL 的堆上分配的对象被错误地释放，造成堆损坏。通常需要在 DLL 内部提供删除接口，或者通过受控的自定义删除器实现跨边界删除。

// DLL 端：返回一个原始指针，并提供一个在 DLL 内部删除的接口
// mlib.h
#pragma once
#ifdef MYLIB_BUILD
#define MYLIB_API __declspec(dllexport)
#else
#define MYLIB_API __declspec(dllimport)
#endif

class MYLIB_API MyClass {
public:
  void Do();
};

extern "C" MYLIB_API MyClass* CreateMyClass();
extern "C" MYLIB_API void DeleteMyClass(MyClass* p);

// DLL 端：实现
#include "mlib.h"
#include 

void MyClass::Do() { std::cout << "Hello from DLL" << std::endl; }

extern "C" MYLIB_API MyClass* CreateMyClass() {
  return new MyClass();
}
extern "C" MYLIB_API void DeleteMyClass(MyClass* p) {
  delete p; // 在 DLL 的堆中删除
}

// 客户端：使用跨 DLL 的对象时，必须通过 DLL 提供的删除接口来释放
#include "mlib.h"

int main() {
  MyClass* p = CreateMyClass();
  p->Do();
  DeleteMyClass(p);
  return 0;
}

跨 DLL 使用智能指针的可行策略

以安全的方式传递对象的两种核心策略

在跨 DLL 的场景中，直接把 std::shared_ptr 或 std::unique_ptr 跨边界通常并不安全，除非两个模块都以相同的运行时库构建并且对控制块、分配器具有完全可控的行为。为避免难以追踪的副作用，推荐使用以下两种核心策略：

策略 A：后端 DLL 维护对象生命周期，客户端仅持有一个“句柄”或智能指针的自定义 deleter。该删除操作在 DLL 内部完成，确保对象的析构和堆释放发生在同一模块。

策略 B：前向暴露一个纯虚接口/抽象基类，DLL 提供实现，客户端通过接口引用计数来管理对象寿命，避免跨边界直接删除对象的风险。

// 策略 A 示例：在 DLL 内部管理析构
// mlib.h（对外暴露句柄和删除函数）
#pragma once
#ifdef MYLIB_BUILD
#define MYLIB_API __declspec(dllexport)
#else
#define MYLIB_API __declspec(dllimport)
#endif

class MYLIB_API IMyClass {
public:
  virtual void Do() = 0;
  virtual ~IMyClass() {}
};

extern "C" MYLIB_API IMyClass* CreateMyClass();
extern "C" MYLIB_API void ReleaseMyClass(IMyClass* p);

// mlib_impl.h / mlib_impl.cpp（DLL 内部实现）
#include "mlib.h"
class MyClassImpl : public IMyClass {
public:
  void Do() override { /* 实现细节 */ }
};

extern "C" MYLIB_API IMyClass* CreateMyClass() {
  return new MyClassImpl();
}
extern "C" MYLIB_API void ReleaseMyClass(IMyClass* p) {
  delete p; // 在 DLL 内部进行删除
}

// 客户端：通过接口使用对象，删除交给 DLL
#include "mlib.h"

int main() {
  IMyClass* obj = CreateMyClass();
  obj->Do();
  ReleaseMyClass(obj);
  return 0;
}

策略 B 的核心在于：通过接口封装实现细粒度的生命周期管理，让 DLL 内部决定对象的销毁时机和清理方式，客户端无需关心具体对象的实现细节。这类设计对跨 DLL 的健壮性尤为重要，尤其在插件化架构中尤为常见。

无论采用哪种策略，核心目标都是避免在跨边界直接依赖对象的析构逻辑，确保对生命周期的控制保持在同一个模组内。请务必在编译和链接阶段统一运行时库设置，以及 ABI 兼容性。键点在于模块边界的一致性与清晰的生命周期边界。

// 策略 A 的延展：使用自定义删除器的智能指针（仅在 DLL 提供删除函数时使用）
// 客户端
#include "mlib.h"
#include 

int main() {
  IMyClass* raw = CreateMyClass();
  // 使用自定义 deleter，确保删除发生在 DLL 内部
  auto deleter = ReleaseMyClass;
  std::unique_ptr obj(raw, deleter);
  obj->Do();
  // 当 obj 超出作用域时，会调用 deleter 附带的 DLL 删除逻辑
}

实战演练：一个跨 DLL 的简单接口示例

示例步骤与实现要点

下面给出一个简化示例，演示如何在 DLL 边界上暴露一个简单接口，并通过明确的删除函数来管理对象生命周期。关键点在于：确保对象的创建与销毁分别在 DLL 内部完成，并在客户端仅通过中间接口进行交互。

第一步，定义一个可导出的接口以及创建/销毁函数；第二步，DLL 实现对象及导出函数；第三步，客户端按照接口规则进行调用并显式释放资源。以上设计有助于在不同语言或不同编译环境之间实现更好的互操作性。

在实现中保持一致性与清晰的边界，避免在跨边界的智能指针管理中混淆对象所有权、堆的位置、以及析构时的上下文。

// mlib.h：DLL 导出接口定义
#pragma once
#ifdef MYLIB_BUILD
#define MYLIB_API __declspec(dllexport)
#else
#define MYLIB_API __declspec(dllimport)
#endif

class MYLIB_API MyClass {
public:
  void Do();
};

extern "C" MYLIB_API MyClass* CreateMyClass();
extern "C" MYLIB_API void DeleteMyClass(MyClass* p);
extern "C" MYLIB_API void MyClass_Do(MyClass* p);

// mlib.cpp：DLL 实现
#include "mlib.h"
#include 

void MyClass::Do() { std::cout << "Inside DLL: Do" << std::endl; }

extern "C" MYLIB_API MyClass* CreateMyClass() {
  return new MyClass();
}
extern "C" MYLIB_API void DeleteMyClass(MyClass* p) {
  delete p;
}
extern "C" MYLIB_API void MyClass_Do(MyClass* p) {
  p->Do();
}

// app.cpp：客户端调用示例
#include "mlib.h"

int main() {
  MyClass* obj = CreateMyClass();
  MyClass_Do(obj);
  DeleteMyClass(obj);
  return 0;
}

// app_safe.cpp：使用自定义删除器的跨边界安全示例（DLL 端删除）
// 客户端：通过自定义 deleter 保证析构在 DLL 端执行
#include "mlib.h"
#include 

int main() {
  MyClass* raw = CreateMyClass();
  // 将删除操作交给 DLL 内部实现
  std::unique_ptr sp(raw, DeleteMyClass);
  sp->Do();
  // 离开作用域时，DeleteMyClass 在 DLL 内部执行
  return 0;
}

通过上述实现，可以在跨 DLL 的场景中避免直接在客户端进行对象的析构，降低跨边界内存管理的风险。需要注意的是，这种方式仍然要求客户端与 DLL 使用相同的 ABI 和运行时配置，且在实现上要确保导出函数的稳定性。