templates and polymorphism

[mscava]

I've created CoutedPtr<Ttype to be able o track how many times
pointer is being reference( for garbage collecting ). The problem is
that the polymorphism doesn't work. e.g. CountedPtr<Bitm ap!=
CountedPtr<Reso urcealthough Bitmap IS Resource( I mean class
Bitmap : public Resource ). How can I go around this obstacle? If you
need more code just tell me...

[Ondra Holub]

[e-mail] m napsal:

I've created CoutedPtr<Ttype to be able o track how many times
pointer is being reference( for garbage collecting ). The problem is
that the polymorphism doesn't work. e.g. CountedPtr<Bitm ap!=
CountedPtr<Reso urcealthough Bitmap IS Resource( I mean class
Bitmap : public Resource ). How can I go around this obstacle? If you
need more code just tell me...

Typical aproach is to create CountedPtr<Base Type>. I suppose you have
to provide raw pointer to BaseTypeto constructor of
CountedPtr<Base Type>. So it is simple, just use pointer to derived
type:

class BaseType
{
// Some declarations
};

class DerivedType: public BaseType
{
// Some declarations
};

CountedPtr<Base Typep = new DerivedType;

And you have polymorphis.

[peter koch]

On Feb 19, 1:54 pm, [e-mail] m wrote:

I've created CoutedPtr<Ttype to be able o track how many times
pointer is being reference( for garbage collecting ). The problem is
that the polymorphism doesn't work. e.g. CountedPtr<Bitm ap!=
CountedPtr<Reso urcealthough Bitmap IS Resource( I mean class
Bitmap : public Resource ). How can I go around this obstacle? If you
need more code just tell me...

If every class gets counted properly, and Bitmap is a Resource, then
CountedPtr<BitM ap<= CountedPtr<Reso urce>, where the comparison will
be < unless Bitmap is the only Resource instantiated.
If that is not the case, I assume there is some problem with your
code. If you are using the curiously recurring template pattern your
"example" above misses something. It should be something like:
Bitmap : public Resource, public CountedPtr<BitM ap{...
(I assume that in other uses of CountedPtr<you meant e.g.
CountedPtr<BitM ap>::value)

/Peter

[mscava]

Typical aproach is to create CountedPtr<Base Type>. I suppose you have

to provide raw pointer to BaseTypeto constructor of
CountedPtr<Base Type>. So it is simple, just use pointer to derived
type:

class BaseType
{
// Some declarations

};

class DerivedType: public BaseType
{
// Some declarations

};

CountedPtr<Base Typep = new DerivedType;

And you have polymorphis.

Problem is that this way CountedPtr will loose it's meaning, when I
will be assigning raw pointer. The action I want to solve is
CountedPtr<Bitm ap= CountedPtr<Reso urce>. And this makes me think of
implementing somehow dynamic_cast...

[mscava]

If every class gets counted properly, and Bitmap is a Resource, then

CountedPtr<BitM ap<= CountedPtr<Reso urce>, where the comparison will
be < unless Bitmap is the only Resource instantiated.
If that is not the case, I assume there is some problem with your
code. If you are using the curiously recurring template pattern your
"example" above misses something. It should be something like:
Bitmap : public Resource, public CountedPtr<BitM ap{...
(I assume that in other uses of CountedPtr<you meant e.g.
CountedPtr<BitM ap>::value)

/Peter

Well here is more exact code:

vector< CountedPtr<Bitm ap vec;
// Function in my ResourceManager
CounterPtr<Reso urceGet( string& key )
// This is the line where compiler says it want to get Bitmap passed,
not Resource
vec.push_back( RCM::Get( myKey ) );

[mscava]

I feel like I should formulate it otherwise. Can I cast templates?

With normal pointers I would do:

Bitmap* b;
Resource* r = new Resource;
b = dynamic_cast<Bi tmapr;

But what if I want to do it with CountedPtr<T>?

CountedPtr<Bitm ap= CountedPtr<Reso urce>; is not valid...

Is there a way go around this?

[paul.joseph.davis]

On Feb 19, 6:54 am, [e-mail] m wrote:

I've created CoutedPtr<Ttype to be able o track how many times
pointer is being reference( for garbage collecting ). The problem is
that the polymorphism doesn't work. e.g. CountedPtr<Bitm ap!=
CountedPtr<Reso urcealthough Bitmap IS Resource( I mean class
Bitmap : public Resource ). How can I go around this obstacle? If you
need more code just tell me...

Check out boost's shared_ptr
http://www.boost.org/boost/shared_ptr.hpp

Specifically boost::dynamic_ pointer_cast

and

shared_ptr::ope rator=( const shared_ptr& rhs )

This is some pretty detail oriented stuff. I'd recommend using boost's
implementation of shared_ptr's to create garbage collection.

[mscava]

Ouw! Thanks Paul! Something I'm going to study. I'll try to implement
it by myself. Thanks again.

[Patrik Kahari]

With normal pointers I would do:

>
Bitmap* b;
Resource* r = new Resource;
b = dynamic_cast<Bi tmapr;

But what if I want to do it with CountedPtr<T>?

CountedPtr<Bitm ap= CountedPtr<Reso urce>; is not valid...

Is there a way go around this?

Hi.

If Resource is a base class of the derived class Bitmap then the above
example should always fail. (As in a resource is not a bitmap. A
bitmap is a resource. Maybe you meant to write 'Resource* r = new
Bitmap' on the second line, then the example would make sense.)

However if you wanted to allow assignemnt the other way, from wrapper
of derived pointer to wrapper of base pointer.. as in
CountedPtr<Reso urce*= CountedPtr<Bitm ap*>
just as there is an imlicit conversion from a naked derived pointer to
a base pointers. as in
Resource* = Bitmap*

Then you can overload the CountedPtr copy constructor to do just
that.

<CODE>

template <class T>
struct CountedPtr {

CountedPtr(T t):t_(t) {}

template <class T1>
CountedPtr(Coun tedPtr<T1&t1):t _(t1.t_) {} // copy constructor for
different template type. So CountedPtr<T1to CountedPtr<Twil l work
if there is a conversion from T1 to T

T t_;
};
struct Base{};
struct Derived: public Base {};

inline void Test() {
CountedPtr<Base *cb(0);
CountedPtr<Deri ved*cd(0);
cb = cd; // works
}

</CODE>

Regards Patrik