Re: Concerning n2157 and is_empty specification
On 3/13/07 1:19 PM, in article 55o7vqF261fmfU1@mid.individual.net, "Alf P.
Steinbach" <alfps@start.no> wrote:
* Greg Herlihy:
The NonEmpty example is in fact doubly misleading. Because (somewhat
paradoxically) a NonEmpty base class is still eligible for the empty
base class optimzation - and may in fact contribute zero bytes to the
size of subclass object (thereby affirming for a second time that
NonEmpty is an empty class). The only stipulation is that the size of
the derived class on its own (that is, without the NonEmpty base
class) would be at least equal to the size of a NonEmpty object.
So whether defined by its zero bits of information or by the zero
bytes of incremental storage - it's clear that the "oversight" and
(unsuccessful) attempt to define an "empty" class is found in the "C++
Templates" book and not in the proposed wording for is_empty<> type
trait - which is accurate in its current wording.
Uh, well. Albert, some words? (Albert kicks in) "All is relative!"
With a class such as NonEmpty it seems to me it depends on the derived
class (specifically, its size) whether the empty base class optimization
can be applied or not.
In order for the Empty Base Class Optimization to be applied to a base class
- the base class must (naturally enough) be "empty". And the std::is_empty<>
type trait (in the wording originally proposed) performs precisely that test
for emptiness. Granted, there are other factors that determine whether an
empty base class may be optimized in a given situation (for example, the
compiler might not support the optimization) - but in the abstract case, the
distinction between empty and non-empty classes is not relative - but
absolute: an empty class is one whose size (as a subobject) may be optimized
to zero bytes (under the right circumstances). A non-empty class is one
whose size (as a sub- or as a complete object) may never be optimized to
zero bytes - under any circumstances.
So the reason why NonEmpty is an empty class, is because there are
circumstances under which a NonEmpty base class contributes nothing to the
size of the complete object.
If is_empty<> is meant to say whether EBCO can be applied, it seems to
me it needs the size information about the derived class, or must simply
not apply to this case (compile time error?), and if it's not meant to
say whether EBCO can be applied, what is it for?
The std::is_empty<> type trait is supposed to be ideally-suited for testing
whether a base class is ever eligible for the EBC optimization. Where the
"C++ Templates" book went astray was assuming that the the target of the
empty base class optimization (and of the is_empty type trait as well) was
the complete class object itself. Granted, the complete type benefits from
the EBCO, but as its very name suggests, the optimization is applied to the
empty base class. So is_empty<NonEmpty> is really testing whether a class
that adds NonEmpty as a base class is certain to become larger by doing so,
or whether there is a possibility (but by no means a guarantee) that its
size would remain unchanged.
Unfortunately, if std::is_empty<> template type trait is hacked in order to
force is_empty<NonEmpty>::value to evaluate to false, then the is_empty<>
template would no longer be able to test whether a class's base class was
empty and - by extension - to test whether the complete class type may
benefit from the EBCO. In fact, by returning inaccurate results is_empty<>
would no longer have any discernable, useful purpose (that I can discern) -
and would in fact have the less-than-useful effect of propagating the same
errors, illogic and confusion evident in the C++ Templates book's discussion
of empty class types into the C++ Standard itself.
Greg
---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:std-c++@ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]