Tengo algo como el siguiente código:

   template<typename T1, typename T2, typename T3, typename T4>
   void inc(T1& t1, T2& t2, T3& t3, T4& t4) { ++t1; ++t2; ++t3; ++t4; }

   template<typename T1, typename T2, typename T3>
   void inc(T1& t1, T2& t2, T3& t3) { ++t1; ++t2; ++t3; }

   template<typename T1, typename T2>
   void inc(T1& t1, T2& t2) { ++t1; ++t2; }

   template<typename T1>
   void inc(T1& t1) { ++t1; }

Me gustaría volver a implementarlo usando las plantillas variadas propuestas del próximo estándar. Sin embargo, todos los ejemplos que he visto hasta ahora en línea parecen ser ejemplos impresos, la diferencia aquí parece ser el uso de referencias. Se me ocurrió lo siguiente:

inline void inc() { }

template<typename T>
inline void inc(T&& t) { ++t; }

template<typename T,typename ... Args>
inline void inc(T&& t, Args&& ... args) { ++t; inc(args...); }

Lo que me gustaría saber es:

¿Debo usar valores r en lugar de referencias?

Posibles pistas o pistas sobre cómo lograr lo que quiero correctamente.

¿Qué garantías ofrece el nuevo estándar propuesto con respecto al tema de las llamadas a funciones recursivas? ¿Hay alguna indicación de que la versión variadic anterior sea tan óptima como la original? (¿debo agregar en línea o algo así?)