Reference Counters, Pointers, Abstract Classes, Memory Leaks

[Stoodent]

Hi.
The project I'm working at turned larger and larger and I fear I produce some memory leaks there. I read about auto_ptr, smart pointers, reference counting classes but I have some problems to implement it in my code.

I was happy to find a template class which is doing a reference counting for any object (of type given as template parameter).
I found this template class here:
http://ootips.org/yonat/4dev/counted_ptr.h

Now my problem:

#include "counted_ptr.h"

//------------------------------------------------------------------------------

class IAnything
{
public:
  virtual char GetAny()=0;
};

//------------------------------------------------------------------------------

class CAny1 : public IAnything
{
public:
  char m_anyMember;

  void AMethod(){
    m_anyMember='1';
  }

  virtual char GetAny(){
    AMethod();
    return m_anyMember;
  }
};

//------------------------------------------------------------------------------

class CAny2 : public IAnything
{
public:
  char m_anyMember;

  void AMethod(){
    m_anyMember='2';
  }

  virtual char GetAny(){
    AMethod();
    return m_anyMember;
  }
};

//------------------------------------------------------------------------------

void AcceptAnything(counted_ptr<IAnything> pAnything){
  if (pAnything.get())
    char test = pAnything->GetAny();
}

//------------------------------------------------------------------------------

int main(int argc, char* argv[])
{
  // simple demo
  {
    counted_ptr<int> pCounted1(new int);
    *pCounted1 = 0x12;
    counted_ptr<int> pCounted2(new int);
    *pCounted2 = 0x99;
    counted_ptr<int> pCounted3;
    pCounted3 = pCounted1;
    pCounted2 = pCounted3;
  }

  // demo with classes of interface derived class
  {
    counted_ptr<CAny1> pAnyPtr1(new CAny1);
    AcceptAnything((counted_ptr<class IAnything>)pAnyPtr1); // <--- WHAT TO DO HERE ???
    counted_ptr<CAny2> pAnyPtr2(new CAny2);
    AcceptAnything((counted_ptr<class IAnything>)pAnyPtr2); // <--- WHAT TO DO HERE ???
  }
  return 0;
}

The "simple demo" part compiles successful but not the other part.
In my project I have a lot of methods using Interface* as arguments.
I also store objects being derived from that interface into a generic list using CArray.

What can I do to replace the memory leak advantaging mechanism of using directly "new" and "delete" with a more secure mechanism but still being able to use a structure accepting interface* as arguments ?

[NMTop40]

class IAnything
{
public:
  virtual char GetAny()=0;
};

Before you will be able to use counted_ptrs on IAnything you will need to give that class a virtual destructor.

Correct to

class IAnything
{
public:
  virtual char GetAny()=0;
  virtual ~IAnything() {}
};

and your smart pointers should hopefully clean up properly.

[Stoodent]

thank you,
but it doesn't help the line

AcceptAnything((counted_ptr<class IAnything>)pAnyPtr1);

to compile.

The problem is that the method "AcceptAnything()" shall get any object of class being derived from the interface...

[NMTop40]

C-style casting like this:

counted_ptr<CAny1> pAnyPtr1(new CAny1);
    AcceptAnything((counted_ptr<class IAnything>)pAnyPtr1); // <--- WHAT TO DO HERE ???
    counted_ptr<CAny2> pAnyPtr2(new CAny2);
    AcceptAnything((counted_ptr<class IAnything>)pAnyPtr2); // <--- WHAT TO DO HERE ???

is bad. And is plain wrong too.

What compiler are you on? If VC6 there may be problems, but if you have a compiler that allows member templates then you should not have NO_MEMBER_TEMPLATES defined and then it will be able to construct a counted_ptr<IAnything> from a counted_ptr<CAny1> as CAny1 is derived from IAnything.

Otherwise declare your pointers like this:

counted_ptr< IAnything > pAnyPtr1( new CAny1  );
counted_ptr< IAnything > pAnyPtr2( new CAny2  );

[Stoodent]

Oh thank you...
Why didn't see it myself ?

Thank you for your help.