After thinking about boost::ref and the auto_ptr by_ref trick, I
wondered if these could be applied to the function forwarding
problem, like so:
template <typename R, typename T1, typename T2, ...>
R f(by_ref<T1> v1, by_ref<T2> v2, ...)
{
g(v1, v2, ...);
}
template <typename T>
class by_ref
{
// ... like boost::reference_wrapper
};
template <>
class by_ref<int>
{
// value-semantics specializations for fundamental types
};
template <>
class by_ref<double>
{
// value-semantics specializations for fundamental types
};
template <typename T>
class by_ref<T*>
{
// ...
};
// etc.
So the default would be to pass by reference, and provide
specializations for known types that should be passed by value,
and let the user specify other types that are pass-by-value.
Another alternative would be go by size, maybe like so:
template <typename T, bool Big = sizeof(T) > 8>
class by_ref
{
// reference semantics
};
template <typename T>
class by_ref<T, false>
{
// value semantics
};
Is this is a worthwhile idea to pursue? Am I missing any critical
details? I realize there is still a problem with const vs. non-const
references, but I won't even try to solve that. ;)
Dave
_______________________________________________
Unsubscribe & other changes: http://lists.boost.org/mailman/listinfo.cgi/boost
