How to use variadic template function correctly - c++

Question

I have some structs and an enum that look like this:
enum NUM
{
A = 0,
B,
C
};
struct X{};
struct Y{};
I'd like to create a variadic template for a function that looks like this:
template<NUM n, typename...Args>
void func(const Args&...a);
I'd like to specialize the template function func in cases like this:
if NUM::A define func as
template<> void func<A, X>(const X& x)
{
var.emplace_back(std::make_shared<SomeClass>(x));
}
if NUM::B define func as
template<> void func<B,X,Y>(const X& x, const Y& y)
{
var.emplace_back(std::make_shared<SomeOtherClass>(x,y))
}
Could you help me tidy it up with variadic templates?

Answer 1

Partial specialisation of functions can be achieved by deferring the implementation of the function to a function object template, which because it is a class template, can be partially specialised.
example:
#include <memory>
#include <vector>
enum NUM
{
A = 0,
B,
C
};
struct X{};
struct Y{};
// guess at missing code in question
struct SomeBase
{
virtual ~SomeBase() noexcept;
};
struct SomeClass : SomeBase
{
SomeClass(const X&);
};
struct SomeOtherClass : SomeBase
{
SomeOtherClass(const X&, const Y&);
};
std::vector<std::shared_ptr<SomeBase>> var;
// helper base class
struct func_impl_common
{
func_impl_common(std::vector<std::shared_ptr<SomeBase>>& var) : var(var) {}
std::vector<std::shared_ptr<SomeBase>>& var;
};
// general template
template<NUM n, typename...Args> struct func_impl;
// now specialise for A X
template<> struct func_impl<A, X> : func_impl_common
{
using func_impl_common::func_impl_common;
void operator()(X const& x) const
{
var.push_back(std::make_shared<SomeClass>(x));
}
};
// now specialise for B X Y
template<> struct func_impl<B, X, Y> : func_impl_common
{
using func_impl_common::func_impl_common;
void operator()(X const& x, Y const& y) const
{
var.push_back(std::make_shared<SomeOtherClass>(x, y));
}
};
// define func in terms of function object template
template<NUM n, typename...Args>
void func(const Args&...a)
{
auto op = func_impl<n, Args...>(var);
op(a...);
}
// test
int main()
{
func<A>(X{});
func<B>(X{}, Y{});
}
However, if this is a real design it seems a little suspect.