Question

我有很多模板类，它们以任意顺序一起工作（共享相同的概念）。

假设我有：

template<typename T>
class A {
  T t_;
public:
  void call() {
    // Do something.
    t_.call();
  }
};

template<typename T, typename U>
class B {
  T t_;
  U u_;
public:
  void call() {
    // Do something.
    t_.call();
    // Do something.
    u_.call();
  }
};

class C {
public:
  void call() {
    // Do something.
  }
};

我有以下实例化的类：

using Foo = A<B<A<C>,C>>;

让我们假设，C需要一个特殊的构造函数（或初始化函数）来工作。我在运行时只知道的东西。

struct C {
  void init(int);
  void call();
};

我怎么能初始化Foo？或者任何其他嵌套类组合？

我目前的解决方法是将C定义为：

template<typename I>
struct C {
  C() : var_(I::get())
  void call();
};

在函数中创建Foo：

int main()
{
  int i = 0;

  struct HelperC1 {
    static int get(bool set = false, int value = 0) {
      static int value_ = value;
      if (set) value_ = value;
      return value_;
    }
  } helperC1;

  struct HelperC2 {
    static int get(bool set = false, int value = 0) {
      static int value_ = value;
      if (set) value_ = value;
      return value_;
    }
  } helperC2;

  helperC1.get(true, i);
  helperC2.get(true, i+1);

  A<B<A<C<HelperC1>>,C<HelperC2>>> foo;   
  foo.call();

  return 0;
}

Live example.

你知道，这种解决方法不是很方便。另一种方法是使用参数调用Foo的第一个构造函数并将它们重定向到C，但这对于不同的类组合非常糟糕，如：

using Bar = A<B<A<C>,<B<B<A,C>,C>>>;

问题：如何使用运行时参数初始化嵌套（模板）类（更好/更好，更清晰）？

Answer 1

您可以使用指针并使用已构造和初始化的对象构建foo。即：

未经审查的代码

template<typename T>
 class A {
  T* t_;

public:
  A(T* valptr) : t_(valptr){}
  ~A(){ delete t_ ; }

  void call() {
    // Do something.
    t_.call();
  }
};

template<typename T, typename U>
class B {
  T* t_;
  U* u_;

public:
  B(T* val1ptr, U* val2ptr):t_(val1ptr), u_(val2ptr){}
  ~B(){delete val1ptr; delete val2ptr;}

  void call() {
    // Do something.
    t_->call();
    // Do something.
    u_->call();
  }
};

class C {
  private:
    int x_;
  public:
  C(int x):x_(x){}
  void call() {
    // Do something.
  }
};

用法：

A<B<A<C>,C>> foo( new B<A<C>,C>(new A<C>(new C(3) ), new C(3) ) );

Answer 2

此示例使用移动构造和转发帮助程序函数为分支模板类型构建值。

转发助手使用类型推断来包装构造函数，以避免需要使用复杂的参数指定每个构造函数。

在这个例子中，call（）函数转储对象子节点的参数结构和值。

#include <iostream>
#include <utility>

template<typename T>
class A {
    T t;
public:
    A(T&& t) : t{std::move(t)} {}
    void call() {
        std::cout << "A<";
        t.call();
        std::cout << ">";
    }
};
template <typename T>
inline A<T> mkA(T&& t) { return A<T>{std::forward<T>(t)}; }

template<typename T, typename U>
class B {
    T t;
    U u;
public:
    B(T&& t, U&& u) : t{std::move(t)}, u{std::move(u)} {}

    void call() {
        std::cout << "B<";
        t.call();
        std::cout << ",";
        u.call();
        std::cout << ">";
    }
};
template <typename T, typename U>
inline B<T,U> mkB(T&& t, U&& u) { 
    return B<T,U>{std::forward<T>(t), std::forward<U>(u)};
}

class C {
    int c;
public:
    C(int c) : c{c} {}
    void call() {
        std::cout << "C(" << c << ")";
    }
};

int main() {
    auto bar = mkA(mkB(mkA(C{1}), mkB(mkB(mkA(C{2}),C{3}), C{4})));
    bar.call();
    std::cout << '\n';
}

输出：

A<B<A<C(1)>,B<B<A<C(2)>,C(3)>,C(4)>>>

初始化嵌套模板类

2 个答案: