covariant return type

[abir]

Hi,
is there any way forward declare a covariant return type (and is it
a language feature or extension only)?

I have class,
class CompModel;
class CompWorker{
public:
virtual CompModel& model(); /// forward declaration works as
usual.
};
#include "KeyModel.hpp" ///here i need to include it.
class KeyWorker : public CompWorker{
public:
virtual KeyModel& model();
}
where,
class KeyModel : public CompModel{
};
No way i can express a forward decl which inherit from another class.
I am not sure if really any include is needed apart from knowing
inheritance, as KeyModel memory model is not needef for KeyWorker.

Thanks
abir

[anon]

abir wrote:

Hi,
is there any way forward declare a covariant return type (and is it
a language feature or extension only)?

I have class,
class CompModel;
class CompWorker{
public:
virtual CompModel& model(); /// forward declaration works as
usual.
};
#include "KeyModel.hpp" ///here i need to include it.
class KeyWorker : public CompWorker{
public:
virtual KeyModel& model();
}
where,
class KeyModel : public CompModel{
};
No way i can express a forward decl which inherit from another class.
I am not sure if really any include is needed apart from knowing
inheritance, as KeyModel memory model is not needef for KeyWorker.

Looks like a bad design decision. Anyway, would something like this work
for you?

template < class T >
class CompWorker
{
public:
virtual T& model();
};

class KeyWorker : public CompWorker< KeyWorker >
{
};
Might need to add some things (like for example virtual destructor).

[abir]

On Jul 14, 2:38 pm, anon <[e-mail]:

abir wrote:

Hi,
is there any way forward declare a covariant return type (and is it
a language feature or extension only)?

I have class,
class CompModel;
class CompWorker{
public:
virtual CompModel& model(); /// forward declaration works as
usual.
};
#include "KeyModel.hpp" ///here i need to include it.
class KeyWorker : public CompWorker{
public:
virtual KeyModel& model();
}
where,
class KeyModel : public CompModel{
};
No way i can express a forward decl which inherit from another class.
I am not sure if really any include is needed apart from knowing
inheritance, as KeyModel memory model is not needef for KeyWorker.

Looks like a bad design decision. Anyway, would something like this work
for you?

Why bad design decision? This is a common design and covariant return
type is just for these kind of evolved objects.
consider GoF AbstructFactory, and if someone has
BombedWall* BombedMazeFactory::MakeWall () const;
BombedRoom* BombedMazeFactory::MakeRoom(int n) const;
instead of,
Wall* BombedMazeFactory::MakeWall () const
Room* BombedMazeFactory::MakeRoom(int n) const
I don't see anything bad in this, do you?
Forward declaration is a C++ related issue, which i was testing.
BTW, i don't have any cyclic dependency, so i can include it well, in
my case. But any change in KeyModel.hpp needs a recompilation of
KeyWorker,
which is not actually needed if i can express the relationship between
KeyModel & CompModel properly.

template < class T >
class CompWorker
{
public:
virtual T& model();

};

class KeyWorker : public CompWorker< KeyWorker >
{

};

Might need to add some things (like for example virtual destructor).

Yes, it works. but ... If i have a bunch of evolving objects ,
then i need to have a few template parameter for CompWorker.
and if there is N such cov return types, out of N^2 templates only N
are useful.
It's a solution, but intent is not a clear one.
Where if i can declare relation among the class as forward declaration
then it is clear.
like class CompWorker;
class KeyWorker : public CompWorker;

Thnaks
abir

[anon]

abir wrote:

On Jul 14, 2:38 pm, anon <[e-mail]:

>abir wrote:

>>Hi,
is there any way forward declare a covariant return type (and is it
a language feature or extension only)?
I have class,
class CompModel;
class CompWorker{
public:
virtual CompModel& model(); /// forward declaration works as
usual.
};
#include "KeyModel.hpp" ///here i need to include it.
class KeyWorker : public CompWorker{
public:
virtual KeyModel& model();
}
where,
class KeyModel : public CompModel{
};
No way i can express a forward decl which inherit from another class.
I am not sure if really any include is needed apart from knowing
inheritance, as KeyModel memory model is not needef for KeyWorker.

Looks like a bad design decision. Anyway, would something like this work
for you?

Why bad design decision? This is a common design and covariant return
type is just for these kind of evolved objects.
consider GoF AbstructFactory, and if someone has
BombedWall* BombedMazeFactory::MakeWall () const;
BombedRoom* BombedMazeFactory::MakeRoom(int n) const;
instead of,
Wall* BombedMazeFactory::MakeWall () const
Room* BombedMazeFactory::MakeRoom(int n) const
I don't see anything bad in this, do you?

IMO might be better if BomberWall and Wall inherit from WallBase, then
you could do:
WallBase* BombedMazeFactory::MakeWall () const

Forward declaration is a C++ related issue, which i was testing.
BTW, i don't have any cyclic dependency, so i can include it well, in
my case. But any change in KeyModel.hpp needs a recompilation of
KeyWorker,
which is not actually needed if i can express the relationship between
KeyModel & CompModel properly.

>template < class T >
class CompWorker
{
public:
virtual T& model();

};

class KeyWorker : public CompWorker< KeyWorker >
{

};

Might need to add some things (like for example virtual destructor).

Yes, it works. but ... If i have a bunch of evolving objects ,
then i need to have a few template parameter for CompWorker.
and if there is N such cov return types, out of N^2 templates only N
are useful.
It's a solution, but intent is not a clear one.
Where if i can declare relation among the class as forward declaration
then it is clear.
like class CompWorker;
class KeyWorker : public CompWorker;

Would it be possible to make a non-template base class for the template
class I suggested?
Maybe this would solve your doubts:
http://www.gamedev.net/community/for...opic_id=400392