template
<
    typename T,
    template <typename> class OwnershipPolicy = ref_counted,
    template <typename> class ConversionPolicy = disallow_conversion,
    template <typename> class CheckingPolicy = assert_check,
    template <typename> class StoragePolicy = scalar_storage
>
 class smart_ptr
    : public optimally_inherit<
        typename optimally_inherit<
            StoragePolicy<T>,
            OwnershipPolicy<T>
            >::type,
        typename optimally_inherit<
            CheckingPolicy<T>,
            ConversionPolicy<T>
            >::type
        >::type
    {
        ...
    };

#include <boost/signal.hpp>
#include <boost/bind.hpp>
#include <iostream>

using namespace boost;
using namespace std;

struct ClassA
{
    signal<void ()>    SigA;
    signal<void (int)> SigB;
};

struct ClassB
{
    void PrintFoo()      { cout << "Foo" << endl; }
    void PrintInt(int i) { cout << "Bar: " << i << endl; }
};

int main()
{
    ClassA a;
    ClassB b, b2;

    a.SigA.connect(bind(&ClassB::PrintFoo, &b));
    a.SigB.connect(bind(&ClassB::PrintInt, &b,  _1));
    a.SigB.connect(bind(&ClassB::PrintInt, &b2, _1));

    a.SigA();
    a.SigB(4);
}

ref_counted::ref_counted() {
pCount_ = static_cast<unsigned int*>(
SmallObject<>::operator new(sizeof(unsigned int)));
assert(pCount_);
*pCount_ = 1;
}
bool ref_counted::release(const P&) {
if (!--*pCount_) {
SmallObject<>::operator delete(pCount_, sizeof(unsigned int));
return true;
}
return false;
}
class smart_ptr
: public storage_policy<T>
, public ownership_policy<typename storage_policy<T>::PointerType>
, public checking_policy<typename storage_policy<T>::stored_type>
, public conversion_policy
{ ... };
smart_ptr::smart_ptr(const stored_type& p) : SP(p)
{ KP::OnInit(GetImpl(*this)); }
smart_ptr::~smart_ptr() {
if (OP::release(GetImpl(*static_cast<SP*>(this)))) {
SP::Destroy();
}
}