#ifndef __SMART_POINTER__
#define __SMART_POINTER__
#pragma once


#include <map>
#include <iostream>
#include <windows.h>


// smartptr_base ======================================
class smartptr_base
{
public:
    typedef std::map<const void*,int> register_type;

    static register_type& reg()
    {
        static register_type reg;
        return reg;
    }

    static CRITICAL_SECTION *pcs()
    {
        static CRITICAL_SECTION *pcs = 0;
        if ( !pcs )
        {
            pcs = new CRITICAL_SECTION;
            ::InitializeCriticalSection(pcs);
        }
        return pcs;
    }

    static void lock()
    {
        ::EnterCriticalSection(pcs());
    }

    static void unlock()
    {
        ::LeaveCriticalSection(pcs());
    }

    static int increase_refcount(const void *pt)
    {
        lock();

        int refcnt = ++reg()[pt];

        unlock();
        return refcnt;
    }

    static int decrease_refcount(const void *pt)
    {
        lock();
        int refcnt = --reg()[pt];

        if ( !refcnt )
            reg().erase(pt);

        unlock();
        return refcnt;
    }
};

// smartptr =================================================
template<class T>
class smartptr : smartptr_base
{
public:
    typedef T element_type;

    /*explicit*/ smartptr(const T *pt = 0)
        : m_pt( 0 ) //init member to zero!
    {
        reset( pt );
    }

    template<class U>
    /*explicit*/ smartptr(const U *pu)
        : m_pt( 0 ) //init member to zero!
    {
        reset( dynamic_cast<const T*>(pu) );
    }

    smartptr(const smartptr& sp)
        : m_pt( 0 ) //init member to zero!
    {
        reset( sp.m_pt );
    }

    template<class U>
    smartptr(const smartptr<U>& sp)
        : m_pt( 0 ) //init member to zero!
    {
        reset( dynamic_cast<const T*>(sp.get()) );
    }

    ~smartptr()
    {
        reset();
    }

    smartptr& reset(const T *pt = 0)
    {
        if ( m_pt == pt )
            return *this;

        if ( m_pt && !decrease_refcount(dynamic_cast<const void*>(m_pt)) )
            delete m_pt;

        if ( pt )
            increase_refcount(dynamic_cast<const void*>(pt));

        m_pt = pt;
        return *this;
    }

    // standard operations ----------------------------------------------
          T *get               ()       { return const_cast<T*>(m_pt); }
    const T *get               () const { return m_pt; }
             operator       T* ()       { return  get(); }
             operator const T* () const { return  get(); }
          T& operator *        ()       { return *get(); }
    const T& operator *        () const { return *get(); }
          T *operator ->       ()       { return  get(); }
    const T *operator ->       () const { return  get(); }

             operator bool     () const { return m_pt ? true  : false; }
    bool     operator !        () const { return !(bool)(*this); }

    smartptr& operator = (const smartptr& sp)
    {
        return reset( sp.get() );
    }

    template<class U>
    smartptr& operator = (const smartptr<U>& sp)
    {
        return reset( dynamic_cast<const T*>(sp.get()) );
    }

private:
    const T *m_pt;
};

#endif//__SMART_POINTER__

// порочная идея - хранить счётчики в общей помойке.
// во-первых, каждая операция - O(logN)
// во-вторых, бутылочное горлышко (невозможность двум независимым потокам параллельно работать)
M>    static int increase_refcount(const void *pt)
M>    {
M>        lock();
M>        int refcnt = ++reg()[pt];
M>        unlock();
M>        return refcnt;
M>    }

// /*explicit*/ - можно случайно инициализировать указателем на объект, который нельзя удалять.
// огромная ошибкоопасность.
M>    /*explicit*/ smartptr(const T *pt = 0)
M>        : m_pt( 0 ) //init member to zero!
M>    {
M>        reset( pt );
M>    }

smartptr<X> ptr = SomeThing;

smartptr<X> ptr( SomeThing );

// dynamic_cast - невозможно работать с типами, не являющимися полиморфными классами.

