Re: Cyclic dependency?
Greg Herlihy wrote:
kanze wrote:
Louis Lavery wrote:
The following compiles under g++ 3.2 and vc7, but should it
compile on all platforms?
/* test.cpp */
#include <list>
struct Vertex;
struct Edge;
typedef std::list<Vertex>::iterator Vit;
typedef std::list<Edge>::iterator Eit;
Formally, you have undefined behavior here. The type
expression std::list<>::iterator requires the instantiation
of the template std::list, and the standard says that
instantiating a template from the standard with an incomplete
type is undefined behavior.
The Vit and Eit typedefs don't instantiate anything.
That's not what my version of the standard says. Particularly
?7.4/4: "A class template specialization is implicitly
instantiated if the class type is used in a context that
requires a completely-defined object type or if the completeness
of the class type affects the semantics of the program; [...]"
The compiler cannot know whether std::list<Vertex>::iterator
names a type unless it has instantiated the template. And the
legality of the program depends on whether it names a type or
not.
A typedef simply creates another name for a class (or
typedef).
And the compiler needs to know a certain number of things about
that type. It may be an incomplete type, but it must be known
to be a type; in practice, it must also be known whether it is a
class type or not, and if it is not a class type, the complete
type must be known.
And there is no code or data that needs to be instantiated for
std::list<Edge>::iterator to be called by another name.
I can see you've not much experience with C++ compilers, and how
they do name mangling. The standard doesn't impose name
mangling, of course, but it is an almost universal
implementation technique, and the standard doesn't require
anything which would make it impossible. Consider the similar
case of std::vector<SomeType>::iterator. In some
implementations, this is a typedef to SomeType*; in others, it
is a typedef to a class type, or a nested class. All three
possibilities mangle differently, at least with all C++
compilers I've used.
The std::list template classes are not instantiated until they
are needed - that is not until the Edge and Vertex
declarations in main().
They're needed anytime you write std::list<SomeType>::whatever.
The compiler must know what whatever is, particularly, whether
it is a type or not, in order to parse the program.
In other words, both the Vertex and Edge classes are complete
by the time they are used as template type parameters.
Maybe in some other language, but not in C++.
--
James Kanze kanze.james@neuf.fr
Conseils en informatique orient?e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S?mard, 78210 St.-Cyr-l'?cole, France +33 (0)1 30 23 00 34
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]