How to make a variadic function of smart pointers?

Question

I'm trying to make an interface an abstract class which would be implemented by derivated childs. One of methods in that class has to be variadic (children get one ore more QSharedPointer<QObject> depending on implementation)

The problem is that:

1. templated methods cannot be virtual

2. I cannot make a variadic method taking QSharedPointer<QObject>... args arguments because of error: expansion pattern ‘QSharedPointer<QObject>’ contains no argument packs.

Less words, more code:

class BaseClass {
public:
    virtual void foo(QSharedPointer<QObject>... args) = 0;
}

class ChildClassA : public BaseClass {
public:
    void foo(QSharedPointer<QObject> arg1);
}


class ChildClassB : public BaseClass {
public:
    void foo(QSharedPointer<QObject> arg1, QSharedPointer<QObject> arg2);
}

I would like to use above classes to things like that:

template <class T = BaseClass>
class Controller<T>{
    void callFoo(QSharedPointer<QObject>... args){
        T* = new T();
        T->foo(args);
    }
}

As you can see the BaseClass is only to say: use one of my children as generic type.

How do I make such things work? Is it even possible in C++?

Answer 1

Since (per the comments) you already have separated the children by arity, and they're managed by separate instantiations of a Controller class template, there is no point in trying to force them all into the same hierarchy -- that only means workarounds and runtime overhead.

Instead, let's make BaseClass a template, and use its parmeter to generate foo's signature.

namespace detail {
    template <std::size_t, class T>
    using expandHook = T;
}

template <std::size_t N, class = std::make_index_sequence<N>>
struct BaseClass;

template <std::size_t N, std::size_t... Idx>
struct BaseClass<N, std::index_sequence<Idx...>> {
    virtual void foo(detail::expandHook<Idx, QSharedPointer<QObject>>... args) = 0;
};

detail::expandHook is kind of a syntactic trick to repeat the QSharedPointer<QObject> type as many times as there are Idxes, which are 0 to N - 1 thanks to the work of std::index_sequence.

Then, children inherit from the corresponding BaseClass:

struct Child : BaseClass<2> {
    void foo(QSharedPointer<QObject>, QSharedPointer<QObject>) override;
};

Bonus: a child can inherit from several BaseClass specializations if you want it to support several arities!

Finally, a controller will be parameterized by the adequate BaseClass type, and everything clicks in.

See it live on Coliru (with stubbed types, and main's content would be what's inside a Controller).

Answer 2

If you follow the guideline that public functions should be non-virtual and virtual functions should be private, then you can solve this problem by turning the base function into a variadic template function which delegates to a virtual private function taking a std::vector.

This also has the advantage that all the unpacking happens in one place and derived classes are easier to implement.

Here is an example (I've replaced QSharedPtr with std::shared_ptr and added dummy implementations for QObject so that the example can be compiled without 3rd-party stuff):

#include <memory>
#include <vector>
#include <iostream>
#include <cassert>

struct QObject { virtual void sayHi() const = 0; };
struct DerivedQObject1 : public QObject { void sayHi() const override { std::cout << "1\n"; } };
struct DerivedQObject2 : public QObject { void sayHi() const override  { std::cout << "2\n"; } };

class BaseClass {
public:
    template <class... Types>
    void foo(std::shared_ptr<Types>... args)
    {
        std::vector<std::shared_ptr<QObject>> vector;
        pushBack(vector, args...);
        assert(!empty(vector));
        doFoo(vector);
    }

private:
    virtual void doFoo(std::vector<std::shared_ptr<QObject>> const& args) = 0;

    template<typename LastType>
    static void pushBack(std::vector<std::shared_ptr<QObject>>& vector, LastType arg)
    {
        vector.push_back(arg);
    };

    template<typename FirstType, typename ...OtherTypes>
    static void pushBack(std::vector<std::shared_ptr<QObject>>& vector, FirstType const& firstArg, OtherTypes... otherArgs)
    {
        vector.push_back(firstArg);
        pushBack(vector, otherArgs...);
    };
};

class ChildClassA : public BaseClass {
private:
    void doFoo(std::vector<std::shared_ptr<QObject>> const& args) override;
};

void ChildClassA::doFoo(std::vector<std::shared_ptr<QObject>> const& args) {
    for (auto const& arg : args) {
        arg->sayHi();
    }
}

int main() {
    ChildClassA child;
    auto obj1 = std::make_shared<DerivedQObject1>();
    auto obj2 = std::make_shared<DerivedQObject2>();
    child.foo(obj1, obj2);
}