Re: Isn't this a conversion bug in gcc?
On 26 Jul., 16:13, DeMarcus <use_my_alias_h...@hotmail.com> wrote:
On 2010-07-26 01:56, DeMarcus wrote:
[..]
Ok, I realized I needed a bit compiler knowledge refresh. I found out
that it's not until A is instantiated that the error will show up.
In your example that depends on the concrete implementation
as shown in my previous posting.
Can you please confirm that the following is true?
If I do the this
struct A : Q<A>
{
};
the compiler will be able to deduce that A is a subclass of Q
At which point? Not within the definition of Q<A>.
since the compiler compiles in two steps; first it goes through all the
declarations and sees everything is ok, then it goes through all the
definitions, and it will then find out that 'return T' is valid
according to the already processed declarations where it says that A
inherits from Q. (is there a paragraph in the standard confirming this?)
No, see below.
Can you confirm that the following is correct as well?
I extended the template to look like this. Note, I changed the fnc()
return type be of type T.
template<typename T, class Base>
struct Q : Base
{
virtual T* fnc() { return new T; }
};
I extended A with some inheritance.
struct A : Q<A, EmptyClass>
{
};
This is OK, because T can be incomplete, when
the parser sees the declaration
T* Q<>::fnc();
T is required to be complete within the definition
of the function body, but that is not relevant for
the compiler when parsing the definition of Q<A,
EmptyClass>, where only the declaration of the
members is needed. The role of the second template
parameter is that of a base class, but a type must be
complete to be used as a base class. I assume that
EmptyClass is defined (not just declared), which makes
it feasible for a base class.
struct B : Q<B, A>
{
};
The compiler will give me an error saying that B is not a covariant
return type of A (while it actually is). Is the compiler unable to
deduce the covariance because of the fact that it's only part of the
declaration step?
In this example you are attempting to define
a class Q<B, A>, that has a base class A, which
again derives from Q<A, EmptyClass>. The base
class is complete and effectively has a virtual
function
A* A<>::fnc();
Now when you attempt to instantiate Q<B, A>
we have the same situation as we had in the example
before: Within Q<B, A> B is an incomplete type.
But since you are now overriding the base class,
the standard requires that the return type is a
derived class of the pointee used in the super
class. Since B is incomplete within Q<B, A>,
this declaration is ill-formed according to
10.3/6 (FCD):
"If the return type of D::f differs from the return type
of B::f, the class type in the return type of D::f shall
be complete at the point of declaration of D::f or shall
be the class type D."
Note that it says: "at the point of the declaration
of D::f", which is not satisfied in your example.
(would the compiler be able to find out, or do we break any rule by
doing that?)
If I remove the keyword 'virtual' it will work because the compiler then
applies function overriding instead.
Am I correct about how the compiler works?
Not really ;-)
HTH & Greetings from Bremen,
Daniel Kr?gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]