Question

**I’ve gotten a few suggestions to make my function pure generic, which would work, but I’d prefer limiting the function to only accept Base and its children.

Having trouble making a function that can accept arguments of a variadic template class base type, while the function will actually be called with classes that derive from Base. I’ve tried a few things. Here’s the general idea. Given:

template<typename... Args> struct Base {
    std::tuple<Args...> data;
    ... //other stuff
};

struct DerivedA : Base<string, int> {
};

struct DerviedB : Base<bool, string, int> {
};

What’s the correct way to create a function that does this:

string moosh_together(Base A, Base B) { //I only need access to Base's members
    return get<0>(A.data) + get<1>(B.data);
}

main() {
    DerivedA aThing;
        get<0>(aThing.data) = "foo";
    DerivedB bThing;
        get<1>(bThing.data) = "bar'd";
    cout << moosh_together(aThing, bThing) << endl;
}

Output:

foobar'd

I’ve tried a few variations of the moosh_together function, none of which work. Leaving it as above generates a compiler error about missing template arguments. I’m unsure how to pass through to the function the template arguments that define DerivedA and DerivedB.

Other things I’ve tried (shotgun method):

string moosh_together(Base<> A, Base<> B) {}
//err: conversion from 'DerivedA' to non-scalar type 'Base<>' requested

template<Base<typename... Args> T1, Base<typename... Args> T2>
string moosh_together(T1 A, T2 B) {}
//err: expected paramter pack before '...'

template<Base<Args...> T1, Base<Args...> T2>
string moosh_together(T1 A, T2 B) {}
//err: 'Args' was not declared in this scope

Answer 1

Edit:

If you need both parameter packs, you can just put both in the template specification:

template<typename... ArgsA, typename... ArgsB>
string moosh_together(const Base<ArgsA...>& A, const Base<ArgsB...>& B) {
    return get<0>(A.data) + get<1>(B.data);
}

This works because the parameter packs are inferred from arguments and not specified in a list. Naturally you can’t have a class that depends on multiple parameter packs.