template parameter-übergabe

Treb

wenn ich sowas habe :

template <class T>
class BeispielContainer
{

void addItem(const t& item) // per reference to const
{
m_cont.add(item);
}

};

dann stehe ich irgendwie vor dem dilemma, das es bei integralen typen langsamer
werden kann, weil man die nicht als reference übergeben sollte,
aber ich grosse Objekte auch nicht per-value übergeben kann // möchte

gibts dafür eine eine Lösung?

simon.gysi

Spielt Dir das wirklich eine Rolle wegen der Performance?

Treb

obwohl es schon eine rolle spielt,
ist es wohl eher interesse-halber

darf zB der Compiler sowas nach "per-value" optimieren,
so weit ich das überblicke gibt es keine semantischen
unterschiede zwischen "per-value" und "per reference to const"
(jedenfalls bei der parameter-übergabe)

oder mir fehlt da der weitblick

Fellhuhn

const_cast?

queer_boy

verwende type_traits und partielle spezialisierung oder SFINAE.

//SFINAE mit boost
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_fundamental.hpp>

template <class T>
void do_sth (T t , typename boost::enable_if<boost::is_fundamental<T> >::type* = 0)
{
}

template <class T>
void do_sth (T const &t, typename boost::disable_if<boost::is_fundamental<T> >::type* = 0)
{
}

//partielle spezialisierung mit TR1
#include <tr1/type_traits>

template <class T, bool fund = std::tr1::is_fundamental<T>::value>
struct Foo;

template <class T>
struct Foo<T, true>
{
void out (T t);
};

template <class T>
struct Foo<T, false>
{
void out (T const& t);
};

/edit: es gibt noch eine möglichkeit, aber das überlasse ich jemand anderem.

hustbaer

Der Compiler darf Optimieren was er möchte.
Das Programm muss nur das erwartete Verhalten zeigen.