CareerCup

template<typename T> class SmartPointer {

public:
	SmartPointer(const SmartPointer& other){
		this->operator=(other);
	}

	SmartPointer(): ptr (0), refCount(new int(1)) {}

	explicit SmartPointer(T* newPtr): ptr (newPtr), refCount( new int(1) ) {}

	SmartPointer& operator=( const SmartPointer& smartPtr ){
		if( this != &smartPtr ){
			ptr = smartPtr.ptr;
			refCount = smartPtr.refCount;
			incRefCount();
		}
		return *this;
	}

	virtual ~SmartPointer(){
		decRefCount();

		if( ptr && ! *refCount ){
			delete ptr;
			delete refCount;
			cout << "ptr deleted"<< endl;
			ptr = 0;
		}
	}

	T* operator->() const {
		return ptr;
	}

	T& operator*(){
		return *ptr;
	}

	int getRefCount() const {
		return *refCount;
	}

private:
	T* ptr;
	int* refCount;


	void incRefCount(){
		++(*refCount);
	}

	void decRefCount(){
		--(*refCount);
	}
};

I have a question about this, which I've also noticed in other smart-pointer implementation examples.

I guess I don't understand the usage, because it seems this code, in the assignment operator implementation:

ptr = smartPtr.ptr;
			refCount = smartPtr.refCount;

inadvertently leak ptr and refCount in the lhs instance if it's already set up before the assignment?