// как насчёт множественного наследования?
M>        if ( m_pt == pt )
M>            return *this;
M>        if ( m_pt && !decrease_refcount(dynamic_cast<const void*>(m_pt)) )
M>            delete m_pt;
M>        if ( pt )
M>            increase_refcount(dynamic_cast<const void*>(pt));
M>        m_pt = pt;
M>        return *this;

static CRITICAL_SECTION *pcs()
{
  static CRITICAL_SECTION* volatile pcs = 0;
  if (pcs == 0)
  {
    CRITICAL_SECTION* tmp = new CRITICAL_SECTION;
    ::InitializeCriticalSection(tmp);
    if (_InterlockedCompareExchange((long*)&pcs, (long)tmp, 0))
    {
      DeleteCriticalSection(tmp);
      delete tmp;
    }
  }
  return pcs;
}

static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

static int increase_refcount(const void *pt)
{
  scoped_lock lock (pcs());
  return ++reg()[pt];
}

struct part_t
{
  mutex_t mtx;
  map<void*, unsigned> rc;
};

struct padded_part_t : part_t
{
  char pad [cache_line_size - sizeof(part_t)];
};

size_t const part_count = 1024;
padded_part_t g_parts [1024];

void increase_rc(void* obj)
{
  size_t part_idx = hash(obj) % part_count;
  part_t& part = g_parts[part_idx];
  scoped_lock_t lock (part.mtx);
  part.rc[obj] += 1;
}

M>// порочная идея - хранить счётчики в общей помойке.
M>// во-первых, каждая операция - O(logN)
M>// во-вторых, бутылочное горлышко (невозможность двум независимым потокам параллельно работать)
M>>    static int increase_refcount(const void *pt)
M>>    {
M>>        lock();
M>>        int refcnt = ++reg()[pt];
M>>        unlock();
M>>        return refcnt;
M>>    }
M>

M>// /*explicit*/ - можно случайно инициализировать указателем на объект, который нельзя удалять.
M>// огромная ошибкоопасность.
M>>    /*explicit*/ smartptr(const T *pt = 0)
M>>        : m_pt( 0 ) //init member to zero!
M>>    {
M>>        reset( pt );
M>>    }
M>

M>smartptr<X> ptr = SomeThing;
M>

M>smartptr<X> ptr( SomeThing );
M>

void foo(X& x, ...)
{
  ...
  bar(&x);
  ...
}

void foo(X* x, ...)
{
  ...
  bar(smart_ptr<X>(x));
  ...
}

M>// dynamic_cast - невозможно работать с типами, не являющимися полиморфными классами.
M>

M>// как насчёт множественного наследования?
M>>        if ( m_pt == pt )
M>>            return *this;
M>>        if ( m_pt && !decrease_refcount(dynamic_cast<const void*>(m_pt)) )
M>>            delete m_pt;
M>>        if ( pt )
M>>            increase_refcount(dynamic_cast<const void*>(pt));
M>>        m_pt = pt;
M>>        return *this;
M>

template<class T>
class smart_ptr
{
    T*   m_ptr;
    int* m_counter;
public:
    smart_ptr()
        : m_ptr(0)
        , m_counter(0)
        {}
    smart_ptr(T* p)
        : m_ptr(p),
        , m_counter(p ? take_the_counter(dynamic_cast<void*>(p)) : 0)) // регистрирует новый или получает старый счётчик
        {
            it(m_counter)
                atomic_inc(&m_counter);
        }
    smart_ptr(smart_ptr const& other)
        : m_ptr(other.m_ptr)
        , m_counter(other.m_counter)
        {
            if(m_counter)
                atomic_inc(&m_counter);
        }
    ~smart_ptr()
        {
            if(m_counter && atomic_dec(&m_counter)==0)
            {
                remove_the_counter(dynamic_cast<void*>(p), m_counter);
                delete m_ptr;
            }
        }
    .....
};

struct foo
{
    // просто некое определение приведения к указателю. без смысла.
    operator void const* () const { return this; }
};

int main()
{
    foo f;
    // по-всякому приводим объект к bool
    bool b1 = f;
    bool b2 = !f;
    bool b3 = f ? true : false;
    bool b4 = f && f;
}