C++ Primer Plus（第6版）---编程作业完成（第十三章）

charpter13_homework.cpp

#include<iostream>
#include<string>
#include"classic.h"
#include"dma_3.h"
#include"port.h"

using namespace std;
void p13_1(void);
void p13_3(void);
void p13_4(void);

int main()
{
	//p13_1();
	//p13_3();
	p13_4();

	return 0;
}

//-----作业一/二----------
void Bravo(const Cd& disk)
{
	disk.Report();
}
void p13_1(void)
{
	Cd c1("AAA","BBB",14,13.5);
	Classic c2=Classic("CCC","DDD","EEE",2,57.17);
	Cd* pcd=&c1;
	c1.Report();
	c2.Report();
	cout<<endl;
	pcd->Report();
	pcd=&c2;
	pcd->Report();
	cout<<endl;
	Bravo(c1);
	Bravo(c2);
	cout<<endl;
	Classic copy;
	copy=c2;
	copy.Report();
}

//-----------作业三-----------
void p13_3(void)
{
	const int Max=3;
	dmaABC* p_dma[Max];

	string temp_label;
	int temp_rating;
	string temp_color;
	string temp_style;

	for(int i=0;i<Max;i++)
	{
		cout<<"Enter the label:";
		getline(cin,temp_label);//头文件为<string>
		cout<<"Enter the rating: ";
		cin>>temp_rating;
		cout<<"Enter the num(1,2,3): ";
		char temp;
		while(cin>>temp && (temp!='1'&& temp!='2' && temp!='3'))
			cout<<"Enter the num(1,2,3): ";
		while(cin.get()!='\n')
			continue;
		if(temp=='1')//string转为C字符串
			p_dma[i]=new baseDMA(temp_label.c_str(),temp_rating);
		else if(temp=='2')
		{
			cout<<"Enter the color: ";
			getline(cin,temp_color);
			p_dma[i]=new lacksDMA(temp_color.c_str(),temp_label.c_str(),temp_rating);
		}
		else
		{
			cout<<"Enter the style: ";
			getline(cin,temp_style);
			p_dma[i]=new hasDMA(temp_style.c_str(),temp_label.c_str(),temp_rating);
		}
		cout<<endl;
	}
	for(int i=0;i<Max;i++)
	{
		p_dma[i]->View();
		cout<<endl;
	}
	for(int i=0;i<Max;i++)
		delete [] p_dma[i];
	cout<<"Done!"<<endl;
	return;
}

//---------作业四-------------
void p13_4(void)
{
	Port p1("AAA","BBB",20);
	p1.Show();
	Port p2;
	p2=p1;
	cout<<p2<<endl;
	p2-=5;
	cout<<p2<<endl;
	VintagePort v1;
	v1.Show();
	v1+=20;
	cout<<v1<<endl;
	VintagePort v2(v1);
	v2.Show();
}

classic.h

//-----------作业一-------------------

//#ifndef CLASSIC_H_
//#define CLASSIC_H_
//
////基类
//class Cd
//{
//private:
//	char performers[50];
//	char laber[20];
//	int selections;
//	double playtime;
//public:
//	Cd(char* s1="None",char* s2="Nul",int n=0,double x=0.0);
//	virtual void Report()const;
//};
//
////派生类
//class Classic:public Cd
//{
//private:
//	char importance[50];
//public:
//	Classic(char* s="No",char* s1="None",char* s2="Nul",int n=0,double x=0.0);
//	Classic(char* s,const Cd& d);
//	virtual void Report()const;
//};
//
//#endif


//-------------作业二------------------------

#ifndef CLASSIC_H_
#define CLASSIC_H_

//基类
class Cd
{
private:
	char* performers;//复制构造，析构，重载赋值
	char* laber;
	int selections;
	double playtime;
public:
	Cd(char* s1="None",char* s2="Nul",int n=0,double x=0.0);
	Cd(const Cd & c);//复制构造
	Cd& operator=(const Cd & c);
	virtual void Report()const;
	virtual ~Cd();//析构
};

