基类持有的unique_ptr重复初始化问题及优化方案咨询

一、继承体系内的优化（排除传入构造参数/新增基类构造的方案） #

如果必须保留继承关系，且不能修改基类构造参数或新增基类构造函数，可以采用延迟初始化+虚函数初始化逻辑的方式：

class Object { public: Object(std::string someString, ...); .... };

class Base
{
public:
  Base(int a) : value(a) {} // object默认初始化为nullptr，避免基类提前创建实例
  virtual ~Base() = default;

  // 定义虚函数用于初始化object，基类提供默认实现
  virtual void initializeObject() {
    object = std::make_unique<Object>("Base", ... );
  }
  ...
protected:
  int value;
  std::unique_ptr<Object> object;
};

class Derived : public Base
{
public:
  Derived(int a) : Base(a) {
    initializeObject(); // 调用派生类的初始化逻辑
  }

  // 重写初始化逻辑，创建Derived所需的Object实例
  void initializeObject() override {
    object = std::make_unique<Object>("Derived", ... );
  }
};

// 可选：用工厂函数确保初始化逻辑被调用
template<typename T>
std::unique_ptr<T> createInstance(int a) {
  auto instance = std::make_unique<T>(a);
  instance->initializeObject();
  return instance;
}

void fun() {
  auto d = createInstance<Derived>(42);
}

这种方式避免了基类和派生类重复创建Object，通过延迟到派生类构造完成后再初始化object，确保只创建一次实例。

二、非继承的替代设计 #

1. 组合代替继承 #

将原Base类的核心功能抽离为独立组件，让原Base和Derived类通过组合该组件复用逻辑，各自负责创建对应的Object：

class Object { public: Object(std::string someString, ...); .... };

// 抽离核心逻辑为组件类
class CoreLogic {
public:
  CoreLogic(int a, std::unique_ptr<Object> obj) 
    : value(a), object(std::move(obj)) {}
  
  // 原Base类的成员函数示例
  void doSomething() {
    // 使用value和object的业务逻辑
  }
  ...
private:
  int value;
  std::unique_ptr<Object> object;
};

// 原Base类改为组合CoreLogic
class Base {
public:
  Base(int a) : core(a, std::make_unique<Object>("Base", ... )) {}
  
  // 转发CoreLogic的接口
  void doSomething() { core.doSomething(); }
  ...
private:
  CoreLogic core;
};

// 原Derived类同样组合CoreLogic，创建自己的Object实例
class Derived {
public:
  Derived(int a) : core(a, std::make_unique<Object>("Derived", ... )) {}
  
  // 复用CoreLogic的接口，也可添加派生类特有逻辑
  void doSomething() { core.doSomething(); }
  void doDerivedSpecificThing() { /* 派生类专属逻辑 */ }
  ...
private:
  CoreLogic core;
};

void fun() {
  Derived d(42);
}

2. 模板类+创建者模式 #

通过模板参数注入Object的创建逻辑，避免继承关系，同时复用通用逻辑：

class Object { public: Object(std::string someString, ...); .... };

// 通用处理类，依赖模板参数提供的创建逻辑
template<typename ObjectCreator>
class GenericHandler {
public:
  GenericHandler(int a) : value(a), object(ObjectCreator::create()) {}
  
  // 通用成员函数示例
  void process() {
    // 使用value和object的业务逻辑
  }
  ...
protected:
  int value;
  std::unique_ptr<Object> object;
};

// 定义Base对应的Object创建者
struct BaseObjectCreator {
  static std::unique_ptr<Object> create() {
    return std::make_unique<Object>("Base", ... );
  }
};

// 定义Derived对应的Object创建者
struct DerivedObjectCreator {
  static std::unique_ptr<Object> create() {
    return std::make_unique<Object>("Derived", ... );
  }
};

// 类型别名，对应原Base和Derived
using Base = GenericHandler<BaseObjectCreator>;
using Derived = GenericHandler<DerivedObjectCreator>;

void fun() {
  Derived d(42);
}

3. 策略模式 #

定义Object创建的策略接口，通过组合不同策略实现不同的Object初始化逻辑：

class Object { public: Object(std::string someString, ...); .... };

// Object创建策略接口
struct ObjectCreationStrategy {
  virtual std::unique_ptr<Object> create() const = 0;
  virtual ~ObjectCreationStrategy() = default;
};

// Base对应的创建策略
struct BaseCreationStrategy : ObjectCreationStrategy {
  std::unique_ptr<Object> create() const override {
    return std::make_unique<Object>("Base", ... );
  }
};

// Derived对应的创建策略
struct DerivedCreationStrategy : ObjectCreationStrategy {
  std::unique_ptr<Object> create() const override {
    return std::make_unique<Object>("Derived", ... );
  }
};

// 统一处理类，组合策略对象
class Handler {
public:
  Handler(int a, std::unique_ptr<ObjectCreationStrategy> strategy) 
    : value(a), object(strategy->create()) {}
  
  // 通用处理逻辑示例
  void handle() {
    // 使用value和object的业务逻辑
  }
  ...
private:
  int value;
  std::unique_ptr<Object> object;
};

void fun() {
  // 使用Derived策略创建Handler实例
  Handler d(42, std::make_unique<DerivedCreationStrategy>());
}

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