Ich habe so etwas wie den folgenden Code:

   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; }

Ich würde es gerne mit den vorgeschlagenen variadischen Vorlagen aus dem kommenden Standard neu implementieren. Alle Beispiele, die ich bisher online gesehen habe, scheinen jedoch wie gedruckte Beispiele zu sein, der Unterschied hier scheint die Verwendung von Referenzen zu sein. Ich habe mir folgendes ausgedacht:

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...); }

Was ich gerne wissen würde ist:

Sollte ich r-Werte anstelle von Referenzen verwenden?

Mögliche Hinweise oder Hinweise, wie ich das, was ich will, richtig ausführen kann.

Welche Garantien bietet der neue vorgeschlagene Standard in Bezug auf die Ausgabe der rekursiven Funktionsaufrufe? Gibt es Hinweise darauf, dass die obige variadische Version so optimal ist wie das Original? (soll ich inline oder so etwas hinzufügen?)