Ho il seguente pezzo di codice, ad esempio dec_proxy tenta di invertire gli effetti dell'operatore di incremento sul tipo che viene eseguito in una chiamata di funzione complessa foo - che btw non posso cambia l'interfaccia di.Passare i temporari come riferimenti non const in C++
#include <iostream>
template<typename T>
class dec_proxy
{
public:
dec_proxy(T& t)
:t_(t)
{}
dec_proxy<T>& operator++()
{
--t_;
return *this;
}
private:
T& t_;
};
template<typename T, typename S, typename R>
void foo(T& t, S& s, R& r)
{
++t;
++s;
++r;
}
int main()
{
int i = 0;
double j = 0;
short k = 0;
dec_proxy<int> dp1(i);
dec_proxy<double> dp2(j);
dec_proxy<short> dp3(k);
foo(dp1,dp2,dp3);
//foo(dec_proxy<int>(i), <---- Gives an error
// dec_proxy<double>(j), <---- Gives an error
// dec_proxy<short>(k)); <---- Gives an error
std::cout << "i=" << i << std::endl;
return 0;
}
Il problema è che per i vari tipi mi piacerebbe usare dec_proxy Io attualmente richiedono la creazione di un'istanza specializzata di dec_proxy - sembra un approccio molto disordinato e limitata.
La mia domanda è: qual è il modo corretto per passare temporaries così brevi come parametri di riferimento non const?
Perché non passare l'oggetto in base al valore? –
Perché, così è stato definito foo, non posso cambiare foo e perché foo prende più parametri. –
In tal caso, ottima domanda. –