Re: private destructor and templates
If any new variables
were added, they would break the layout. Therefore there can be no
non-public variables.
What if I add new public variables? Don't they break the layout of
an _existing_ struct?
Still a POD, because it is layout compatible with some C struct, namely the
C struct that also has those public variables added.
However member functions and static members of
any type do not affect the layout,
Says who?
Says me. Non-virtual member functions and static members of any type add no
per-instance overhead, and occupy no space in the layout.
and do not break existing code
referring to structure members, so they are permitted, regardless of
visibility.
What existing code? What if I'm writing a new program altogether?
What does "Drop-in replacement" mean to you? A POD means you can
reinterpret_cast back and forth at will with the corresponding C struct.
You can create an instance of the POD, and pass it by reference to a C
function, and vice versa you can receive it from a C function, cast it as
the POD, and call POD member functions on it without losing type-safety.
You can also typedef the POD type in place of the old struct and not have
any visibility errors.
How the hell should the compiler know where the code comes from?
POD is not a compiler concept. The compiler only distinguishes between "has
a v-table" and "doesn't".
A v-table is what makes an object. Without a v-table, there is no
polymorphism, no RTTI, in fact no awareness of 'type'. A class
without a v-table is just an assembly of variables and functions in a
naming scope, hardly any different from a namespace.
Bull. An object is an area of computer memory, ones and zeros. There
are no RTTI, no 'type', no "awareness". Program is another set of
the same ones and zeros. See, anything can be taken to extreme and
made absurd, if one pleases. Object is a concept that exists in terms
of the program you write. Nothing more and nothing less. Same as
a class, a POD-struct, a function, a namespace, a variable, whatever.
Pull it out of its context and you can do whatever you want with it.
An object class has a v-table uniquely identifying the type. Every instance
has a pointer to this v-table. Therefore the instance has an exact type,
known at runtime, for which that v-table is created. POD types have no
v-table.