Re: Function Template Specialization
Markus Grueneis wrote:
I recently came across some not so much but a bit surprising behaviour
when using a function template and some specializations. The code snippet
below is a bit verbose, maybe I'm missing something obvious.
I do have a template function get_value(), which returns a selected value
from an aggregate.
The template parameter is used to generalize of different types of such an
aggregate.
Then I do have a template function is_valid(), which returns a boolean
flag, depending on the aggregate content, and the set of the parameter.
So it has two template parameters (ValueSet, AggregateType).
//---------------------------------------------------------------------
//---------------------------------------------------------------------
#include <iostream>
typedef enum { id_1, id_2, id_3 } index_t;
struct FooSet {}; struct BarSet {};
typedef std::pair<int, bool> baz_t; // (value, currently-valid-flag)
//---------------------------------------------------------------------
template<class ParameterSet, class Aggregate>
bool is_valid(const Aggregate& dat) { return false; }
template<>
bool is_valid<FooSet, class Aggregate> (const Aggregate& dat) {
return true;
}
template<>
bool is_valid<BarSet, class Aggregate> (const Aggregate& dat) {
return true;
}
There is no class named "Aggregate" defined in this program, so there
are no instances of Aggregate class objects that could be passed as the
argument to is_valid(). So the reason why these specializations are not
instantiated is simply because there is no way to call either one -
unless and until a class named Aggregate is defined.
Clearly Aggregate was meant to serve as a template type parameter and
not meant to be interpreted as forwardly-declared name of a class.
Changing the declaration accordingly though will no longer compile,
because partial specializations are legal only for template classes:
// illegal partial specialization
template<class Aggregate>
bool is_valid<BarSet, Aggregate>(const Aggregate& dat);
Full specializations of template functions are legal, but there is
little reason ever to declare one. The reason being that only the
function template is considered in the overload resolution process, so
the existence of a full specialization does not necessarily mean that
it will be called - even when the argument types match those of the
specialization. To obtain the expected behavior, the program should
declare a function overload with the specific types, not a function
template specialization.
Greg
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]