How to specializing a forwarding parameter pack? - c++

Question

I'm making use of a generic class member to forward a variable list of arguments to an external object, using forwarding arguments:
#include <utility>
#include <iostream>
#include <string>
class MyClass {
public:
MyClass() = default;
virtual ~MyClass() = default;
// ...
template < typename... Args >
void func(Args&&... args);
};
// generic definition
template < typename... Args >
void MyClass::func(Args&&... args) {
std::cout << "MyClass::" << __func__ << std::endl;
// ...
// e.g. Other(std::forward< Args >(args)...);
// ...
}
However, I'd like to account for a specific case associated with a specific signature for func e.g. func(float, const std::string&). However, I'm not entirely sure how to specialize the template to account for arguments to be passed by-value and by-reference.
I'm only able to compile a specialized definition for func that uses rvalue references:
// specialization
template < >
void MyClass::func< float&&, std::string&& >(float&& first, std::string&& rest) {
std::cout << "MyClass::" << __func__ << "(float,std::string)" << std::endl;
}
However, whereas the generic forwarding definition would be called for any combination of argument types, this specialization will only fit temporary objects. I assume the issue is related to the use of && on the template declaration, but how would one specialize for different combinations of (float, const std::string&) arguments?

Answer 1

Live demo
I can only think of this solution that uses a helper template class. The class method punts the job to a helper template class, using std::remove_cvref_t to trim off the fat:
template < typename... Args >
void func(Args&&... args)
{
helper<std::remove_cvref_t<Args>...>::func(std::forward<Args>(args)...);
}
And this now becomes mostly bog-standard specialization:
template<typename ...Args2> struct helper {
template<typename ...Args>
static void func(Args && ...args)
{
std::cout << "Generic\n";
}
};
template<> struct helper<double, std::string> {
template<typename ...Args>
static void func(Args && ...args)
{
std::cout << "Specialized\n";
}
};
With the following test code:
double v=0;
std::string s;
func(v, v);
func(v, s);
func(v, std::move(s));
The result is:
Generic
Specialized
Specialized
Now, if all the real work needs to be done by a class method, what can be done is have func() pass along *this as the first parameter to the static func()s, which then use it to forwards their remaining argument to two real class methods -- generic and specialized.
It is a reasonable bet that modern compilers will be able to optimize away the extra function calls, this is par for the course in modern C++.