Come utilizzare correttamente i riferimenti con i modelli variadici

Question

Ho qualcosa di simile al seguente codice:

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

Mi piacerebbe reimplementarlo utilizzando i modelli variadici proposti dal prossimo standard.Tuttavia tutti gli esempi che ho visto finora online sembrano essere esempi stampati, la differenza qui sembra essere l'uso dei riferimenti.Ho ottenuto quanto segue:

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

Quello che vorrei sapere è:

• Dovrei usare valori r invece di riferimenti?

• Possibili suggerimenti o indizi su come realizzare correttamente ciò che desidero.

• Quali garanzie fornisce il nuovo standard proposto riguardo al problema delle chiamate di funzione ricorsive, c'è qualche indicazione che la versione variadica di cui sopra sarà ottimale quanto l'originale?(devo aggiungere in linea o qualcosa del genere?)

Answer 1

Non utilizzerei riferimenti a rvalue qui, perché ciò ti consentirà di associarti a rvalue che possono consentire codice senza senso come:

inc(1);

Quindi, resterei con i riferimenti regolari:

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

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

Answer 2

Dovrei usare valori r invece di riferimenti?

Intendi riferimenti a valore?No, non ne vedo il motivo.

Possibili suggerimenti o indizi su come realizzare correttamente ciò che desidero.

Sei già lì.Il tuo codice dovrebbe fare quello che vuoi.

Quali garanzie fornisce il nuovo standard proposto rispetto al problema delle chiamate di funzione ricorsive, c'è qualche indicazione che la versione variadica di cui sopra sarà ottimale quanto l'originale?(devo aggiungere in linea o qualcosa del genere?)

Lo standard C++ non garantisce alcun incorporamento.Potresti controllare cosa genera il compilatore.Se vuoi che tutto sia in linea, inclusa la chiamata inc più alta, potresti mettere un inline su entrambe le funzioni come a richiesta.Se vuoi qualcosa come il tuo modello non variadico, potresti racchiuderlo in questo modo:

inline void inc_impl() {}

template<typename T, typename...U>
inline void inc_impl(T& t, U&...u) { ++t; inc_impl(u...); }

template<typename...T>
void inc(T&...t) { inc_impl(t...); }

Ora inc non è in linea mentre ciascuna delle sue implementazioni probabilmente non conterrà chiamate di funzione reali quando verrà eseguito l'inlining delle chiamate inc_impl - ma ancora una volta, non c'è garanzia.

Answer 3

  

quali garanzie il nuovo standard proposti forniscono WRT il problema delle chiamate di funzione ricorsive, c'è qualche indicazione che il sopra la versione variadic sarà come ottimale come l'originale? (Devo aggiungere in linea o qualcosa di tale?)

Lo standard non garantisce un'ottimizzazione verrà eseguita, specifica solo il comportamento e il risultato. Se la funzione sarà inline problema della realizzazione.

In realtà, la parola chiave inline è solo un accenno al compilatore che viene spesso ignorato perché il compilatore può decidere meglio.

Infine, g ++ - 4.5 completamente tutte le funzioni inline inc a -O2. Non so se è quello che vuoi.