Re: Using a STL container of type self in a class declaration
Now, I just reviewed the standard myself, and I'm unsure of some of
the following. I post to see if anyone can make corrections to what I
say.
On Nov 6, 9:08 pm, ros...@gmail.com wrote:
On Nov 7, 1:20 pm, Maxim Yegorushkin <maxim.yegorush...@gmail.com>
wrote:
There is a good article by Matthew H. Austern "Containers of
Incomplete Types" which explains the issue in great details.
http://www.ddj.com/database/184403814
Sorry for the confusion, but this article seems to contradict what
some people are saying -
"Can you define an incomplete type as the argument to a template?
Certainly! The C++ Standard [4] even says so explicitly."
You can instantiate a template on an incomplete type. If the template
does not do things to the template argument which require it to be a
complete type, it's OK. For example, if you have a template
template <typename T>
class vector_of_pointers
{
//..
};
vector_of_pointers just works with T*, never using T in a way that
requires it to be complete, so
class Foo;
vector_of_pointers<Foo> bar;
is perfectly fine. Foo is an incomplete type, but
vector_of_pointers<Foo> is a complete type as it never tries to use T
as a complete type.
However the article also staties that std::list<B> is an incomplete
type (if B is an incomplete type) which cannot be instantiated in an
instance of B.
std::list is unlike vector_of_pointers. Its code constructs and
destroys Ts, which requires T to be a complete type, thus
std::list<incomplete_type> is an 'incomplete type'. (Calling it an
incomplete type is probably an abuse of the term. It would probably be
better to say "ill-formed". However, you can have a pointer to
std::list<incomplete_type> as this will not instantiate the template.
See the rest of this post for the relevant discussion.)
The article also states - "You can't pass or return incomplete types
by value" which leads me to ask how do you define the + operator. We
have always written it as -
const B operator + (const B& right)
Obviously this returns B (an incomplete type) by value, am I missing
something here?
Take for example:
class Foobar
{
public:
Foobar create(); //AA
};
Foobar x = Foobar::create(); //BB
At AA, "Foobar" refers to an incomplete type. Any attempt to use
create() while "Foobar" is an incomplete type will result in undefined
behavior. However, if later we have line BB, this is ok. While
"Foobar" as the return type of create in the class definition is an
incomplete type and cannot be used, after the ending "}" of the class
definition, it is a complete type, so we may use as a complete type.
This is different from your example of
#include <list>
class B
{
std::list<B> x;
};
You can think of templates as a special pre-processor. (I know there's
a lot more to it.) When you define the member object x with
"std::list<B> x;", you instantiate the class template. This is like
telling the compiler to copy the template code, replace all the
template arguments with B, and put this new instantiated class at the
same scope as the class template. The key is the following section
from the C++ 03 standard, 14.6.2.1:
Inside a template, some constructs have semantics which may differ
from one instantiation to another.
Such a construct depends on the template parameters. In particular,
types and expressions may depend on
the type and/or value of template parameters (as determined by the
template arguments) and this determines
the context for name lookup for certain names. Expressions may be type-
dependent (on the type of a template
parameter) or value-dependent (on the value of a non-type template
parameter). In an expression of
the form:
postfix-expression ( expression-listopt )
where the postfix-expression is an identifier, the identifier denotes
a dependent name if and only if any of
the expressions in the expression-list is a type-dependent expression
(14.6.2.2). If an operand of an operator
is a type-dependent expression, the operator also denotes a dependent
name. Such names are unbound
and are looked up at the point of the template instantiation
<<<<
Forgive the standardeze. What it's trying to say is that for the
instantiatation std::list<B>, all B's in std::list are looked up at
the point of instantiation, which in your example is the class member
definition "std::list<B> x;". At this point in the class definition,
at the point of instantiation of the template, B refers to an
incomplete type. Thus, all lookup of B in the instantiated template
class will find an incomplete type. std::list contains code to create
and destroy B, among other things, and you can only create or destroy
objects of complete types, thus attempting to instantiate std::list<B>
while B is an incomplete type makes the program ill-formed.
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]