Class 带有构造函数转发的模板

Question

我想知道实施以下内容的最佳方式是什么。

我有许多 class 是从抽象 class、BaseClass 派生出来的。我想创建一个新的 class ParallelBaseClass，它基本上对 BaseClass 的所有子项执行并行化。

我想到的设计是这样的：

template <class D>
class ParallelBaseClass
{
  private:
     std::vector<D> _classes;

   public:

   ParallelBaseClass(int threads, constructor_args)
   {
       for(int i = 0; i < threads; i++)
         _classes.push_back(D(constructor_args));
   }
}

但是，我不知道这是最好的设计。我有两个问题：

确保模板类型是 BaseClass
如上所示转发构造函数参数。

非常感谢任何指导。

谢谢！

Answer 1

以下内容可能会有所帮助：

template <class Base>
class ParallelBaseClass
{
private:
     std::vector<std::unique_ptr<Base>> classes;

 public:

    template<typename Derived, typename ... Ts>
    void Add(Ts&&...args)
    {
        classes.push_back(std::make_unique<Derived>(std::forward<Ts>(args)...));
    }

};

用法：

struct B { virtual ~B() = default; };
struct D : B { D(int) {} };

ParallelBaseClass<B> p;

p.Add<D>(42);

Answer 2

如果 classes 都有一个函数（例如 execute）做某事，并且 ParallelBaseClass 应该同时在多个对象上调用它在不同的线程中，这可能是一个设计：

#include <utility> // for std::forward

class Base {
public:
    virtual void execute() = 0;
}


class Example : public Base {
public:
    void execute() override { .... }
}

template<typename D>
class Parallel : public Base {
private:
    std::vector<D> objects_; // Called objects, since classes refers to the type and not instances of it
public:
    template<typename... Args>
    explicit ParallelBase(int threads, Args&&... args) {
        for(int i = 0; i < threads; ++i)
            objects_.emplace_back( args... );
            // not using std::forward<Args>(args)... here:
            // need to make (multiple) copies instead of moving
    }

    void execute() override {
        for(D& obj : objects_)
            //create thread and run objects_[i].execute()
    }
}

构造函数是一个可变参数模板函数，它将参数转发给 D 的构造函数。 std::forward 转发 than 作为右值引用或尽可能作为引用。 ... 扩展模板参数包。 explicit 确保不能使用零 args 个参数的结构将 int 隐式转换为 ParallelBase。

这里Base是抽象和多态的。这将对应于组合设计模式。 Parallel（这里不是基础 class）对应于 D 功能的并行化，并且本身有一个 execute 实现。

更新固定移动结构。

Class 带有构造函数转发的模板

Class template with constructor forwarding

c++

templates