Re: how to boost::range_size work?
Greg Herlihy wrote:
Function templates parameterized with non-type parameters, such as
to_vector(), are rarely useful.
I'm not sure how rare you mean by rarely; they are certainly in
the minority. On the other hand, I can hardly imagine a program
which didn't use a couple of them; things like:
template< typename T, size_t N >
T*
begin( T (&array)[ N ] )
{
return array ;
}
template< typename T, size_t N >
T*
end( T (&array)[ N ] )
{
return array + N ;
}
template< typename T, size_t N >
size_t
begin( T (&array)[ N ] )
{
return N ;
}
Such functions really belong in everyone's toolkit.
I wonder: was there a proposal to add them to the standard? If
not, and it isn't too late, I'll write one up in time for the
next meeting. (It's surely too late for anything significant,
but this seems simple enough that perhaps the committee could
squeeze it in.)
After all, if the value of a parameter
is known at compile time, then why is a function needed?
Because the programmer may not know as much as the compiler, and
at any rate, is far less competent when it comes to counting.
The function is needed so that template argument deduction
occurs; not the usual reason for using a function, I know, but a
fairly frequent one where templates are involved.
Furthermore, a
function template with a non-type parameter is prone to cause "code
bloat" by adding a signficant number of (nearly identical) routines to
a program that are not really needed.
Well, this is one case where I would make an exception, and
declare the functions "inline" up front:-). Come to think about
it, I think that any time a function is used only to get
template argument deduction, it should probably be inlined
without further thought. (Most such examples do involve types,
and exist mainly to avoid having to name the type. Things like
std::make_pair, for example.)
Besides, the syntax for initializing a vector can more ecomonical
without using a special function:
int main()
{
const int N = 5;
int V[ N ] = { 1, 2, 3, 4, 5 };
std::vector<int> vec( V, V+N );
...
Except that typically, you won't define a const N. You'll let
the compiler do the counting:
static int const init[] = { 1, 2, 3, 4, 5 } ;
std::vector< int > v( begin( init ), end( init ) ) ;
// ...
That's the whole point: the compiler can count better than you
can.
--
James Kanze (Gabi Software) email: james.kanze@gmail.com
Conseils en informatique orient?e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S?mard, 78210 St.-Cyr-l'?cole, France, +33 (0)1 30 23 00 34
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]