//派生类
class Classic:public Cd
{
private:
	char* importance;
public:
	Classic(char* s="No",char* s1="None",char* s2="Nul",int n=0,double x=0.0);
	Classic(char* s,const Cd& d);
	Classic(const Classic & c);
	Classic& operator=(const Classic& c);
	virtual void Report()const;
	~Classic();
};

#endif

classic.cpp

#include<iostream>
#include<cstring>
#include"classic.h"
using std::cout;
using std::endl;
using std::strcpy;
using std::strlen;

//--------------作业一-----------------
//
////基类
//Cd::Cd(char* s1,char* s2,int n,double x)
//{
//	strcpy(performers,s1);
//	strcpy(laber,s2);
//	selections=n;
//	playtime=x;
//}
//void Cd::Report()const
//{
//	cout<<"performers: "<<performers<<endl;
//	cout<<"laber: "<<laber<<endl;
//	cout<<"selections: "<<selections<<endl;
//	cout<<"playtime: "<<playtime<<endl;
//}
//
////派生类
//Classic::Classic(char* s,char* s1,char* s2,int n,double x):Cd(s1,s2,n,x)
//{
//	strcpy(importance,s);
//}
//Classic::Classic(char* s,const Cd& d):Cd(d)
//{
//	strcpy(importance,s);
//}
//void Classic::Report()const
//{
//	Cd::Report();
//	cout<<"importance: "<<importance<<endl;
//}



//-----------作业二--------------
//基类
Cd::Cd(char* s1,char* s2,int n,double x)
{
	performers=new char[strlen(s1)+1];
	strcpy(performers,s1);
	laber=new char[strlen(s2)+1];
	strcpy(laber,s2);
	selections=n;
	playtime=x;
}
Cd::Cd(const Cd & c)//复制构造
{
	performers=new char[strlen(c.performers)+1];
	strcpy(performers,c.performers);
	laber=new char[strlen(c.laber)+1];
	strcpy(laber,c.laber);
	selections=c.selections;
	playtime=c.playtime;
}
Cd& Cd::operator=(const Cd & c)
{
	performers=new char[strlen(c.performers)+1];
	strcpy(performers,c.performers);
	laber=new char[strlen(c.laber)+1];
	strcpy(laber,c.laber);
	selections=c.selections;
	playtime=c.playtime;
	return *this;
}
void Cd::Report()const
{
	cout<<"performers: "<<performers<<endl;
	cout<<"laber: "<<laber<<endl;
	cout<<"selections: "<<selections<<endl;
	cout<<"playtime: "<<playtime<<endl;
}
Cd::~Cd()//析构
{
	delete [] performers;
	delete [] laber;
}
//派生类
Classic::Classic(char* s,char* s1,char* s2,int n,double x):Cd(s1,s2,n,x)
{
	importance=new char[strlen(s)+1];
	strcpy(importance,s);
}
Classic::Classic(char* s,const Cd& d):Cd(d)
{
	importance=new char[strlen(s)+1];
	strcpy(importance,s);
}
Classic::Classic(const Classic & c):Cd(c)
{
	importance=new char[strlen(c.importance)+1];
	strcpy(importance,c.importance);
}
Classic& Classic::operator=(const Classic& c)
{
	//成员函数，使用作用域运算符来调用
	Cd::operator=(c);
	importance=new char[strlen(c.importance)+1];
	strcpy(importance,c.importance);
	return *this;
}
void Classic::Report()const
{
	Cd::Report();
	cout<<"importance: "<<importance<<endl;
}
Classic::~Classic()
{
	delete [] importance;
}

dma_3.h

#ifndef DMA_3_H_
#define DMA_3_H_
#include<iostream>
using std::ostream;

//抽象基类
class dmaABC
{
private:
	char* label;
	int rating;
protected:
	char* Label(){return label;};
	int Rating(){return rating;};
public:
	dmaABC(const char* lab="null",int rat=0);
	dmaABC(const dmaABC & d);//复制构造
	dmaABC& operator=(const dmaABC& d);//重载赋值
	virtual void View()const=0;//至少有一个纯虚函数
	virtual ~dmaABC();//虚析构函数
};


