抽象基类单个数据成员实现多态行为的最佳实践及设计方案咨询

1 设计思路合理性判断 #

你的核心设计是组合多态（用多态成员变量实现不同行为，而非直接给Base加虚函数让派生类重写），属于策略模式的典型应用，是行业通用实践，不存在设计思路层面的坏味道。
你当前Demo代码的问题是实现层面的：裸指针所有权不清晰、成员变量公开无封装、缺少强制约束，极易出现空指针访问、double free、野指针等问题。

2 BaseMember内存分配位置 #

不需要让派生类自行分配然后给成员赋值，你可以通过改造Base的构造函数，要求派生类构造时必须传入对应BaseMember子类的实例指针，分配动作可以放在派生类构造函数的初始化列表阶段完成，逻辑上更清晰。

3 编译期强制派生类完成赋值 #

你只需要将Base的默认构造函数删除，仅保留一个需要传入BaseMember*参数的构造函数，即可实现编译期强制校验：派生类构造时必须调用基类的带参构造函数，不传对应指针就会编译报错，完全避免用户遗忘初始化的问题。
同时建议将BaseMember*成员设为protected/private，仅对外提供只读getter，避免用户后续随意修改指针指向。

4 内存释放方案 #

完全可以在Base的析构函数中完成释放，不违反RAII原则：你可以通过设计把BaseMember的所有权明确交给Base持有，用户只负责创建传入，不负责销毁。
要避免double free很简单：

• 用std::unique_ptr<BaseMember>替代裸指针作为Base的成员，自动在Base析构时释放内存，不需要手动写delete逻辑
• 禁用Base的拷贝构造、拷贝赋值运算符，避免所有权转移混乱
• 不提供修改成员指针的接口，用户没有办法手动delete该指针，从根源上避免double free

5 无动态内存的嵌入式适配方案 #

针对Cortex M4这类无操作系统的裸机环境，可以用预分配静态缓冲区+placement new的方案实现完全等价的多态行为，不需要任何动态内存分配：

1. 提前计算所有库提供的BaseMember子类的最大内存占用、最大对齐要求，在Base类中定义一块符合大小和对齐要求的静态缓冲区（比如用std::aligned_storage定义，或手动加对齐修饰的char数组）
2. 派生类构造时，将对应BaseMember子类实例通过placement new构造到这块缓冲区中，不需要调用new分配堆内存
3. Base析构时手动调用BaseMember的虚析构函数即可，不需要释放内存

优化后代码示例（带动态内存的通用版本） #

// --------------- Library.h ---------------
#include <memory>
class BaseMember {
public:
  virtual void do_stuff() = 0;
  virtual ~BaseMember() = default;
};

class OneDerivedMember : public BaseMember {
public:
  void do_stuff() override {/* do stuff one way */}
};

class AnotherDerivedMember : public BaseMember {
public:
  void do_stuff() override {/* do stuff another way */}
};

class Base {
  std::unique_ptr<BaseMember> member;
public:
  // 仅保留带参构造，删除默认构造，强制派生类传成员实例
  explicit Base(std::unique_ptr<BaseMember> m) : member(std::move(m)) {}
  virtual ~Base() = default;
  // 禁用拷贝，避免所有权问题
  Base(const Base&) = delete;
  Base& operator=(const Base&) = delete;

  void do_member_stuff() {
    member->do_stuff();
  }
};

// ------------- User of library ---------------
#include "Library.h"
#include <list>

class Derived : public Base {
public:
  // 必须调用基类带参构造，否则编译报错
  Derived() : Base(std::make_unique<OneDerivedMember>()) {}
  // 不需要手动写析构函数释放成员
};

int main() {
  std::list<std::unique_ptr<Base>> my_list;
  my_list.push_back(std::make_unique<Derived>());
  for (auto& item : my_list) {
    item->do_member_stuff();
  }
  return 0;
}

嵌入式无动态内存版本示例 #

// --------------- Library.h ---------------
#include <new>
#include <cstddef>
#include <cstdint>

class BaseMember {
public:
  virtual void do_stuff() = 0;
  virtual ~BaseMember() = default;
};

class OneDerivedMember : public BaseMember {
  // 假设该类最大，占16字节
  uint32_t buf[4];
public:
  void do_stuff() override {/* do stuff one way */}
};

class AnotherDerivedMember : public BaseMember {
  // 占8字节
  uint32_t buf[2];
public:
  void do_stuff() override {/* do stuff another way */}
};

// 提前计算所有BaseMember子类的最大大小和对齐
constexpr size_t MAX_MEMBER_SIZE = sizeof(OneDerivedMember);
constexpr size_t MAX_MEMBER_ALIGN = alignof(OneDerivedMember);

class Base {
  // 定义对齐的静态缓冲区
  alignas(MAX_MEMBER_ALIGN) uint8_t member_buf[MAX_MEMBER_SIZE];
protected:
  // 模板构造函数，自动placement new构造对应成员
  template<typename T>
  explicit Base(std::in_place_type_t<T>) {
    static_assert(std::is_base_of_v<BaseMember, T>);
    static_assert(sizeof(T) <= MAX_MEMBER_SIZE);
    static_assert(alignof(T) <= MAX_MEMBER_ALIGN);
    new (member_buf) T();
  }
public:
  BaseMember* get_member() {
    return reinterpret_cast<BaseMember*>(member_buf);
  }
  virtual ~Base() {
    get_member()->~BaseMember();
  }
  // 禁用拷贝
  Base(const Base&) = delete;
  Base& operator=(const Base&) = delete;
};

// ------------- User of library ---------------
#include "Library.h"
#include <array>

class Derived : public Base {
public:
  // 必须传类型标签构造基类，否则编译报错
  Derived() : Base(std::in_place_type<OneDerivedMember>) {}
};

int main() {
  // 完全用栈存储，无任何动态内存分配
  std::array<Derived, 4> derived_arr;
  Base* base_ptr_arr[] = {&derived_arr[0], &derived_arr[1]};
  for (auto base : base_ptr_arr) {
    base->get_member()->do_stuff();
  }
  return 0;
}

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