I have seen in some code the following :
template<const Foo& bar>
I was told its purpose was to handle big structures.
Can't we then use const & directly in the code non-templatized arguments ?
Can it be considered a good practice to pass object references around as arguments using a const reference as template parameter ?
This is a non-type template parameter, which happens to be of type const Foo&.
Whatever its use there is ("big structures" isn't really that descriptive), like all non-type template parameters its advantage is to be usable at compile-time (for example in metaprograms), its drawback is that you must have its value at compile-time. It being a compile-time constant may also help the compiler optimize it better.
Here are some examples :
struct Foo {};
/////////////////////////////////
// Type template parameter :
template <class T>
struct TypeParame {
T const &tRef; // T is a type
};
/////////////////////////////////
// Non-type template parameters :
// Integral type
template <int I>
struct NonTypeParam {
// I is a value
enum { constant = I };
};
// Reference
template <Foo const &F>
struct RefParam {
// F is a value again
Foo const &ref = F;
};
// Pointer
template <Foo const *F>
struct PtrParam {
// F is still a value
Foo const *ptr = F;
};
// More are possible, but...
// error: 'struct Foo' is not a valid type for a template non-type parameter
template <Foo F>
struct ValParam {};
template<const Y& b> struct Z {}; which correspond to what I have seen sometimes. Can't we have an equivalent with template<Y b> and use the reference elsewhere ?
template <class T> will enable you to then decorate T however you want (e.g T&). With non-type template parameters though, the parameter is the value. So, no.