Re: instantiating a template on an incomplete type?
* Kai-Uwe Bux:
Alf P. Steinbach wrote:
* Kai-Uwe Bux:
Hendrik Schober wrote:
Bart van Ingen Schenau wrote:
Hendrik Schober wrote:
Hi,
can I instantiate a template on an incomplete type?
In general, yes.
<snip>
This compiles just fine using VC9 and Comeau (online), but ISTR that
there was a problem with this.
The standard containers have as requirement that they can only be
instantiated on complete types, but that requirement does not carry
over to templates in general.
Thanks. That's good news.
Now. Waitaminute. That is, I cannot create a class that has
a container of objects like itself as member?
class xyz;
typedef std::vector<xyz> xyz_list;
class xyz {
xyz_list more_of_mine;
};
Wasn't it that /some of the containers/ didn't support this,
but some did?!
Nope. None of the standard containers support that. You encounter
undefined behavior and no diagnostic is required.
Uhm, I think I'd like chapter and verse for that.
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.
[snip]
As a matter of fact, most _implementations_ of, say, std::list _do_ or
_did_ support the above (but may no longer do so after the introduction
of concept checks).
Hm?
The straight forward implementation of std::list<> would support incomplete
types and do the expected thing; in particular, this used to be the case
with all implementations based upon the STL from SGI.
Are you sure you're not confusing the Assignable requirement with "complete type"?
[snip]
Cheers, and even more TIA., :-)
- 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!