Template Deduction of Base Template Parameters through Smart Pointers and Conversion - c++

Question

See Compiler Explorer for a full example: https://godbolt.org/z/_rVFvO
Given an abstract template class Runnable and an implementation Derived inheriting from Runnable<int>:
#include <iostream>
#include <memory>
using namespace std;
template<class... Args>
struct Runnable
{
virtual ~Runnable() = default;
virtual void f(Args... args) const = 0;
};
struct Derived : public Runnable<int>
{
void f(int x) const override
{
cout << "f(" << x << ")" << endl;
}
};
What is the underlying reason the template parameter deduction for the function accept_variadic fails given the smart pointer to a derived type?
template<class... Args>
void accept_variadic(std::unique_ptr<Runnable<Args...>> o, Args&&... args)
{
o->f(forward<Args>(args)...);
}
int main()
{
accept_variadic(make_unique<Derived>(), 5); // Error (no conversion)
return 0;
}
But given a reference (or pointer) directly without a smart pointer works:
template<class... Args>
void accept_variadic_ref(const Runnable<Args...>& o, Args&&... args)
{
o.f(forward<Args>(args)...);
}
int main()
{
accept_variadic_ref(Derived(), 5); // OK
return 0;
}
Also, is there a way to support a similar usage with template class deduction guides or using a different smart pointer (owning raw pointers and non lifetime extending references would be difficult in my application).

Answer 1

Instead of:
template<class... Args>
void accept_variadic(std::unique_ptr<Runnable<Args...>> o, Args&&... args)
{
o->f(forward<Args>(args)...);
}
You can use TMP to get what you want:
template<class T, class... Args>
std::enable_if_t<std::is_convertible_v<std::unique_ptr<T>,
std::unique_ptr<Runnable<Args...>>>>
accept_variadic(std::unique_ptr<T> o, Args&&... args)
{
o->f(forward<Args>(args)...);
}
(See full code here)
This is not 100% equivalent, since the propose solution accepts a std::unique_ptr of the Derived type, while the original code will accept only the base type.
The original code does not work, since the templates do to match types that require conversion. In your code, the two std::unique_ptr types are not base/derived of each other, so the templates won't match.
With the proposed solution, the function accepts the original std::unique_ptr, provided that it can be converted to the base type inside the function. The std::enable_if_t makes sure that other types don't match, only the ones that can be converted to the base.
Edit
In some variants of the question, the original solution could be problematic. This can happen in question variants in which calling f() on a base class is treated differently than calling f() on the derived class. There are several possibilities when this can happen (but not in the original question). To overcome this risk, accept_variadic() should be altered to:
template<class T, class... Args>
std::enable_if_t<std::is_convertible_v<T&, Runnable<Args...>&>>
accept_variadic(std::unique_ptr<T> o, Args&&... args)
{
// could also be solved with
// std::unique_ptr<Runnable<Args...>> base = std::move(o);
Runnable<Args...> & runnable = *o;
runnable.f(forward<Args>(args)...);
}