Últimamente escribí una función de plantilla para resolver algunas repeticiones de código. Se parece a esto:
template<class T, class R, class... Args>
R call_or_throw(const std::weak_ptr<T>& ptr, const std::string& error, R (T::*fun)(Args...), Args... args) {
if (auto sp = ptr.lock())
{
return std::invoke(fun, *sp, args...);
}
else
{
throw std::runtime_error(error.c_str());
}
}
int main() {
auto a = std::make_shared<A>();
call_or_throw(std::weak_ptr<A>(a), "err", &A::foo, 1);
}
Este código funciona perfectamente bien para lo class A
que se ve así:
class A {
public:
void foo(int x) {
}
};
Pero no puede compilar para uno como este:
class A {
public:
void foo(const int& x) {
}
};
¿Por qué es así (por qué quiero decir por qué no puede deducir el tipo) y cómo (si es posible) puedo hacer que este código funcione con referencias? Ejemplo en vivo
Args&&...
ystd::forward
?