Re: Sharing generic bodies across instantiations.

[Maciej Sobczak <see.my.homepage@gmail.com>]

On 28 Lip, 13:27, "Peter C. Chapin" <pcc482...@gmail.com> wrote:

> For example
>
> template< typename T >
> void f(const T &object)
> {
>   typename T::helper internal;
>   ...
>
> }
>
> Here T::helper might be a class or a typedef.

Which makes no difference from the point of view of how to implement
that.
Think about:

char buf[sizeof(T)];

This is essentially the only problem that you have to solve, and that
does not seem to be very difficult.

> Depending on what it is a
> wide variety of uses are possible.

No, all uses have to be compatible with the code of the template. Even
though each T can have different ways of being used, the template has
to target the common subset of all such possibilities - otherwise the
program will not compile.
In other words, it does not matter how wide is the variety introduced
by different Ts - if the program compiles at all, it means that the
template is compatible with the common subset of all Ts uses. This
removes the variety out of the picture.

> There could well be other corner cases
> I'm not seeing right now... that is the 'nature' of C++ of which I spoke.

Sorry, but you did not identify any corner case for the moment.

> I realize that implementing the shared model in Ada would be hard as
> well, but Ada constrains much more the way names in generic bodies can
> be used.

Not really. AARM explicitly refers to the code copying when defining
the meaning of generics, see 12.3, especially this:

"The instance is a copy of the text of the template." (12.3/13)

and then a whole lot of consequent descriptions that are implied by
this.

I would even say that by being so explicit with this, AARM gives more
reasons to do macro-expansion than C++.

> > But, for the sake of exercise, think about a C++ *interpreter*.
>
> That seems like a different situation to me. A pure interpreter executes
> code only as needed and only when needed. Without a compilation step
> isn't the question of shared or replicated bodies meaningless?

Bingo and that's my point. This is why it does not make any sense to
say that C++ prevents some implementation scenario.
I can even imagine a combined approach, where each instantiation has a
facade that is distinct (this can target stuff like static objects)
and an actual implementation that is shared.

--
Maciej Sobczak * http://www.inspirel.com

YAMI4 - Messaging Solution for Distributed Systems
http://www.inspirel.com/yami4