Re: Sharing generic bodies across instantiations.

["Randy Brukardt" <randy@rrsoftware.com>]

"Maciej Sobczak" <see.my.homepage@gmail.com> wrote in message 
news:14342188-c6f4-4b60-9284-8eff4f3f9ecd@k19g2000yqc.googlegroups.com...
...
> 2. How does this affect the amount of late binding and why is there
> less of it than with C++ templates?

You need to read about the Ada contract model for generics. (Off-hand, I 
can't think of a good reference, however.) Part of the Ada contract model is 
that there cannot be an error caused by the actual parameters of an instance 
in an instance body. Tucker Taft liked to describe the model as 
"assume-the-best" in the specification and "assume-the-worst" in the generic 
body. Thus there are a lot of things that are illegal in a generic body in 
Ada simply because they *could* be illegal in some instance of that generic. 
C++ has no such counterpart (indeed, I recall reading that Stoustrup [sp] 
explicitly eliminated it from C++ templates because it was too complex).

In addition, binding of names in the generic body always takes place at the 
point of the compilation of that body. That means that most operations at 
determined at that point, facilitating sharing. (This also causes the 
sometimes bug of "reemergence" in generics, where a hidden predefined 
operator is used instead of the user-defined one for the actual type.) C++ 
uses a more macro approach to template expansion.

                Randy.

P.S. When Dmitry talks about "macros", he means the general concept of macro 
processing. You seem to think he's talking about C macros, which is a 
specific instance of macro processing. It is pretty likely that some form of 
macro processing will be used to implement templates (and Ada generics in 
most compilers), but that has nothing whatsoever to do with the C 
preprocessor.