frame_step08.txt

用什么语言能编制出好的程序

//*****************************************************
//		Step 8   
//		
//  Desc: 1) 添加Frame,HCat,VCat等静态函数或全局函数。
//        2) 为将Node* 自动转换成Picture对象，添加Picture的私有构造函数
//		Picture(Node *p):pt(p) {}
//	  3) 添加main函数 
//*****************************************************

/----------------------- ProgramMain---------------------------
#include "Pictures.h"

char * array[]={"123","456","789"};

int main()
{
	Picture a(array,3,3);
	cout<<"a="<<endl;
	a.Display();

	Picture b=Picture::Frame(a);
	cout<<"b="<<endl;
	b.Display();

	Picture c=Picture::HCat(b,a);
	cout<<"c="<<endl;
	c.Display();

	Picture d=Picture::Frame(Picture::VCat(c,b));
	cout<<"d="<<endl;
	d.Display();
	return 0;
}

//------------------  Pictures.cpp  ---------------------
#include "Pictures.h"

Picture Picture::Frame(const Picture& org)
{
	return Picture(new FramePic(org));
}
Picture Picture::HCat(const Picture& one,const Picture& two)
{
	return Picture(new HCatPic(one,two));
}
Picture Picture::VCat(const Picture& one,const Picture& two)
{
	return Picture(new VCatPic(one,two));
}


Picture::Picture(char ** array,int wd, int ht)
:pt(new DataPic(array,wd,ht)) 
{
}

Picture::~Picture()		
{
	ReleaseRef();
}
Picture::Picture(const Picture& rhs)
{
	pt=rhs.pt;
	AddRef();
}
Picture& Picture::operator=(const Picture& rhs)
{
	if (this==&rhs) return (*this);
	ReleaseRef();
	pt=rhs.pt;
	AddRef();
	return (*this);
}

int	 Picture::Width() const
{ 
	return pt->Width(); 
} 
int  Picture::Height() const
{
	return pt->Height();
}

void Picture::AddRef()
{
	++pt->use;
}
void Picture::ReleaseRef()
{
	if (--pt->use==0)
		delete pt;
}

// new added
//-------------------------------------------------------
void Picture::Display() const
{
	int ht=Height();
	int wd=Width();
	for (int row=0;row<ht;row++) 
	{
		DisplayLine(row,wd);
		cout<<endl;
	}
}
void Picture::DisplayLine(int lineno,int wd) const
{
	pt->DisplayLine(lineno,wd); 
}

void Node::Pad(int from,int to)
{
	for (int i=from;i<to;i++)
		cout<<" ";
}

void DataPic::DisplayLine(int lineno,int wd) const
{
	if(lineno>=0 && lineno<Height()) {
		int len=Width();
		for(int i=0;i<len;i++)
			cout<<data[lineno*len+i];
		Pad(len,wd);
	}else {
		Pad(0,wd);
	}
	
}
void FramePic::DisplayLine(int lineno,int wd) const
{
	if (lineno>=0 && lineno<Height()) {
		if ((lineno==0) ||(lineno==Height()-1)) { //顶或底
			cout<<"+";
			int len=kernel.Width();
			for (int i=0;i<len;i++) cout<<"-";
			cout<<"+";
		}else { //内部
			cout<<"|";
			int len=kernel.Width();
			kernel.DisplayLine(lineno-1,len);
			cout<<"|";
		}
		Pad(Width(),wd);
	}else { //越界
		Pad(0,wd);
	}
}
void HCatPic::DisplayLine(int lineno,int wd) const
{
	left.DisplayLine(lineno,left.Width());
	right.DisplayLine(lineno,right.Width());
	Pad(Width(),wd);
}
void VCatPic::DisplayLine(int lineno,int wd) const
{
	if ((lineno>=0) && (lineno<top.Height()))
		top.DisplayLine(lineno,wd);
	else if (lineno<top.Height()+bottom.Height())
		bottom.DisplayLine(lineno-top.Height(),wd);
	else
		Pad(0,wd);
}





//------------------  Pictures.h  ---------------------
#ifndef PICTURESH
#define PICTURESH

#include <iostream.h>
class Node;

class Picture
{
public:
	static Picture Frame(const Picture& org);
	static Picture HCat(const Picture& one,const Picture& two);
	static Picture VCat(const Picture& one,const Picture& two);
public:
	Picture(char ** array,int wd, int ht);
	~Picture();
	Picture(const Picture& rhs);
	Picture& operator=(const Picture& rhs);	
public:
	void Display() const;
	void DisplayLine(int row,int wd) const;
	int  Width() const;
	int  Height() const;
private:
	Picture(Node * p):pt(p) {}
	void AddRef();
	void ReleaseRef();	
private:
	Node *  pt;
};
//-------------------------------------------------------
class Node
{
	friend class Picture;
public:
	Node():use(1)   {}		
	virtual ~Node()	{}
	virtual void DisplayLine(int row,int wd) const=0;
	virtual  int  Width()  const=0;
	virtual  int  Height() const=0;
protected:	
	static int max(int a,int b) {return a>b?a:b;}
	static void Pad(int from,int to);
private:
	int  use;
};
//------------------------------------------------------
class DataPic:public Node
{
public:
	DataPic(char ** array,int wd, int ht):w(wd),h(ht)
	{	
		data=new char[w*h];
		for (int i=0;i<h;i++)
			for (int j=0;j<w;j++)
				data[i*w+j]=array[i][j];

	}
	~DataPic()	{delete[] data;}
protected:
	void 		DisplayLine(int row,int wd) const;
	int		Width() const	{return w;}
	int		Height() const	{return h;}
private:
	DataPic(const DataPic& rhs);		//no define
	DataPic& operator=(const DataPic& rhs);	//no define
private:
	int		w;
	int		h;
	char *	data;
};
//------------------------------------------------------
class FramePic:public Node
{
public:
	FramePic(const Picture& rhs):kernel(rhs) {}  
	~FramePic() {}
protected:
	void DisplayLine(int row,int wd) const;
	int Width() const	{return kernel.Width()+2;}
	int Height() const	{return kernel.Height()+2;}
private:
	Picture	kernel;
};
//------------------------------------------------------
class HCatPic:public Node
{
public:
	HCatPic(const Picture& lpic,const Picture& rpic)
		:left(lpic),right(rpic) {}	
	~HCatPic() {}
protected:
	void DisplayLine(int row,int wd) const;
	int Width() const    {return left.Width()+right.Width();}
	int Height() const   {return max(left.Height(),right.Height());}
private:
	Picture		left;
	Picture		right;
};
//------------------------------------------------------
class VCatPic:public Node
{
public:
	VCatPic(const Picture& tpic,const Picture& bpic)
		:top(tpic),bottom(bpic) {}	
	~VCatPic() {}
protected:
	void DisplayLine(int row,int wd) const;
	int Width() const  {return max(top.Width(),bottom.Width());}
	int Height() const {return top.Height()+bottom.Height();}
private:
	Picture		top;
	Picture		bottom;
};
#endif