Re: Are homonymous non-template and template classes incompatible?
Sylvain GUILLEY wrote:
It is common practice to implement an abstract interface by
several concrete parametrized classes, like in the example
below:
struct abstract // Interface
{
virtual void do_it()=0;
virtual ~abstract() {}
};
template<typename T> struct concrete: abstract // Implementation
{
void do_it() {}
};
When a concrete object is instanciated with T=int, the
following mangling is generated by the compiler:
00000000 V typeinfo for abstract [mangled into: _ZTI8abstract]
00000000 V typeinfo for concrete<int> [mangled into: _ZTI8concreteIiE]
For sure, this mangling is compiler-dependent; however, it is
remarkable that, if we had chosen different names for our
classes, the mangling would always differ.
Supposing that there is mangling. It's an implementation detail
which isn't of interest unless you are writing a compiler.
Consequently, I would like to give to "abstract" and to
"concrete" the same name, say "my_class", as illustrated in
the code "template.cpp" (12 lines) listed below:
struct my_class // Interface
{
virtual void do_it()=0;
virtual ~my_class() {}
};
template<typename T> struct my_class: my_class // Implementation
{
void do_it() {}
};
my_class<int> my_obj; // Object instanciation
And how on earth is the reader of the code -- compiler or human
being -- supposed to know which one is meant where?
G++ is definitely confused by this code:
Not as much as a human reader would be.
g++ -c template.cpp -o /dev/null
template.cpp:7: error: `my_class' is not a template type
template.cpp:8: error: recursive type `my_class' undefined
template.cpp:8: error: redefinition of `struct my_class'
template.cpp:2: error: previous definition of `struct my_class'
template.cpp:12: error: non-template type `my_class' used as a template
template.cpp:12: error: ISO C++ forbids declaration of `my_obj' with
no type
template.cpp:11: confused by earlier errors, bailing out
Is this a limitation of the compiler or of the C++ language?
It's more along the lines of a basic principle common to just
about every modern language -- in a given context, a symbol has
one, and only one meaning. (In the case of C++, there are a few
strange exceptions, for reasons of C compatibility. But they
don't affect this example in any way.)
The basic motivation is clarity for the human reader; techniques
to handle this in a compiler are known.
My opinion is that if the compiler parser was able to cope
with the syntax, then the generated code would be supported by
any linker because of the different mangling of non-template
and template homonymous classes.
And if pigs had wings, they could fly. How on earth could the
compiler parser possibly cope with this? For that matter, how
on earth could a human reader cope with it?
--
James Kanze GABI Software
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! ]