//派生类baseDMA
class baseDMA:public dmaABC
{
public:
	baseDMA(const char* lab="null",int rat=0);
	void View()const;
};

//派生类lacksDMA,没有new操作
class lacksDMA:public dmaABC
{
private:
	enum{COL_LEN=40};
	char color[COL_LEN];
public:
	lacksDMA(const char* c="blank",const char* lab="null",int rat=0);
	lacksDMA(const char* c,const dmaABC& d);
	void View()const;
};

//派生类hasDMA，有new操作
class hasDMA:public dmaABC
{
private:
	char* style;
public:
	hasDMA(const char* s="None",const char* lab="null",int rat=0);
	hasDMA(const char*s,const dmaABC& d);
	hasDMA(const hasDMA& hasD);//复制构造
	hasDMA& operator=(const hasDMA& hasD);//重载赋值
	void View()const;
	~hasDMA();//析构
};

#endif

dma_3.cpp

#include<iostream>
#include<cstring>
#include "dma_3.h"
using std::cout;
using std::endl;
using std::strcpy;
using std::strlen;

//抽象基类dmaABC
dmaABC::dmaABC(const char* lab,int rat)
{
	label=new char[strlen(lab)+1];
	strcpy(label,lab);
	rating=rat;
}
dmaABC::dmaABC(const dmaABC & d)//复制构造
{
	label=new char[strlen(d.label)+1];
	strcpy(label,d.label);
	rating=d.rating;
}
dmaABC& dmaABC::operator=(const dmaABC& d)//重载赋值
{
	//检查自己
	if(this==&d)
		return *this;
	//删除自己
	delete [] label;
	//开始复制
	label=new char[strlen(d.label)+1];
	strcpy(label,d.label);
	rating=d.rating;
	return *this;
}
void dmaABC::View()const//至少有一个纯虚函数
{
	cout<<"label: "<<label<<endl;
	cout<<"rating: "<<rating<<endl;
}
dmaABC::~dmaABC()//虚析构函数
{
	delete [] label;
}

//派生类 baseDMA
baseDMA::baseDMA(const char* lab,int rat):dmaABC(lab,rat)
{
}
void baseDMA::View()const
{
	dmaABC::View();
}

//派生类 lacksDMA
lacksDMA::lacksDMA(const char* c,const char* lab,int rat):dmaABC(lab,rat)
{
	strcpy(color,c);
}
lacksDMA::lacksDMA(const char* c,const dmaABC& d):dmaABC(d)
{
	strcpy(color,c);
}
void lacksDMA::View()const
{
	dmaABC::View();
	cout<<"color: "<<color<<endl;
}

//派生类 hasDMA
hasDMA::hasDMA(const char* s,const char* lab,int rat):dmaABC(lab,rat)
{
	style=new char[strlen(s)+1];
	strcpy(style,s);
}
hasDMA::hasDMA(const char*s,const dmaABC& d):dmaABC(d)
{
	style=new char[strlen(s)+1];
	strcpy(style,s);
}
hasDMA::hasDMA(const hasDMA& hasD):dmaABC(hasD)//复制构造
{
	style=new char[strlen(hasD.style)+1];
	strcpy(style,hasD.style);
}
hasDMA& hasDMA::operator=(const hasDMA& hasD)//重载赋值
{
	//检查自己
	if(this==&hasD)
		return *this;
	//调用基类重载赋值
	dmaABC::operator=(hasD);
	//删除自己
	delete [] style;
	style=new char[strlen(hasD.style)+1];
	strcpy(style,hasD.style);
	return *this;
}
void hasDMA::View()const
{
	dmaABC::View();
	cout<<"style: "<<style<<endl;
}
hasDMA::~hasDMA()//析构
{
	delete [] style;
}

port.h

