* Noah Roberts:
That doesn't actually call the default constructor of a POD though.
A o = A();
On the contrary. What you have here is copy construction from a
zero-initialized instance (the expression 'A()' means
default-initialization, 8.5/7, which for a POD is defined as
zero-initialization, 8.5/5). That's not to say that 'A o;' necessarily
actually calls a default constructor: it doesn't affect the outcome
whether you say that there is no default constructor for a POD class (no
call), or that the default constructor does absolutely nothing (call
does nothing), but the standard specifies an implicitly declared default
constructor, 12.1/5, which if it actually exists must do nothing at all.
In particular, if you derive from class A,
struct A { /* as before */ };
struct B: A { int x; int y; B(): x(1), y(2) {} };
B o;
then you have an object 'o' with x and y initialized, and i, c, and iPtr
uninitialized. If class A had a default constructor that did
zero-initialization, then instead you would have i, c and iPtr zeroed.
But that isn't what you get, so the notion of a zeroing automatically
generated default constructor leads to incorrect, dangerous conclusions.
However, with a /conforming/ compiler,
struct B: A { int x; int y; B(): x(1), y(2), A() {} };
should ensure zero-initializion of the A base class sub-object; for a
POD this syntax does not denote a call of the (possibly existing or not)
default constructor, it instead denotes default initialization which is
defined as zero-initialization (references given above).