Question

I have a class with function called void deallocatorFunc(ClassA *p) I want using templates make it possible to write boost::shared_ptr< ClassA > ptr(new ClassA()); instead of boost::shared_ptr< ClassA > ptr(new ClassA(), deallocatorFunc);. I want it to spread on to my class and its inheritors. How to do such thing in C++? (I really need my peculiar destructor for that special class, while I want to keep super simple API).

Answer 1

You can use specialization for your class and wrap the standard implementation. Here’s a self-contained compilable example.

#include <iostream>
#include <boost/shared_ptr.hpp>

using namespace std;

class A
{
   public:
   A() {
      cout << "Constructing A." << endl;
   };
   virtual ~A() {
      cout << "Destructing A." << endl;
   }
};

class B : public A
{
   public:
   B() {
      cout << "Constructing B." << endl;
   };
   virtual ~B() {
      cout << "Destructing B." << endl;
   }
};
class C
{
   public:
   C() {
      cout << "Constructing C." << endl;
   };
   virtual ~C() {
      cout << "Destructing C." << endl;
   }
};

void deallocatorFunc(A *p)
{
   cout << "Deallocator function." << endl;
   delete p;
};

namespace boost {
    template<> class shared_ptr<A> {
       private:
       shared_ptr<void> _ptr;
       public:
       shared_ptr(A* p) : _ptr(p, deallocatorFunc)
       {
       }
    };
}
int main( int argc, const char* argv[] )
{
   boost::shared_ptr<A> ptrA(new A());
   boost::shared_ptr<B> ptrB(new B());
   boost::shared_ptr<C> ptrC(new C());
}

Output:

Constructing A. Constructing A. Constructing B. Constructing C.
Destructing C. Destructing B. Destructing A. Deallocator function.
Destructing A.

Note

As given, the specialization doesn’t work for derived classes of A!

For that to work, you need more trickery:

Template specialization based on inherit class