Thread: Forward declaration of classes

I have two classes: we'll call them A and B for the sake of discussion.

B is publicly derived from A.
a member function in A returns an instance of B.

I can't get it to compile, even with forward declarations of these classes.

is this even possible? I'm having a lot of trouble wrapping my head around this, and could use some help.

On the other hand, if As really should create Bs, then you are looking for a factory pattern, where unrelated object A has a method that makes Bs.

There are times when the base class knows about the derived class (some forms of multiple dispatch require this). You'd want to take an output parameter by reference or return a pointer. Then you can use the forward declaration.

Is that function in A virtual and overridden in B?
Does it return an object, a reference or a pointer?

Could you do this instead?

Code:

class A
{
public:
   virtual A*  GetDerivedClass() { return new A; }
};

class B : public A
{
public:
   virtual A*  GetDerivedClass() { return new B; }
};

Originally Posted by laserlight

It would probably be better to return a B* in B's override of GetDerivedClass(), but then I think we need a reply from Elkvis before we can begin giving more specific suggestions.

Then it wouldn't be an override (or at least not a good one), since you're changing the return type between the A & B version.
If they need to call functions that are only in B and not in A, they could always do a:

Code:

B* pB = dynamic_cast<B*>( pA );

>> If they need to call functions that are only in B and not in A, they could always do a:
VC++ 6.0 didn't handle covariant return types well, so you ended up being forced to use workarounds like that. It shouldn't be a problem any more.

Originally Posted by laserlight

No, it would be a correct override, since B is-a A. This is just covariant return types at work.

But then it would only return a B* if you're calling the function from a B class right? i.e. this wouldn't work:

Code:

A a;
B* pB = a.GetDerivedClass();

Originally Posted by laserlight

Of course, but why should it work? Even if B's GetDerivedClass() returned an A*, your example still would not work, since A's GetDerivedClass() is called.

I'm not saying it should work with my way either, I'm just clearifying the implications for some less-experienced people that might be reading this.
I guess (depending on how you plan to use these classes) it would be useful to have the B version return a B*.

Basically, if you're calling from an A pointer, you usually expect an A* to be returned (since you're working generically anyway and probably don't know what a B is anyway).

If you're calling from a B object or pointer, then you want a B* returned because that's what you're working with and you can always use it as an A if you really wanted to.

if you're calling B::getDerived directly from a B then you wouldn't need the function anyway, would you?

if you're calling B::getDerived from an A, the return type will always be an A and need to be cast to B anyway.


i don't see how it could possibly matter?

That example is too simple for it to matter, but factory and clone methods do basically the same thing and they do matter (you do sometimes need to call the method even if you already have a B).