#include <iostream>
using namespace std;


template<class T>
class SmartPtr
{
public:
	SmartPtr(T* const p);
	SmartPtr(const SmartPtr<T>& orig);
	~SmartPtr();
	SmartPtr& operator=(const SmartPtr& ptr);
	T& operator*();
	T* getPointer();
	int getCount();



private:
	T* _ptr;
	int* _count;

};

template<class T>
SmartPtr<T>::SmartPtr(T* const p)
{
	_ptr = p;
	_count = new int(1);
}

template<class T>
SmartPtr<T>::SmartPtr(const SmartPtr<T>& orig)
{
	_ptr = orig._ptr;
	_count = orig._count;
	++(*_count);
}

template<class T>
SmartPtr<T>::~SmartPtr()
{
	if (--(*_count) == 0)
	{
		delete _ptr;
		delete _count;
		_ptr = nullptr;
		_count = nullptr;
		cout << "destructor!" << endl;
	}
}

template<class T>
SmartPtr<T>& SmartPtr<T>::operator=(const SmartPtr& ptr)
{
	_ptr = ptr._ptr;
	*_count = ptr._count;
}

template<class T>
T& SmartPtr<T>::operator*()
{
	return *(_ptr);
}

template<class T>
T* SmartPtr<T>::getPointer()
{
	return _ptr;
}

template<class T>
int SmartPtr<T>::getCount()
{
	return *_count;
}

int main()
{
	SmartPtr<int> sPtr(new int(10));
	cout << "Pointer address:" << sPtr.getPointer() << endl;
	cout << "value:\t\t" << *sPtr << endl;

	cout << endl;
	SmartPtr<int> sPtr1(sPtr);
	cout << "Pointer address:" << sPtr.getPointer() << endl;
	cout << "value:\t\t" << *sPtr << endl;

	cout << endl;
	++(*sPtr);
	cout << "value:\t\t" << *sPtr << endl;
	cout << "value:\t\t" << *sPtr << endl;
}