智能指针

#include <iostream>
#include <string>
using namespace std;

class Screen;
class ScreenPtr;

class Screen
{
public:
	typedef string::size_type index;
	Screen(int r = 4, int c = 3)
	{
		contents.resize(r * c, '#');
		height = r;
		width = c;
		access_ctr = 0;
	}
	char get() const
	{
		return contents[cursor];
	}

	inline char get(index ht, index wd) const;
	index get_cursor() const;
	Screen& move(index r, index c);
	Screen& set(char);
	Screen& set(index, index, char);
	Screen& display(ostream& os)
	{
		do_display(os);
		return *this;
	}
	const Screen& display(ostream& os) const
	{
		do_display(os);
		return *this;
	}
private:
	void do_display(ostream& os) const;
	string contents;
	index cursor;
	index height, width;
	mutable size_t access_ctr;
};

Screen& Screen::set(char c)
{
	contents[cursor] = c;
	return *this;
}

Screen& Screen::move(index r, index c)
{
	index row = r * width;
	cursor = row + c;
	return *this;
}

Screen& Screen::set(index r, index c, char x)
{
	index row = r * width;
	row += c;
	contents[row] = x;
	return *this;
}

void Screen::do_display(ostream &os) const
{
	++access_ctr;
	os<<contents<<"\t"<<access_ctr<<endl;
}

char Screen::get(index r, index c) const
{
	index row = r * width;
	return contents[row + c];
}

Screen::index Screen::get_cursor() const
{
	return cursor;
}



class ScrPtr
{
	friend class ScreenPtr;
	Screen *sp;
	size_t use;
	ScrPtr(Screen *p) : sp(p), use(1){}
	~ScrPtr()
	{
		delete sp;
	}
};

class ScreenPtr
{
public:
	ScreenPtr(Screen *p) : ptr(new ScrPtr(p)){}

	ScreenPtr(const ScreenPtr &orig) : ptr(orig.ptr)
	{
		++ptr->use;
	}

	ScreenPtr& operator=(const ScreenPtr&);
	~ScreenPtr()
	{
		if(--ptr->use == 0)
			delete ptr;
	}
	Screen& operator*()
	{
		return *ptr->sp;
	}
	Screen* operator->()
	{
		return ptr->sp;
	}
	const Screen& operator*() const
	{
		return *ptr->sp;
	}
	const Screen* operator->() const
	{
		return ptr->sp;
	}

private:
	ScrPtr *ptr;
};

ScreenPtr& ScreenPtr::operator =(const ScreenPtr &rhs)
{
	++rhs.ptr->use;
	if(--ptr->use == 0)
		delete ptr;
	ptr = rhs.ptr;
	return *this;
}

int main()
{
	Screen myScreen(2,2);
	const Screen blank(5,3);
	myScreen.set(0,0,'X').display(cout);
	blank.display(cout);

	//无法区分指针式堆中的还是栈中的.所以不能引用上面的例子	
	ScreenPtr sp(new Screen());
	ScreenPtr sp2(sp);
	sp->set(1, 0, 'd').display(cout);
	sp->display(cout);
	cout<<sp->get(1,0)<<endl;
	(*sp).display(cout);
	ScreenPtr sp3 = sp2;
	sp3->display(cout);


	return 0;
}