Re: Terminology in english :)
On 17 mar, 16:38, Taras_96 <taras...@gmail.com> wrote:
Thanks Andrey, James, and Victor for your excellent responses.
So, if I understand correctly:
1) Overload resolution can be done by the compiler where the function
is called
2) Since transform is templated, it is overloaded (and it also has a C
version)
Not quite (and it certainly doesn't have a C version). Since
transform is a function template, it doesn't exist as a function
until the compiler has worked out what arguments to use. In
theory, you could specify them explicitly, e.g.
std::transform< ... >( ... ) ;
In practice, you're not going to want to. (The first template
argument is something like std::basic_string< char,
std::char_traits< char >, std::allocator >::iterator. And the
others aren't any simpler.) You'll want compiler to do
automatic type deduction. But the compiler can't do that until
it knows that type it has to deduce from.
3) In this case, the overload resolution must be done where transform
is called (template argument deduction from a functioncall). But in
order for template argument deduction to be done, we must tell the
compiler what 'version' of the function to use. This is what the cast
does.
Exactly.
4) By using functors we can accomplish delaying the overload
resolution until the function is actually called within the transform
function, similar to 1).
That's not really the difference. In this case, you're
arranging for the type of the unary_function to be a
non-template class type. No template, and the compiler knows
the exact type.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34