Re: instantiating a template on an incomplete type?
* Bart van Ingen Schenau:
Alf P. Steinbach wrote:
* Kai-Uwe Bux:
I am thinking of [17.4.3.6/1-2]:
In certain cases (replacement functions, handler functions,
operations on types used to instantiate standard library template
components), the C++ Standard Library depends on components
supplied by a C + + program. If these components do not meet their
requirements, the Standard places no requirements on the
implementation.
In particular, the effects are undefined in the following cases:
...
? if an incomplete type (3.9) is used as a template argument when
instantiating a template component.
That seems to be the case for
#include <memory>
class Foo;
int main() { std::auto_ptr<Foo> p; }
although it may be argued that std::auto_ptr's more specific
requirement that 'delete p.get()' is well-formed means that it's OK
with incomplete type as long as it has a trivial destructor.
But the question for the xyz example above is, is std::vector<xyz> at
all instantiated, in the standard's meaning of that term for a
template, in that code?
This is, I think, what must be shown in order to invoke ?17.4.3.6/1-2,
and the point of my comment about apparently very "lazy" template
instantiation.
The example in question is:
class xyz;
typedef std::vector<xyz> xyz_list;
class xyz {
xyz_list more_of_mine;
};
According to clause 14.7.1/1, the std::vector template must be
instantiated for the template argument int at the latest when the
compiler reaches the declaration of the member xyz::more_of_mine,
because there a completely-defined object type is needed and the type
xyz_list is an alias for std::vector<int>.
I tend to agree that that's the conclusion, but it doesn't tell why the complete
type is required at that particular point.
Indeed, the following is fine and good C++ (as far as I know :-)):
struct Foo;
struct Bar
{
Foo blah();
};
struct Foo {};
Foo Bar::blah() { return Foo(); }
int main()
{}
And the practical reason the complete type is needed before compilation of the
definition of Bar::blah is that for this, sizeof(Foo) must be known and other
operations such as here default-construction must be known.
However, while compiling the definition of struct Bar no machine code needs to
be emitted, and essentially nothing but the name of Foo and that it's a type
needs to be known, which is the practical reason why the pure declaration of
Bar::blah is OK.
And considering that practical reason why Bar::blah is OK, the question is still
why it's invalid to declare a Foo member variable above (which any compiler will
diagnose), and in general why the complete type is required at that point, or,
as an alternative, perhaps "affects the semantics of the program"?
It's pretty unclear to me.
Like the code above, imagining myself as a compiler I would have no technical
problem compiling a Bar definition with a member variable of type Foo (except
that the standard apparently forbids that, and why/how is the question). I'd
only really need the complete Foo type when I came to e.g. a sizeof(Bar) or
something. Even then -- to take this train of thought to its end station --
I could probably make do by back-patching the generated code. :-)
Clause 14.6.4.1/3 then tells us that the point-of-instantiation (POI)
for the template is immediately before the definition of class xyz.
As the POI is at a location where class xyz is incomplete, clause
17.4.3.6/2 makes it clear that the program has UB.
As a side note, I could not quickly determine if the typedef declaration
itself requires std::vector to be instantiated. If so, then the POI
moves to just before the typedef without affecting the reasoning above.
Yeah, I think perhaps that aims somewhere in the region of the heart of the matter.
Cheers, & thanks (but still unclear),
- Alf
--
Due to hosting requirements I need visits to <url: http://alfps.izfree.com/>.
No ads, and there is some C++ stuff! :-) Just going there is good. Linking
to it is even better! Thanks in advance!