如何让stalker包装类的构造器兼容底层类型的所有构造方式？

问题背景 #

我需要实现一个stalker<Obj>模板类，内部持有Obj类型的成员变量，要求从用户角度看，stalker<Obj>的构造行为和原生Obj完全一致。类内部还有其他成员，构造时必须执行独立于Obj的特定逻辑，且Obj可能被标记为final。

初始实现的缺陷 #

最初的实现用万能引用构造函数试图覆盖所有构造场景：

template <typename Obj>
class stalker {
  Obj obj;
  // 其他成员

 public:
  template <typename... Args>
  stalker(Args&&... args) : obj(std::forward<Args>(args)...) {
    // 执行特定逻辑
  }
};

但这个方案无法正确处理std::initializer_list相关的构造，比如：

int main() {
  stalker<std::vector<int>> v = {1, 2, 3};  // 编译错误：无法匹配构造函数
  stalker<std::vector<int>> v({1, 2, 3});   // 同样编译错误
  return 0;
}

编译器会报错No matching constructor for initialization of 'std::vector<int>'，因为万能引用无法推导std::initializer_list类型，导致无法正确初始化内部的Obj。

中间尝试的问题 #

针对初始化列表的问题，我尝试添加专门的构造函数：

template <typename T>
requires (std::is_constructible_v<Obj, const std::initializer_list<T>&>)
stalker(const std::initializer_list<T>& init_list) : obj(init_list) {
  // 执行特定逻辑
}

template <typename T>
requires (std::is_constructible_v<Obj, std::initializer_list<T>&&>)
stalker(std::initializer_list<T>&& init_list) : obj(std::move(init_list)) {
  // 执行特定逻辑
}

这个方案能解决std::vector<int>的构造问题，但遇到聚合类型时会失效：

struct A {
  int val;
};

int main() {
  stalker<A> a = {1};  // 编译错误：无法匹配构造函数
  return 0;
}

同时，嵌套初始化列表的场景也无法处理，比如：

int main() {
  stalker<std::vector<std::vector<int>>> v = {{1,2,3}, {4,5}, {6}};  // 编译错误
  return 0;
}

最终解决方案 #

要让stalker<Obj>完全复刻Obj的构造行为，需要结合C++20的约束和特性，覆盖所有构造场景：

完整实现代码 #

#include <concepts>
#include <utility>
#include <initializer_list>

template <typename Obj>
class stalker {
  Obj obj;
  // 其他成员变量

  // 构造时执行的特定逻辑，私有封装
  void run_init_logic() {
    // 这里添加独立于Obj的初始化逻辑
  }

public:
  // 拷贝构造：拷贝内部Obj，同时执行特定逻辑
  stalker(const stalker& other) : obj(other.obj) {
    run_init_logic();
  }

  // 移动构造：移动内部Obj，同时执行特定逻辑
  stalker(stalker&& other) noexcept(std::is_nothrow_move_constructible_v<Obj>)
    : obj(std::move(other.obj)) {
    run_init_logic();
  }

  // 万能引用构造：约束为非stalker类型，避免和拷贝/移动构造冲突
  template <typename... Args>
  requires (!std::same_as<std::remove_cvref_t<Args>..., stalker>)
  stalker(Args&&... args) : obj(std::forward<Args>(args)...) {
    run_init_logic();
  }

  // 初始化列表构造：覆盖所有能接受std::initializer_list的Obj类型
  template <typename T>
  stalker(std::initializer_list<T> init_list)
    requires std::constructible_from<Obj, std::initializer_list<T>>
    : obj(init_list) {
    run_init_logic();
  }

  // 聚合类型支持：如果Obj是聚合，直接用花括号初始化内部成员
  template <typename... Args>
  requires std::is_aggregate_v<Obj> && std::constructible_from<Obj, Args...>
  stalker(Args&&... args) : obj{std::forward<Args>(args)...} {
    run_init_logic();
  }
};

// 测试用例
struct A { int val; };

int main() {
  // 1. 普通参数构造
  stalker<std::vector<int>> v1(10, 0);
  // 2. 初始化列表构造
  stalker<std::vector<int>> v2 = {1, 2, 3};
  // 3. 聚合类型构造
  stalker<A> a = {1};
  // 4. 嵌套初始化列表构造
  stalker<std::vector<std::vector<int>>> v3 = {{1,2}, {3,4,5}, {6}};
  // 5. 拷贝构造
  stalker<std::vector<int>> v4 = v2;
  // 6. 移动构造
  stalker<std::vector<int>> v5 = std::move(v2);
}

关键细节说明 #

1. 万能引用的约束：!std::same_as<std::remove_cvref_t<Args>..., stalker>确保当传入stalker类型时，优先匹配显式的拷贝/移动构造函数，避免歧义。
2. 聚合类型支持：通过std::is_aggregate_v<Obj>判断Obj是否为聚合类型，使用花括号初始化obj，完美支持stalker<A> a = {1}这类聚合初始化场景。
3. 初始化列表构造：用std::constructible_from约束确保Obj可以接受std::initializer_list<T>，同时不需要单独处理右值初始化列表（因为std::initializer_list的拷贝代价极低）。
4. 拷贝/移动构造：显式实现以保证构造时执行特定逻辑，同时正确处理内部Obj的拷贝/移动。

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