C++ Primer Plus第十三章编程练习答案

1，以下面的类声明为基础:

// base class
class Cd{ // represents a CD disk

private:
char performers[50] ;
char label[20];
int selections;// number of selections

double playtime; // playing time in minutes

public:
Cd(char * sl,char * s2,int n,double x!;Cd(const cd & d!;
Cd{};
-Cd(};
void Report() const; // reports all CD data

Cd & operator=(const cd & d);

派生出一个Classic 类，并添加一组 har 成员，用于存储指出CD 中主要作品的字符串。修改上述声明，使基类的所有函数都是虚的。如果上述定义声明的某个方法并不需要，则请删除它。使用下面的程序测试您的产品:

#include <iostream>
using namespace std;
#include "classic.h"// which will contain #include cd.hvoid Bravo(const Cd & disk);int main()
Cd cl("Beatles"，"Capitol"，14，35,5);Classic c2 = Classic("piano Sonata in B flat，Fantasia in C""Alfred Brendel"，"Philips"，2，57.17);
Cd *pcd = &cl;
cout <s "Using object directly:\n";cl.Report();
// use Cd method
c2.Report();
//use Classic method
cout << "Using type cd * pointer to objects:\n";pcd->Report();// use cd method for cd objectpcd = &c2;
pcd->Report(); // use Classic method for classic object
cout << "Calling a function with a Cd reference argument:\n";Bravo(c1);Bravo(c2];
cout cc "Testing assignment: ";Classic copyi
copy= c2;
copy.Report()
return 0;
void Bravo(const Cd & disk)
disk.Report();

#include <iostream>
using namespace std;
#include "classic.h"void Bravo(const Cd &disk);int main()
{Cd c1("Beatles", "Capitol", 14, 35.5);Classic c2 = Classic("Piano Sonata in B flat, Fantasia in C","Alfred Brendel", "Philips", 2, 57.17);Cd *pcd = &c1;cout << "Using object directly:\n";c1.Report();c2.Report();cout << "Using type cd * pointer to objects:\n";pcd->Report();pcd = &c2;pcd->Report();cout << "Calling a function with a Cd reference argument:\n";Bravo(c1);Bravo(c2);cout << "Testing assignment:\n";Classic copy;copy = c2;copy.Report();return 0;
}void Bravo(const Cd &disk)
{disk.Report();
}

#ifndef CD_H_
#define CD_H_class Cd
{
private:char performers[50];char labels[20];int selections;double playtime;public:Cd(const char *s1, const char *s2, int n, double x);Cd(const Cd &d);Cd();virtual ~Cd();virtual void Report() const;Cd &operator=(const Cd &d);
};#endif

#include <iostream>
#include "cd.h"
#include <cstring>Cd::Cd(const char *s1, const char *s2, int n, double x) //用户定义构造函数;
{std::strncpy(performers, s1, 50);performers[49] = '\0';std::strncpy(labels, s2, 20);labels[19] = '\0';selections = n;playtime = x;
}Cd::Cd(const Cd &d) //用户定义构造函数;
{std::strncpy(performers, d.performers, 50);performers[49] = '\0';std::strncpy(labels, d.labels, 50);labels[49] = '\0';selections = d.selections;playtime = d.playtime;
}Cd::Cd() //用户定义默认构造函数;
{performers[0] = '\0';labels[0] = '\0';selections = 0;playtime = 0.0;
}Cd::~Cd()
{
}void Cd::Report() const
{std::cout << "Performers: " << performers << std::endl;std::cout << "Label: " << labels << std::endl;std::cout << "Selections: " << selections << std::endl;std::cout << "Playtime: " << playtime << std::endl;
}Cd &Cd::operator=(const Cd &d)
{if (this == &d){return *this;}std::strncpy(performers, d.performers, 50);performers[49] = '\0';std::strncpy(labels, d.labels, 20);labels[19] = '\0';selections = d.selections;playtime = d.playtime;return *this;
}

#ifndef CLASSIC_H_
#define CLASSIC_H_
#include "cd.h"class Classic : public Cd
{
private:char cdstr[50];public:Classic() : Cd() { cdstr[0] = '\0'; }Classic(const char *s, const char *s1, const char *s2, int n, double x);Classic(const char *s, const Cd &d);~Classic();virtual void Report() const;Classic &operator=(const Classic &cs);
};#endif

#include <iostream>
#include <cstring>
#include "classic.h"Classic::Classic(const char *s, const char *s1, const char *s2, int n, double x) : Cd(s1, s2, n, x)
{std::strncpy(cdstr, s, 50);cdstr[49] = '\0';
}Classic::Classic(const char *s, const Cd &d) : Cd(d)
{std::strncpy(cdstr, s, 50);cdstr[49] = '\0';
}Classic::~Classic()
{
}void Classic::Report() const
{Cd::Report();std::cout << "Major article in the CD is: " << cdstr << std::endl;std::cout.put('\n');
}Classic &Classic::operator=(const Classic &cs)
{if (this == &cs){return *this;}Cd::operator=(cs);std::strncpy(cdstr, cs.cdstr, 50);cdstr[49] = '\0';return *this;
}

2.完成练习 1，但让两个类使用动态内存分配而不是长度固定的数组来记录字符串。

#include <iostream>
using namespace std;
#include "classic.h"void Bravo(const Cd &disk);int main()
{Cd c1("Beatles", "Capitol", 14, 35.5);Classic c2 = Classic("Piano Sonata in B flat, Fantasia in C","Alfred Brendel", "Philips", 2, 57.17);Cd *pcd = &c1;cout << "Using object directly:\n";c1.Report();c2.Report();cout << "Using type cd * pointer to objects:\n";pcd->Report();pcd = &c2;pcd->Report();cout << "Calling a function with a Cd reference argument:\n";Bravo(c1);Bravo(c2);cout << "Testing assignment:\n";Classic copy;copy = c2;copy.Report();return 0;
}void Bravo(const Cd &disk)
{disk.Report();
}

#ifndef CD_H_
#define CD_H_class Cd //原有的数组修改为指针便于动态分配内存;
{
private:char *performers;char *labels;int selections;double playtime;public:Cd(const char *s1, const char *s2, int n, double x);Cd(const Cd &d);Cd();virtual ~Cd(); //虚析构函数;virtual void Report() const;Cd &operator=(const Cd &d);
};#endif

#include <iostream>
#include "cd.h"
#include <cstring>Cd::Cd(const char *s1, const char *s2, int n, double x) //用户定义构造函数;
{performers = new char[std::strlen(s1) + 1];std::strcpy(performers, s1);labels = new char[std::strlen(s2) + 1];std::strcpy(labels, s2);selections = n;playtime = x;
}Cd::Cd(const Cd &d) //用户定义构造函数;
{performers = new char[std::strlen(d.performers) + 1];std::strcpy(performers, d.performers);labels = new char[std::strlen(d.labels) + 1];std::strcpy(labels, d.labels);selections = d.selections;playtime = d.playtime;
}Cd::Cd() //用户定义默认构造函数;
{performers = new char[1];performers[0] = '\0';labels = new char[1];labels[0] = '\0';selections = 0;playtime = 0.0;
}Cd::~Cd()
{delete[] performers;delete[] labels;
}void Cd::Report() const
{std::cout << "Performers: " << performers << std::endl;std::cout << "Label: " << labels << std::endl;std::cout << "Selections: " << selections << std::endl;std::cout << "Playtime: " << playtime << std::endl;
}Cd &Cd::operator=(const Cd &d) //重载赋值运算符;
{if (this == &d){return *this;}delete[] performers; //释放原有已分配的内存空间;delete[] labels;     //同上;performers = new char[std::strlen(d.performers) + 1];std::strcpy(performers, d.performers);labels = new char[std::strlen(d.labels) + 1];std::strcpy(labels, d.labels);selections = d.selections;playtime = d.playtime;return *this;
}

#ifndef CLASSIC_H_
#define CLASSIC_H_
#include "cd.h"class Classic : public Cd //公有继承派生类;
{
private:char *cdstr;public:Classic();Classic(const char *s1, const char *s2, const char *s3, int n, double x);Classic(const char *s, const Cd &d);~Classic();virtual void Report() const;Classic &operator=(const Classic &cs);
};#endif

#include <iostream>
#include <cstring>
#include "classic.h"Classic::Classic() : Cd()
{cdstr = new char[1];cdstr[0] = '\0';
}Classic::Classic(const char *s, const char *s1, const char *s2, int n, double x) : Cd(s1, s2, n, x) //基类构造函数的成员列表初始化;
{cdstr = new char[std::strlen(s) + 1];std::strcpy(cdstr, s);
}Classic::Classic(const char *s, const Cd &d) : Cd(d) //基类构造函数的成员列表初始化;
{cdstr = new char[std::strlen(s) + 1];std::strcpy(cdstr, s);
}Classic::~Classic()
{delete[] cdstr;
}void Classic::Report() const
{Cd::Report();std::cout << "Major article in the CD is: " << cdstr << std::endl;std::cout.put('\n');
}Classic &Classic::operator=(const Classic &cs)
{if (this == &cs){return *this;}delete[] cdstr;Cd::operator=(cs);cdstr = new char[std::strlen(cs.cdstr) + 1];std::strcpy(cdstr, cs.cdstr);return *this;
}

3.修改baseDMA-lacksDMA-hasDMA类层次，让三个类都从一个ABC派生而来，然后使用与程序清单13.10 相似的程序对结果进行测试。也就是说，它应使用ABC 指针数组并让用户决定要创建的对象类型。在类定义中添加virtual View()方法以处理数据显示。

#include <iostream>
#include "dma.h"
const int LEN = 3;int main()
{using std::cin;using std::cout;using std::endl;DMA *temp[LEN];char label[50];int rating;char color[40];char style[50];char kind;cout << "Here are the process for creating 3 objects" << endl; //参考书上程序清单13.10让用户进行选择;for (int i = 0; i < LEN; i++){cout << "Enter 1 for baseDMA, 2 for lacksDMA or 3 for hasDMA: ";while (cin >> kind && (kind != '1' && kind != '2' && kind != '3')){cin.clear();while (cin.get() != '\n')continue;cout << "Please enter 1, 2 or 3: ";}if (kind == '1'){cout << "Please enter the label: ";cin >> label; //推荐输入书中样例Portabelly;cout << "Please enter the rating: ";cin >> rating; //推荐输入书中样例8;temp[i] = new baseDMA(label, rating, "baseDMA");}else if (kind == '2'){cout << "Please enter the color: ";cin >> color; //推荐输入书中样例red;temp[i] = new lacksDMA(color, "lacksDMA");}else{cout << "Please enter the style: ";cin >> style; //推荐输入书中样例Mercator;temp[i] = new hasDMA(style, "hasDMA");}}cout << "\nThe results after creating 3 objects" << endl;for (int i = 0; i < LEN; i++){temp[i]->View();}for (int i = 0; i < LEN; i++){delete temp[i];}cout << "Done.\n";return 0;
}

#ifndef DMA_H_
#define DMA_H_
#include <iostream>class DMA
{
private:char *classname; //基类成员设为一个char指针方便分配内存空间保存派生类的类名;protected:const char *show_classname() const { return classname; } //抽象基类DMA的View方法不进行定义因此使用protected让派生类可以访问基类数据;public:DMA(const char *cn = "null");  //声明基类DMA的默认构造函数;DMA(const DMA &rs);            //声明基类DMA的复制构造函数;DMA &operator=(const DMA &rs); //声明为基类DMA重载赋值运算符;virtual ~DMA();                //声明基类DMA的虚析构函数;virtual void View() const = 0; //声明基类DMA的纯虚函数;
};class baseDMA : public DMA
{
private:char *label;int rating;public:baseDMA(const char *l = "null", int r = 0, const char *cn = "null"); //声明派生类baseDMA的默认构造函数;baseDMA(const char *l, int r, const DMA &rs);                        //声明派生类baseDMA的用户定义构造函数;baseDMA(const baseDMA &rs);                                          //声明派生类baseDMA的复制构造函数;~baseDMA();                                                          //声明派生类baseDMA的析构函数;baseDMA &operator=(const baseDMA &rs);                               //声明为派生类baseDMA重载赋值运算符;virtual void View() const;                                           //声明为派生类baseDMA定义基类虚函数;
};class lacksDMA : public DMA
{
private:enum { COL_LEN = 40 };char color[COL_LEN];public:lacksDMA(const char *c = "blank", const char *cn = "null"); //声明派生类lacksDMA的默认构造函数;lacksDMA(const char *c, const DMA &rs);                     //声明派生类lacksDMA的用户定义构造函数;lacksDMA(const lacksDMA &rs);                               //声明派生类lacksDMA的复制构造函数;~lacksDMA();                                                //声明派生类lacksDMA的析构函数;lacksDMA &operator=(const lacksDMA &rs);                    //声明为派生类lacksDMA重载赋值运算符;virtual void View() const;                                  //声明为派生类lacksDMA定义基类虚函数;
};class hasDMA : public DMA
{
private:char *style;public:hasDMA(const char *s = "none", const char *cn = "null"); //声明派生类hasDMA的默认构造函数;hasDMA(const char *s, const DMA &rs);                    //声明派生类hasDMA的用户定义构造函数;hasDMA(const hasDMA &rs);                                //声明派生类hasDMA的复制构造函数;~hasDMA();                                               //声明派生类hasDMA的析构函数;hasDMA &operator=(const hasDMA &rs);                     //声明为派生类hasDMA重载赋值运算符;virtual void View() const;                               //声明为派生类hasDMA定义基类虚函数;
};#endif

#include "dma.h"
#include <cstring>DMA::DMA(const char *cn) //定义基类DMA的默认构造函数;
{classname = new char[std::strlen(cn) + 1];std::strcpy(classname, cn);
}DMA::DMA(const DMA &rs) //定义基类DMA的复制构造函数;
{classname = new char[std::strlen(rs.classname) + 1];std::strcpy(classname, rs.classname);
}DMA &DMA::operator=(const DMA &rs) //为基类DMA重载赋值运算符;
{if (this == &rs){return *this;}delete[] classname; //先释放后分配;classname = new char[std::strlen(rs.classname) + 1];std::strcpy(classname, rs.classname);return *this;
}DMA::~DMA() //定义基类DMA的析构函数;
{delete[] classname;
}baseDMA::baseDMA(const char *l, int r, const char *cn) : DMA(cn) //定义派生类baseDMA的默认构造函数;
{label = new char[std::strlen(l) + 1];std::strcpy(label, l);rating = r;
}baseDMA::baseDMA(const char *l, int r, const DMA &rs) : DMA(rs) //定义派生类baseDMA的用户定义构造函数;
{label = new char[std::strlen(l) + 1];std::strcpy(label, l);rating = r;
}baseDMA::baseDMA(const baseDMA &rs) : DMA(rs) //定义派生类baseDMA的复制构造函数;
{label = new char[std::strlen(rs.label) + 1];std::strcpy(label, rs.label);rating = rs.rating;
}baseDMA::~baseDMA() //定义派生类baseDMA的析构函数;
{delete[] label;
}baseDMA &baseDMA::operator=(const baseDMA &rs) //为派生类baseDMA重载赋值运算符;
{if (this == &rs){return *this;}delete[] label;     //先释放后分配;DMA::operator=(rs); //调用基类DMA的赋值运算符方法初始化派生类baseDMA的基类数据成员;label = new char[std::strlen(rs.label) + 1];std::strcpy(label, rs.label);rating = rs.rating;return *this;
}void baseDMA::View() const //为派生类baseDMA定义基类虚函数;
{std::cout << "Classname: " << show_classname() << std::endl; //调用基类protected中的show_classname方法显示基类数据成员;std::cout << "Label: " << label << std::endl;std::cout << "Rating: " << rating << std::endl;
}lacksDMA::lacksDMA(const char *c, const char *cn) : DMA(cn) //定义派生类lacksDMA的默认构造函数;
{std::strncpy(color, c, COL_LEN - 1);color[COL_LEN - 1] = '\0';
}lacksDMA::lacksDMA(const char *c, const DMA &rs) : DMA(rs) //定义派生类lacksDMA的用户定义构造函数;
{std::strncpy(color, c, COL_LEN - 1);color[COL_LEN - 1] = '\0';
}lacksDMA::lacksDMA(const lacksDMA &rs) : DMA(rs) //定义派生类lacksDMA的复制构造函数;
{std::strncpy(color, rs.color, COL_LEN - 1);color[COL_LEN - 1] = '\0';
}lacksDMA::~lacksDMA()
{
}lacksDMA &lacksDMA::operator=(const lacksDMA &rs) //为派生类lacksDMA重载赋值运算符;
{if (this == &rs){return *this;}DMA::operator=(rs); //调用基类DMA的赋值运算符方法初始化派生类lacksDMA的基类数据成员;std::strncpy(color, rs.color, COL_LEN - 1);color[COL_LEN - 1] = '\0';return *this;
}void lacksDMA::View() const //为派生类lacksDMA定义基类虚函数;
{std::cout << "Classname: " << show_classname() << std::endl; //调用基类protected中的show_classname方法显示基类数据成员;std::cout << "Color: " << color << std::endl;
}hasDMA::hasDMA(const char *s, const char *cn) : DMA(cn) //定义派生类hasDMA的默认构造函数;
{style = new char[std::strlen(s) + 1];std::strcpy(style, s);
}hasDMA::hasDMA(const char *s, const DMA &rs) : DMA(rs) //定义派生类hasDMA的用户定义构造函数;
{style = new char[std::strlen(s) + 1];std::strcpy(style, s);
}hasDMA::hasDMA(const hasDMA &rs) : DMA(rs) //定义派生类hasDMA的复制构造函数;
{style = new char[std::strlen(rs.style) + 1];std::strcpy(style, rs.style);
}hasDMA::~hasDMA() //定义派生类hasDMA的析构函数;
{delete[] style;
}hasDMA &hasDMA::operator=(const hasDMA &rs) //为派生类hasDMA重载赋值运算符;
{if (this == &rs){return *this;}delete[] style;     //先释放后分配;DMA::operator=(rs); //调用基类DMA的赋值运算符方法初始化派生类hasDMA的基类数据成员;style = new char[std::strlen(rs.style) + 1];std::strcpy(style, rs.style);return *this;
}void hasDMA::View() const //为派生类hasDMA定义基类虚函数;
{std::cout << "Classname: " << show_classname() << std::endl; //调用基类protected中的show_classname方法显示基类数据成员;std::cout << "Style: " << style << std::endl;
}

4.BenevolentOrderof Programmers用来维护瓶装葡萄酒箱。为描述它BPPortmaster设置了一个Port类，其声明如下:

#include'<iostream>
using- namespace std;
class Port
private:
char *brand;-charkstyle(201//ieawnyrubyintagesiintbottles;-public.飞+A
Port(const char *br"none",~const char:*st   "none, int b  0)
Port(const Port 5 p);
copy constructor
virtual.-Port(- delete ll brand;
Port &~operator=(const.Port 5 p):.Port & operator+=(int b) ，
Port 5 operator-=(int bj;available
// addsb-tobottles// subtracts b from bottles, if
--
int'BottleCount() const-f return bottles;virtual void showl const:
friend ostream & operatores(ostream & os,const Port & p);

show()方法按下面的格式显示信息
Brand:GalFo
Kind: tawnyBottles:20
operator<<()函数按下面的格式显示信息(末尾没有换行符):Gal1o，tawnyr20-
PortMaster 完成了-Port类的方法定义后派生了VintagePort类然后被解职-因为不小心将一瓶45度Cockbum泼到了正在准备烤肉调料的人身上VintagePort类如下所示:

class VintagePort :publicPort// style-necessarily=vintage
-ai
private:
ehar.*.nickname;
int year!
public:
VintagePortl:
// 1.e,r ."TheNoble".or "oldvelvet",etc ..vintageyear
VintagePort(const char* ,br;int b,const char *inn,int y);;+yintagePortqconstVintagePort-&vp)------_.-
VintagePort(E-delete l] nicknamerVintageport 5 operator=(const VintagePort  vpF;void Show(yconst:....-..
friend ostream  operator<<(ostream os,const Vintageport & vp);

您被指定负责完成 VintagePorta
a.第一个任务是重新创建Port 方法定义，因为前任被开除时销毁了方法定义

b.第二个任务是解释为什么有的方法重新定义了，而有些没有重新定义。
c.第三个任务是解释为何没有operator-)和operator<<()声明为虚的。
d.第四个任务是提供VintagePort 中各个方法的定义。

#include "port.h"
#include "vintageport.h"int main()
{Port wine1("Gallo", "tawny", 20);                     //构造Port基类对象;VintagePort wine2("Lafei", 10, "strong wine", 1876);  //构造VintagePort基类对象;VintagePort wine3("Merlot", 50, "middle wine", 1976); //构造VintagePort基类对象;cout << "Here is the Port object:\n";wine1.Show();          //调用基类Show方法;cout << wine1 << endl; //调用基类重载输出流运算符;cout << "\nHere are the VintagePort objects:\n";wine2.Show();          //调用派生类Show方法;cout << wine2 << endl; //调用派生类重载输出流运算符;wine3.Show();          //调用派生类Show方法;cout << wine3 << endl; //调用派生类重载输出流运算符;cout << "\nGallo add 20 bottles:\n";wine1 += 20; //调用基类重载+=运算符;wine1.Show();cout << "\nLafei add 10 bottles:\n";wine2 += 10; //调用派生类重载+=运算符;wine2.Show();cout << "\nMerlot minus 10 bottles:\n";wine3 -= 10; //调用派生类重载-=运算符;wine3.Show();VintagePort wine4(wine2); //调用派生类复制构造函数;cout << "\nResult of VintagePort copy:\n";wine4.Show();VintagePort wine5;wine5 = wine3; //调用派生类重载赋值运算符;cout << "\nResult of VintagePort assignment:\n";wine5.Show();return 0;
}

#ifndef PORT_H_
#define PORT_H_
#include <iostream>
using namespace std;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);
};#endif

#include "port.h"
#include <cstring>Port::Port(const char *br, const char *st, int b)
{brand = new char[std::strlen(br) + 1]; //new分配内存;std::strcpy(brand, br);std::strncpy(style, st, 20);style[19] = '\0'; //保证字符串是有效的;bottles = b;
}Port::Port(const Port &p)
{brand = new char[std::strlen(p.brand) + 1];std::strcpy(brand, p.brand);std::strncpy(style, p.style, 20);style[19] = '\0';bottles = p.bottles;
}Port &Port::operator=(const Port &p)
{if (this == &p){return *this;}delete[] brand;brand = new char[std::strlen(p.brand) + 1];std::strcpy(brand, p.brand);std::strncpy(style, p.style, 20);style[19] = '\0';bottles = p.bottles;return *this;
}Port &Port::operator+=(int b)
{bottles += b;return *this; //返回调用对象的引用;
}Port &Port::operator-=(int b)
{bottles -= b;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;
}

#ifndef VINTAGEPORT_H_
#define VINTAGEPORT_H_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

#include <cstring>
#include "port.h"
#include "vintageport.h"VintagePort::VintagePort() : Port("none", "vintage", 0) //成员列表初始化派生类的基类对象数据;
{nickname = new char[1];nickname[0] = '\0';year = 0;
}VintagePort::VintagePort(const char *br, int b, const char *nn, int y) : Port(br, "vintage", b) //成员列表初始化派生类的基类对象数据;
{nickname = new char[std::strlen(nn) + 1];std::strcpy(nickname, nn);year = y;
}VintagePort::VintagePort(const VintagePort &vp) : Port(vp) //调用基类复制构造函数初始化派生类的基类对象数据;
{nickname = new char[std::strlen(vp.nickname) + 1];std::strcpy(nickname, vp.nickname);year = vp.year;
}VintagePort &VintagePort::operator=(const VintagePort &vp)
{if (this == &vp){return *this;}delete[] nickname;Port::operator=(vp); //调用基类赋值运算符修改派生类的基类数据成员;nickname = new char[std::strlen(vp.nickname) + 1];std::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; //强制类型转换调用Port基类的重载输出流运算符方法;os << ", " << vp.nickname << ", " << vp.year;return os;
}