Re: Template technicality - What does the standard say?
On Oct 15, 11:26 am, Stephen Horne <sh006d3...@blueyonder.co.uk>
wrote:
On Wed, 15 Oct 2008 01:45:58 -0700 (PDT), James Kanze
<james.ka...@gmail.com> wrote:
On Oct 15, 3:06 am, Stephen Horne <sh006d3...@blueyonder.co.uk> wrote:
On Tue, 14 Oct 2008 15:58:15 -0700 (PDT), James Kanze I'm
sorry, but it's basic textbook. The compiler determines
what is inherited and places each inherited class at a
particualar offset within the derived class, as if it were
member data (which it is).
You must be reading the wrong textbooks (or you don't
understand virtual inheritance), since it's provably
impossible to do so. And it's simple to try:
struct VB
...
struct M : virtual VB
...
struct D : M
{
int d ;
} ;
...
M v1 ;
v1.f( std::cout ) ;
D v2 ;
v2.f( std::cout ) ;
return 0 ;
}
I get different values for the two variables with every
compiler I try.
What this proves is that you didn't read my post.
What this proves is what I said it proves. That sizeof is not
implementable for certain types.
You haven't instantiated two instances of the same class - you
have instantiated two instances of *TWO* *DIFFERENT*
*CLASSES*.
Do you know any C++ at all? I've definitly got two instances of
M; one in one context, and one that isn't.
Given all your insistence on pedantic language, how can you
not notice that point?
Did you notice that there is an M object in the D? Do you
understand what is meant by a type?
The class M uses virtual inheritance, but it's not a dynamic
entity in itself. It's not a run-time entity at all. It has
one layout.
Which is? It quite obviously has two different layouts in my
code above, depending on whether it is a base class of D or not.
It isn't the same layout that is used for D, even for those
components that are inherited from M, but that's what you get
for using virtual inheritance. As I pointed out elsewhere,
even multiple inheritance breaks offsetof if thats what you're
dealing with.
Not at this level. Modulo access issues and possible
ambiguities, offsetof could be well defined for multiple
inheritance, as long as no virtual inheritance is involved.
This issue has NOTHING to do with applications which take the
following form...
Whether offsetof is implementable for non PODS has nothing to do
with any application. It's a matter of principle: either the
offset is fixed, or it's not. In the case of C++, it's not, at
least when virtual inheritance is involved.
Unless you're stupid enough to think the offset also applies
to instances of Node<D> which is a DIFFERENT TYPE, just as D
is a DIFFERENT TYPE to M.
Except that I can prove my statements. Both by example and
by formal proof.
But primarily by failing to read before you reply and
obsessing on an irrelevant issue, which invalidates both
so-called proofs.
If you can't read what I post before replying (or is it that
you can't admit to a mistake?), I see no point in reading on.
In other words, you've lost the argument, so you're taking your
ball and going home.
I'd suggest you actually learn C++ before trying to criticize
it.
--
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