具有构造函数转发的类模板

Question

I wondering what was the best way of implementing the following.

I have a number of classes that derive from an abstract class, BaseClass . I want to create a new class ParallelBaseClass that basically performs a parallelization of all children of BaseClass .

The design I was thinking of was this:

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));
   }
}

However, I don't know that this is the best design. I have two issues:

1. Ensuring that the template type is a descendent of BaseClass
2. forwarding constructor arguments as shown above.

Any guidance is greatly appreciated.

Thanks!

Answer 1

Following may help:

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)...));
    }

};

Usage:

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

ParallelBaseClass<B> p;

p.Add<D>(42);

Answer 2

If the classes are such that they all have a function (for example execute ) that does something, and ParallelBaseClass should call it on several objects at the same time in different threads, this might be a design:

#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()
    }
}

The constructor is a variadic template function that forwards the arguments to D 's constructor. std::forward forwards than as rvalue reference or as reference when possible. The ... expands the template parameter pack. explicit makes sure that an int can't be implicitly converted to a ParallelBase using a construction with zero args arguments.

Here Base is abstract and polymorphic. This would correspond to a composition design pattern. Parallel (not a base class here) corresponds to a parallelization of the functionality of D , and has an execute implementation itself.

Update Fixed move construction.