#ifndef PORT_H_
#define PORT_H_
#include<iostream>
using std::ostream;
//基类 Port
class Port
{
private:
	char* brand;
	char style[20];
	int bottles;
public:
	Port(const char* br="none",const char* st="none",int b=0);
	Port(const Port& p);//复制构造
	virtual ~Port(){delete [] brand;};//析构
	Port& operator=(const Port& p);//重载赋值
	Port& operator+=(int b);
	Port& operator-=(int b);
	int BottleCount()const{return bottles;};
	virtual void Show()const;
	friend ostream& operator<<(ostream& os,const Port& p);
};

//派生类 VintagePort
class VintagePort:public Port
{
private:
	char* nickname;
	int year;
public:
	VintagePort();
	VintagePort(const char* br,int b,const char* nn,int y);
	VintagePort(const VintagePort& vp);
	~VintagePort(){delete [] nickname;};
	VintagePort& operator=(const VintagePort& vp);
	void Show()const;
	friend ostream& operator<<(ostream & os,const VintagePort& vp); 
};

#endif

port.cpp

#include<iostream>
#include"port.h"
using std::cout;
using std::endl;
using std::ostream;
using std::strlen;
using std::strcpy;

//基类 Port
Port::Port(const char* br,const char* st,int b)
{
	brand=new char[strlen(br)+1];
	strcpy(brand,br);
	strncpy(style,st,19);
	style[19]='\0';
	bottles=b;
}
Port::Port(const Port& p)//复制构造
{
	brand=new char[strlen(p.brand)+1];
	strcpy(brand,p.brand);
	strncpy(style,p.style,19);
	style[19]='\0';
	bottles=p.bottles;
}
	
Port& Port::operator=(const Port& p)//重载赋值
{
	//检查自己
	if(this==&p)
		return *this;
	//删除自己
	delete [] brand;
	//复制
	brand=new char[strlen(p.brand)+1];
	strcpy(brand,p.brand);
	strncpy(style,p.style,19);
	style[19]='\0';
	bottles=p.bottles;
	return *this;
}
Port& Port::operator+=(int b)
{
	if(b>0)
		bottles+=b;
	else
		cout<<"Error!\n";
	return *this;
}
Port& Port::operator-=(int b)
{
	if(bottles>b && b>0)
		bottles-=b;
	else
		cout<<"Error!\n";
	return *this;
}
	
void Port::Show()const
{
	cout<<"Brand: "<<brand<<endl;
	cout<<"Kind: "<<style<<endl;
	cout<<"Bottles: "<<bottles<<endl;
}
ostream& operator<<(ostream& os,const Port& p)
{
	os<<p.brand<<", "<<p.style<<", "<<p.bottles;
	return os;
}

//派生类 VintagePort
VintagePort::VintagePort():Port()
{
	nickname=new char[2];
	strcpy(nickname,"n");
	year=0;
}
VintagePort::VintagePort(const char* br,int b,const char* nn,int y):Port(br,"None",b)
{
	nickname=new char[strlen(nn)+1];
	strcpy(nickname,nn);
	year=y;
}
VintagePort::VintagePort(const VintagePort& vp):Port(vp)
{
	nickname=new char[strlen(vp.nickname)+1];
	strcpy(nickname,vp.nickname);
	year=vp.year;
}
	
VintagePort& VintagePort::operator=(const VintagePort& vp)
{
	//检查自己
	if(this==&vp)
		return *this;
	//调用基类重载赋值’
	Port::operator=(vp);
	//删除自己
	delete [] nickname;
	//复制
	nickname=new char[strlen(vp.nickname)+1];
	strcpy(nickname,vp.nickname);
	year=vp.year;
	return *this;
}
void VintagePort::Show()const
{
	Port::Show();
	cout<<"nickname: "<<nickname<<endl;
	cout<<"year: "<<year<<endl;
}
ostream& operator<<(ostream & os,const VintagePort& vp)
{
	os<<(const Port& )vp;
	os<<", "<<vp.nickname<<", "<<vp.year;
	return os;
}

如有错误，欢迎指正！