Question

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

我有许多派生自抽象类BaseClass的类。我想创建一个新的类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

如果类是这样的，它们都有一个函数（例如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转发而不是作为右值引用或尽可能作为参考。 ...扩展了模板参数包。 explicit确保int无法使用带有ParallelBase个参数的构造隐式转换为args。

这里Base是抽象的和多态的。这将对应于构图设计图案。 Parallel（此处不是基类）对应D功能的并行化，并且自身具有execute实现。

<强>更新固定移动建筑。

类模板与构造函数转发

2 个答案: