Re: Overload template function for containers
Am 12.02.2011 18:32, schrieb dec4106:
I have a template function of the form
template<typename T>
void f(const T& lhs, const T& rhs)
{
/// operate on lhs and rhs as plain variables
}
I want to create an overloaded version of this that treats the
arguments as iterable containers:
template<???>
void f( ??? )
{
/// iterate over lhs and rhs
}
If it matters, f() is a class member function, but the class itself is
not a template class.
Is this possible? Thanks.
Yes, this is possible by taking advantage of "constrained" templates.
First, you need to define a criterion what you define as an "iterable container". I assume, you have done that and are able to provide a compile-time predicate trait which expresses this characteristics:
template<class T>
struct is_iterable_container {
...
static const bool value = ...;
};
and where the static member can be used in integral constant expressions returning true, when the conditions are satisfied. Defining your concept "iterable container" is usually the hardest part, but domain-specific, so you need to describe what you actually want to describe.
In a further step, write that a helper template enable_if (The C++0x Standard Library provides it already as std::enable_if):
template<bool, class = void>
struct enable_if {};
template<class T>
struct enable_if<true, T> {
typedef T type;
};
and declare your function template as follows:
template<class T>
typename enable_if<is_iterable_container<T>::value>::type
f(const T& lhs, const T& rhs)
{
/// iterate over lhs and rhs
}
This declaration will prevent to be considered in argument deduction situations unless is_iterable_container<T>::value == true. For details see 14.8.2 p. 8 in the recent standard draft or just ask.
Alternatives to the enable_if approach exists, but that depends on the details of your discrimination criteria and on whether your compiler provides support for more C++0x functionalities.
P.S.: I wrote "constrained" above in quotation marks, because what I showed above is a workaround for real constrained templates with direct support by the language. This is worth to mention, because C++0x was very near to support real constrained templates, but the standard committee decided to defer them because there seemed to be strong evidence for making them delay the C++0x release considerably.
HTH & Greetings from Bremen,
Daniel Kr?gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]