• 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
    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 // 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();

    1. #include 
    2. using namespace std;
    3. #include "classic.h"
    4.  
    5. void Bravo(const Cd &disk);
    6.  
    7. int main()
    8. {
    9.     Cd c1("Beatles", "Capitol", 14, 35.5);
    10.     Classic c2 = Classic("Piano Sonata in B flat, Fantasia in C",
    11.                          "Alfred Brendel", "Philips", 2, 57.17);
    12.     Cd *pcd = &c1;
    13.  
    14.     cout << "Using object directly:\n";
    15.     c1.Report();
    16.     c2.Report();
    17.  
    18.     cout << "Using type cd * pointer to objects:\n";
    19.     pcd->Report();
    20.     pcd = &c2;
    21.     pcd->Report();
    22.  
    23.     cout << "Calling a function with a Cd reference argument:\n";
    24.     Bravo(c1);
    25.     Bravo(c2);
    26.  
    27.     cout << "Testing assignment:\n";
    28.     Classic copy;
    29.     copy = c2;
    30.     copy.Report();
    31.  
    32.     return 0;
    33. }
    34.  
    35. void Bravo(const Cd &disk)
    36. {
    37.     disk.Report();
    38. }
    1. #ifndef CD_H_
    2. #define CD_H_
    3.  
    4. class Cd
    5. {
    6. private:
    7.     char performers[50];
    8.     char labels[20];
    9.     int selections;
    10.     double playtime;
    11.  
    12. public:
    13.     Cd(const char *s1, const char *s2, int n, double x);
    14.     Cd(const Cd &d);
    15.     Cd();
    16.     virtual ~Cd();
    17.     virtual void Report() const;
    18.     Cd &operator=(const Cd &d);
    19. };
    20.  
    21. #endif
    1. #include 
    2. #include "cd.h"
    3. #include 
    4.  
    5. Cd::Cd(const char *s1, const char *s2, int n, double x) //用户定义构造函数;
    6. {
    7.     std::strncpy(performers, s1, 50);
    8.     performers[49] = '\0';
    9.     std::strncpy(labels, s2, 20);
    10.     labels[19] = '\0';
    11.     selections = n;
    12.     playtime = x;
    13. }
    14.  
    15. Cd::Cd(const Cd &d) //用户定义构造函数;
    16. {
    17.     std::strncpy(performers, d.performers, 50);
    18.     performers[49] = '\0';
    19.     std::strncpy(labels, d.labels, 50);
    20.     labels[49] = '\0';
    21.     selections = d.selections;
    22.     playtime = d.playtime;
    23. }
    24.  
    25. Cd::Cd() //用户定义默认构造函数;
    26. {
    27.     performers[0] = '\0';
    28.     labels[0] = '\0';
    29.     selections = 0;
    30.     playtime = 0.0;
    31. }
    32.  
    33. Cd::~Cd()
    34. {
    35. }
    36.  
    37. void Cd::Report() const
    38. {
    39.     std::cout << "Performers: " << performers << std::endl;
    40.     std::cout << "Label: " << labels << std::endl;
    41.     std::cout << "Selections: " << selections << std::endl;
    42.     std::cout << "Playtime: " << playtime << std::endl;
    43. }
    44.  
    45. Cd &Cd::operator=(const Cd &d)
    46. {
    47.     if (this == &d)
    48.     {
    49.         return *this;
    50.     }
    51.     std::strncpy(performers, d.performers, 50);
    52.     performers[49] = '\0';
    53.     std::strncpy(labels, d.labels, 20);
    54.     labels[19] = '\0';
    55.     selections = d.selections;
    56.     playtime = d.playtime;
    57.     return *this;
    58. }
    1. #ifndef CLASSIC_H_
    2. #define CLASSIC_H_
    3. #include "cd.h"
    4.  
    5. class Classic : public Cd
    6. {
    7. private:
    8.     char cdstr[50];
    9.  
    10. public:
    11.     Classic() : Cd() { cdstr[0] = '\0'; }
    12.     Classic(const char *s, const char *s1, const char *s2, int n, double x);
    13.     Classic(const char *s, const Cd &d);
    14.     ~Classic();
    15.     virtual void Report() const;
    16.     Classic &operator=(const Classic &cs);
    17. };
    18.  
    19. #endif
    1. #include 
    2. #include 
    3. #include "classic.h"
    4.  
    5. Classic::Classic(const char *s, const char *s1, const char *s2, int n, double x) : Cd(s1, s2, n, x)
    6. {
    7.     std::strncpy(cdstr, s, 50);
    8.     cdstr[49] = '\0';
    9. }
    10.  
    11. Classic::Classic(const char *s, const Cd &d) : Cd(d)
    12. {
    13.     std::strncpy(cdstr, s, 50);
    14.     cdstr[49] = '\0';
    15. }
    16.  
    17. Classic::~Classic()
    18. {
    19. }
    20.  
    21. void Classic::Report() const
    22. {
    23.     Cd::Report();
    24.     std::cout << "Major article in the CD is: " << cdstr << std::endl;
    25.     std::cout.put('\n');
    26. }
    27.  
    28. Classic &Classic::operator=(const Classic &cs)
    29. {
    30.     if (this == &cs)
    31.     {
    32.         return *this;
    33.     }
    34.     Cd::operator=(cs);
    35.     std::strncpy(cdstr, cs.cdstr, 50);
    36.     cdstr[49] = '\0';
    37.     return *this;
    38. }

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

    1. #include 
    2. using namespace std;
    3. #include "classic.h"
    4.  
    5. void Bravo(const Cd &disk);
    6.  
    7. int main()
    8. {
    9.     Cd c1("Beatles", "Capitol", 14, 35.5);
    10.     Classic c2 = Classic("Piano Sonata in B flat, Fantasia in C",
    11.                          "Alfred Brendel", "Philips", 2, 57.17);
    12.     Cd *pcd = &c1;
    13.  
    14.     cout << "Using object directly:\n";
    15.     c1.Report();
    16.     c2.Report();
    17.  
    18.     cout << "Using type cd * pointer to objects:\n";
    19.     pcd->Report();
    20.     pcd = &c2;
    21.     pcd->Report();
    22.  
    23.     cout << "Calling a function with a Cd reference argument:\n";
    24.     Bravo(c1);
    25.     Bravo(c2);
    26.  
    27.     cout << "Testing assignment:\n";
    28.     Classic copy;
    29.     copy = c2;
    30.     copy.Report();
    31.  
    32.     return 0;
    33. }
    34.  
    35. void Bravo(const Cd &disk)
    36. {
    37.     disk.Report();
    38. }
    1. #ifndef CD_H_
    2. #define CD_H_
    3.  
    4. class Cd //原有的数组修改为指针便于动态分配内存;
    5. {
    6. private:
    7.     char *performers;
    8.     char *labels;
    9.     int selections;
    10.     double playtime;
    11.  
    12. public:
    13.     Cd(const char *s1, const char *s2, int n, double x);
    14.     Cd(const Cd &d);
    15.     Cd();
    16.     virtual ~Cd(); //虚析构函数;
    17.     virtual void Report() const;
    18.     Cd &operator=(const Cd &d);
    19. };
    20.  
    21. #endif
    1. #include 
    2. #include "cd.h"
    3. #include 
    4.  
    5. Cd::Cd(const char *s1, const char *s2, int n, double x) //用户定义构造函数;
    6. {
    7.     performers = new char[std::strlen(s1) + 1];
    8.     std::strcpy(performers, s1);
    9.     labels = new char[std::strlen(s2) + 1];
    10.     std::strcpy(labels, s2);
    11.     selections = n;
    12.     playtime = x;
    13. }
    14.  
    15. Cd::Cd(const Cd &d) //用户定义构造函数;
    16. {
    17.     performers = new char[std::strlen(d.performers) + 1];
    18.     std::strcpy(performers, d.performers);
    19.     labels = new char[std::strlen(d.labels) + 1];
    20.     std::strcpy(labels, d.labels);
    21.     selections = d.selections;
    22.     playtime = d.playtime;
    23. }
    24.  
    25. Cd::Cd() //用户定义默认构造函数;
    26. {
    27.     performers = new char[1];
    28.     performers[0] = '\0';
    29.     labels = new char[1];
    30.     labels[0] = '\0';
    31.     selections = 0;
    32.     playtime = 0.0;
    33. }
    34.  
    35. Cd::~Cd()
    36. {
    37.     delete[] performers;
    38.     delete[] labels;
    39. }
    40.  
    41. void Cd::Report() const
    42. {
    43.     std::cout << "Performers: " << performers << std::endl;
    44.     std::cout << "Label: " << labels << std::endl;
    45.     std::cout << "Selections: " << selections << std::endl;
    46.     std::cout << "Playtime: " << playtime << std::endl;
    47. }
    48.  
    49. Cd &Cd::operator=(const Cd &d) //重载赋值运算符;
    50. {
    51.     if (this == &d)
    52.     {
    53.         return *this;
    54.     }
    55.     delete[] performers; //释放原有已分配的内存空间;
    56.     delete[] labels;     //同上;
    57.     performers = new char[std::strlen(d.performers) + 1];
    58.     std::strcpy(performers, d.performers);
    59.     labels = new char[std::strlen(d.labels) + 1];
    60.     std::strcpy(labels, d.labels);
    61.     selections = d.selections;
    62.     playtime = d.playtime;
    63.     return *this;
    64. }
    1. #ifndef CLASSIC_H_
    2. #define CLASSIC_H_
    3. #include "cd.h"
    4.  
    5. class Classic : public Cd //公有继承派生类;
    6. {
    7. private:
    8.     char *cdstr;
    9.  
    10. public:
    11.     Classic();
    12.     Classic(const char *s1, const char *s2, const char *s3, int n, double x);
    13.     Classic(const char *s, const Cd &d);
    14.     ~Classic();
    15.     virtual void Report() const;
    16.     Classic &operator=(const Classic &cs);
    17. };
    18.  
    19. #endif
    1. #include 
    2. #include 
    3. #include "classic.h"
    4.  
    5. Classic::Classic() : Cd()
    6. {
    7.     cdstr = new char[1];
    8.     cdstr[0] = '\0';
    9. }
    10.  
    11. Classic::Classic(const char *s, const char *s1, const char *s2, int n, double x) : Cd(s1, s2, n, x) //基类构造函数的成员列表初始化;
    12. {
    13.     cdstr = new char[std::strlen(s) + 1];
    14.     std::strcpy(cdstr, s);
    15. }
    16.  
    17. Classic::Classic(const char *s, const Cd &d) : Cd(d) //基类构造函数的成员列表初始化;
    18. {
    19.     cdstr = new char[std::strlen(s) + 1];
    20.     std::strcpy(cdstr, s);
    21. }
    22.  
    23. Classic::~Classic()
    24. {
    25.     delete[] cdstr;
    26. }
    27.  
    28. void Classic::Report() const
    29. {
    30.     Cd::Report();
    31.     std::cout << "Major article in the CD is: " << cdstr << std::endl;
    32.     std::cout.put('\n');
    33. }
    34.  
    35. Classic &Classic::operator=(const Classic &cs)
    36. {
    37.     if (this == &cs)
    38.     {
    39.         return *this;
    40.     }
    41.     delete[] cdstr;
    42.     Cd::operator=(cs);
    43.     cdstr = new char[std::strlen(cs.cdstr) + 1];
    44.     std::strcpy(cdstr, cs.cdstr);
    45.     return *this;
    46. }

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

    1. #include 
    2. #include "dma.h"
    3. const int LEN = 3;
    4.  
    5. int main()
    6. {
    7.     using std::cin;
    8.     using std::cout;
    9.     using std::endl;
    10.  
    11.     DMA *temp[LEN];
    12.     char label[50];
    13.     int rating;
    14.     char color[40];
    15.     char style[50];
    16.     char kind;
    17.  
    18.     cout << "Here are the process for creating 3 objects" << endl; //参考书上程序清单13.10让用户进行选择;
    19.     for (int i = 0; i < LEN; i++)
    20.     {
    21.         cout << "Enter 1 for baseDMA, 2 for lacksDMA or 3 for hasDMA: ";
    22.         while (cin >> kind && (kind != '1' && kind != '2' && kind != '3'))
    23.         {
    24.             cin.clear();
    25.             while (cin.get() != '\n')
    26.                 continue;
    27.             cout << "Please enter 1, 2 or 3: ";
    28.         }
    29.         if (kind == '1')
    30.         {
    31.             cout << "Please enter the label: ";
    32.             cin >> label; //推荐输入书中样例Portabelly;
    33.             cout << "Please enter the rating: ";
    34.             cin >> rating; //推荐输入书中样例8;
    35.             temp[i] = new baseDMA(label, rating, "baseDMA");
    36.         }
    37.         else if (kind == '2')
    38.         {
    39.             cout << "Please enter the color: ";
    40.             cin >> color; //推荐输入书中样例red;
    41.             temp[i] = new lacksDMA(color, "lacksDMA");
    42.         }
    43.         else
    44.         {
    45.             cout << "Please enter the style: ";
    46.             cin >> style; //推荐输入书中样例Mercator;
    47.             temp[i] = new hasDMA(style, "hasDMA");
    48.         }
    49.     }
    50.     cout << "\nThe results after creating 3 objects" << endl;
    51.     for (int i = 0; i < LEN; i++)
    52.     {
    53.         temp[i]->View();
    54.     }
    55.     for (int i = 0; i < LEN; i++)
    56.     {
    57.         delete temp[i];
    58.     }
    59.     cout << "Done.\n";
    60.  
    61.     return 0;
    62. }
    1. #ifndef DMA_H_
    2. #define DMA_H_
    3. #include 
    4.  
    5. class DMA
    6. {
    7. private:
    8.     char *classname; //基类成员设为一个char指针方便分配内存空间保存派生类的类名;
    9.  
    10. protected:
    11.     const char *show_classname() const { return classname; } //抽象基类DMA的View方法不进行定义因此使用protected让派生类可以访问基类数据;
    12.  
    13. public:
    14.     DMA(const char *cn = "null");  //声明基类DMA的默认构造函数;
    15.     DMA(const DMA &rs);            //声明基类DMA的复制构造函数;
    16.     DMA &operator=(const DMA &rs); //声明为基类DMA重载赋值运算符;
    17.     virtual ~DMA();                //声明基类DMA的虚析构函数;
    18.     virtual void View() const = 0; //声明基类DMA的纯虚函数;
    19. };
    20.  
    21. class baseDMA : public DMA
    22. {
    23. private:
    24.     char *label;
    25.     int rating;
    26.  
    27. public:
    28.     baseDMA(const char *l = "null", int r = 0, const char *cn = "null"); //声明派生类baseDMA的默认构造函数;
    29.     baseDMA(const char *l, int r, const DMA &rs);                        //声明派生类baseDMA的用户定义构造函数;
    30.     baseDMA(const baseDMA &rs);                                          //声明派生类baseDMA的复制构造函数;
    31.     ~baseDMA();                                                          //声明派生类baseDMA的析构函数;
    32.     baseDMA &operator=(const baseDMA &rs);                               //声明为派生类baseDMA重载赋值运算符;
    33.     virtual void View() const;                                           //声明为派生类baseDMA定义基类虚函数;
    34. };
    35.  
    36. class lacksDMA : public DMA
    37. {
    38. private:
    39.     enum { COL_LEN = 40 };
    40.     char color[COL_LEN];
    41.  
    42. public:
    43.     lacksDMA(const char *c = "blank", const char *cn = "null"); //声明派生类lacksDMA的默认构造函数;
    44.     lacksDMA(const char *c, const DMA &rs);                     //声明派生类lacksDMA的用户定义构造函数;
    45.     lacksDMA(const lacksDMA &rs);                               //声明派生类lacksDMA的复制构造函数;
    46.     ~lacksDMA();                                                //声明派生类lacksDMA的析构函数;
    47.     lacksDMA &operator=(const lacksDMA &rs);                    //声明为派生类lacksDMA重载赋值运算符;
    48.     virtual void View() const;                                  //声明为派生类lacksDMA定义基类虚函数;
    49. };
    50.  
    51. class hasDMA : public DMA
    52. {
    53. private:
    54.     char *style;
    55.  
    56. public:
    57.     hasDMA(const char *s = "none", const char *cn = "null"); //声明派生类hasDMA的默认构造函数;
    58.     hasDMA(const char *s, const DMA &rs);                    //声明派生类hasDMA的用户定义构造函数;
    59.     hasDMA(const hasDMA &rs);                                //声明派生类hasDMA的复制构造函数;
    60.     ~hasDMA();                                               //声明派生类hasDMA的析构函数;
    61.     hasDMA &operator=(const hasDMA &rs);                     //声明为派生类hasDMA重载赋值运算符;
    62.     virtual void View() const;                               //声明为派生类hasDMA定义基类虚函数;
    63. };
    64.  
    65. #endif
    1. #include "dma.h"
    2. #include 
    3.  
    4. DMA::DMA(const char *cn) //定义基类DMA的默认构造函数;
    5. {
    6.     classname = new char[std::strlen(cn) + 1];
    7.     std::strcpy(classname, cn);
    8. }
    9.  
    10. DMA::DMA(const DMA &rs) //定义基类DMA的复制构造函数;
    11. {
    12.     classname = new char[std::strlen(rs.classname) + 1];
    13.     std::strcpy(classname, rs.classname);
    14. }
    15.  
    16. DMA &DMA::operator=(const DMA &rs) //为基类DMA重载赋值运算符;
    17. {
    18.     if (this == &rs)
    19.     {
    20.         return *this;
    21.     }
    22.     delete[] classname; //先释放后分配;
    23.     classname = new char[std::strlen(rs.classname) + 1];
    24.     std::strcpy(classname, rs.classname);
    25.     return *this;
    26. }
    27.  
    28. DMA::~DMA() //定义基类DMA的析构函数;
    29. {
    30.     delete[] classname;
    31. }
    32.  
    33. baseDMA::baseDMA(const char *l, int r, const char *cn) : DMA(cn) //定义派生类baseDMA的默认构造函数;
    34. {
    35.     label = new char[std::strlen(l) + 1];
    36.     std::strcpy(label, l);
    37.     rating = r;
    38. }
    39.  
    40. baseDMA::baseDMA(const char *l, int r, const DMA &rs) : DMA(rs) //定义派生类baseDMA的用户定义构造函数;
    41. {
    42.     label = new char[std::strlen(l) + 1];
    43.     std::strcpy(label, l);
    44.     rating = r;
    45. }
    46.  
    47. baseDMA::baseDMA(const baseDMA &rs) : DMA(rs) //定义派生类baseDMA的复制构造函数;
    48. {
    49.     label = new char[std::strlen(rs.label) + 1];
    50.     std::strcpy(label, rs.label);
    51.     rating = rs.rating;
    52. }
    53.  
    54. baseDMA::~baseDMA() //定义派生类baseDMA的析构函数;
    55. {
    56.     delete[] label;
    57. }
    58.  
    59. baseDMA &baseDMA::operator=(const baseDMA &rs) //为派生类baseDMA重载赋值运算符;
    60. {
    61.     if (this == &rs)
    62.     {
    63.         return *this;
    64.     }
    65.     delete[] label;     //先释放后分配;
    66.     DMA::operator=(rs); //调用基类DMA的赋值运算符方法初始化派生类baseDMA的基类数据成员;
    67.     label = new char[std::strlen(rs.label) + 1];
    68.     std::strcpy(label, rs.label);
    69.     rating = rs.rating;
    70.     return *this;
    71. }
    72.  
    73. void baseDMA::View() const //为派生类baseDMA定义基类虚函数;
    74. {
    75.     std::cout << "Classname: " << show_classname() << std::endl; //调用基类protected中的show_classname方法显示基类数据成员;
    76.     std::cout << "Label: " << label << std::endl;
    77.     std::cout << "Rating: " << rating << std::endl;
    78. }
    79.  
    80. lacksDMA::lacksDMA(const char *c, const char *cn) : DMA(cn) //定义派生类lacksDMA的默认构造函数;
    81. {
    82.     std::strncpy(color, c, COL_LEN - 1);
    83.     color[COL_LEN - 1] = '\0';
    84. }
    85.  
    86. lacksDMA::lacksDMA(const char *c, const DMA &rs) : DMA(rs) //定义派生类lacksDMA的用户定义构造函数;
    87. {
    88.     std::strncpy(color, c, COL_LEN - 1);
    89.     color[COL_LEN - 1] = '\0';
    90. }
    91.  
    92. lacksDMA::lacksDMA(const lacksDMA &rs) : DMA(rs) //定义派生类lacksDMA的复制构造函数;
    93. {
    94.     std::strncpy(color, rs.color, COL_LEN - 1);
    95.     color[COL_LEN - 1] = '\0';
    96. }
    97.  
    98. lacksDMA::~lacksDMA()
    99. {
    100. }
    101.  
    102. lacksDMA &lacksDMA::operator=(const lacksDMA &rs) //为派生类lacksDMA重载赋值运算符;
    103. {
    104.     if (this == &rs)
    105.     {
    106.         return *this;
    107.     }
    108.     DMA::operator=(rs); //调用基类DMA的赋值运算符方法初始化派生类lacksDMA的基类数据成员;
    109.     std::strncpy(color, rs.color, COL_LEN - 1);
    110.     color[COL_LEN - 1] = '\0';
    111.     return *this;
    112. }
    113.  
    114. void lacksDMA::View() const //为派生类lacksDMA定义基类虚函数;
    115. {
    116.     std::cout << "Classname: " << show_classname() << std::endl; //调用基类protected中的show_classname方法显示基类数据成员;
    117.     std::cout << "Color: " << color << std::endl;
    118. }
    119.  
    120. hasDMA::hasDMA(const char *s, const char *cn) : DMA(cn) //定义派生类hasDMA的默认构造函数;
    121. {
    122.     style = new char[std::strlen(s) + 1];
    123.     std::strcpy(style, s);
    124. }
    125.  
    126. hasDMA::hasDMA(const char *s, const DMA &rs) : DMA(rs) //定义派生类hasDMA的用户定义构造函数;
    127. {
    128.     style = new char[std::strlen(s) + 1];
    129.     std::strcpy(style, s);
    130. }
    131.  
    132. hasDMA::hasDMA(const hasDMA &rs) : DMA(rs) //定义派生类hasDMA的复制构造函数;
    133. {
    134.     style = new char[std::strlen(rs.style) + 1];
    135.     std::strcpy(style, rs.style);
    136. }
    137.  
    138. hasDMA::~hasDMA() //定义派生类hasDMA的析构函数;
    139. {
    140.     delete[] style;
    141. }
    142.  
    143. hasDMA &hasDMA::operator=(const hasDMA &rs) //为派生类hasDMA重载赋值运算符;
    144. {
    145.     if (this == &rs)
    146.     {
    147.         return *this;
    148.     }
    149.     delete[] style;     //先释放后分配;
    150.     DMA::operator=(rs); //调用基类DMA的赋值运算符方法初始化派生类hasDMA的基类数据成员;
    151.     style = new char[std::strlen(rs.style) + 1];
    152.     std::strcpy(style, rs.style);
    153.     return *this;
    154. }
    155.  
    156. void hasDMA::View() const //为派生类hasDMA定义基类虚函数;
    157. {
    158.     std::cout << "Classname: " << show_classname() << std::endl; //调用基类protected中的show_classname方法显示基类数据成员;
    159.     std::cout << "Style: " << style << std::endl;
    160. }

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

    #include'
    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 中各个方法的定义。

    1. #include "port.h"
    2. #include "vintageport.h"
    3.  
    4. int main()
    5. {
    6.     Port wine1("Gallo", "tawny", 20);                     //构造Port基类对象;
    7.     VintagePort wine2("Lafei", 10, "strong wine", 1876);  //构造VintagePort基类对象;
    8.     VintagePort wine3("Merlot", 50, "middle wine", 1976); //构造VintagePort基类对象;
    9.  
    10.     cout << "Here is the Port object:\n";
    11.     wine1.Show();          //调用基类Show方法;
    12.     cout << wine1 << endl; //调用基类重载输出流运算符;
    13.  
    14.     cout << "\nHere are the VintagePort objects:\n";
    15.     wine2.Show();          //调用派生类Show方法;
    16.     cout << wine2 << endl; //调用派生类重载输出流运算符;
    17.     wine3.Show();          //调用派生类Show方法;
    18.     cout << wine3 << endl; //调用派生类重载输出流运算符;
    19.  
    20.     cout << "\nGallo add 20 bottles:\n";
    21.     wine1 += 20; //调用基类重载+=运算符;
    22.     wine1.Show();
    23.  
    24.     cout << "\nLafei add 10 bottles:\n";
    25.     wine2 += 10; //调用派生类重载+=运算符;
    26.     wine2.Show();
    27.  
    28.     cout << "\nMerlot minus 10 bottles:\n";
    29.     wine3 -= 10; //调用派生类重载-=运算符;
    30.     wine3.Show();
    31.  
    32.     VintagePort wine4(wine2); //调用派生类复制构造函数;
    33.     cout << "\nResult of VintagePort copy:\n";
    34.     wine4.Show();
    35.  
    36.     VintagePort wine5;
    37.     wine5 = wine3; //调用派生类重载赋值运算符;
    38.     cout << "\nResult of VintagePort assignment:\n";
    39.     wine5.Show();
    40.  
    41.     return 0;
    42. }
    1. #ifndef PORT_H_
    2. #define PORT_H_
    3. #include 
    4. using namespace std;
    5.  
    6. class Port
    7. {
    8. private:
    9.     char *brand;
    10.     char style[20];
    11.     int bottles;
    12.  
    13. public:
    14.     Port(const char *br = "none", const char *st = "none", int b = 0);
    15.     Port(const Port &p);
    16.     virtual ~Port() { delete[] brand; };
    17.     Port &operator=(const Port &p);
    18.     Port &operator+=(int b);
    19.     Port &operator-=(int b);
    20.     int BottleCount() const { return bottles; }
    21.     virtual void Show() const;
    22.     friend ostream &operator<<(ostream &os, const Port &p);
    23. };
    24.  
    25. #endif
    1. #include "port.h"
    2. #include 
    3.  
    4. Port::Port(const char *br, const char *st, int b)
    5. {
    6.     brand = new char[std::strlen(br) + 1]; //new分配内存;
    7.     std::strcpy(brand, br);
    8.     std::strncpy(style, st, 20);
    9.     style[19] = '\0'; //保证字符串是有效的;
    10.     bottles = b;
    11. }
    12.  
    13. Port::Port(const Port &p)
    14. {
    15.     brand = new char[std::strlen(p.brand) + 1];
    16.     std::strcpy(brand, p.brand);
    17.     std::strncpy(style, p.style, 20);
    18.     style[19] = '\0';
    19.     bottles = p.bottles;
    20. }
    21.  
    22. Port &Port::operator=(const Port &p)
    23. {
    24.     if (this == &p)
    25.     {
    26.         return *this;
    27.     }
    28.     delete[] brand;
    29.     brand = new char[std::strlen(p.brand) + 1];
    30.     std::strcpy(brand, p.brand);
    31.     std::strncpy(style, p.style, 20);
    32.     style[19] = '\0';
    33.     bottles = p.bottles;
    34.     return *this;
    35. }
    36.  
    37. Port &Port::operator+=(int b)
    38. {
    39.     bottles += b;
    40.     return *this; //返回调用对象的引用;
    41. }
    42.  
    43. Port &Port::operator-=(int b)
    44. {
    45.     bottles -= b;
    46.     return *this; //返回调用对象的引用;
    47. }
    48.  
    49. void Port::Show() const
    50. {
    51.     cout << "Brand: " << brand << endl;
    52.     cout << "Kind: " << style << endl;
    53.     cout << "Bottles: " << bottles << endl;
    54. }
    55.  
    56. ostream &operator<<(ostream &os, const Port &p)
    57. {
    58.     os << p.brand << ", " << p.style << ", " << p.bottles;
    59.     return os;
    60. }
    1. #ifndef VINTAGEPORT_H_
    2. #define VINTAGEPORT_H_
    3.  
    4. class VintagePort : public Port
    5. {
    6. private:
    7.     char *nickname;
    8.     int year;
    9.  
    10. public:
    11.     VintagePort();
    12.     VintagePort(const char *br, int b, const char *nn, int y);
    13.     VintagePort(const VintagePort &vp);
    14.     ~VintagePort() { delete[] nickname; }
    15.     VintagePort &operator=(const VintagePort &vp);
    16.     void Show() const;
    17.     friend ostream &operator<<(ostream &os, const VintagePort &vp);
    18. };
    19.  
    20. #endif
    1. #include 
    2. #include "port.h"
    3. #include "vintageport.h"
    4.  
    5. VintagePort::VintagePort() : Port("none", "vintage", 0) //成员列表初始化派生类的基类对象数据;
    6. {
    7.     nickname = new char[1];
    8.     nickname[0] = '\0';
    9.     year = 0;
    10. }
    11.  
    12. VintagePort::VintagePort(const char *br, int b, const char *nn, int y) : Port(br, "vintage", b) //成员列表初始化派生类的基类对象数据;
    13. {
    14.     nickname = new char[std::strlen(nn) + 1];
    15.     std::strcpy(nickname, nn);
    16.     year = y;
    17. }
    18.  
    19. VintagePort::VintagePort(const VintagePort &vp) : Port(vp) //调用基类复制构造函数初始化派生类的基类对象数据;
    20. {
    21.     nickname = new char[std::strlen(vp.nickname) + 1];
    22.     std::strcpy(nickname, vp.nickname);
    23.     year = vp.year;
    24. }
    25.  
    26. VintagePort &VintagePort::operator=(const VintagePort &vp)
    27. {
    28.     if (this == &vp)
    29.     {
    30.         return *this;
    31.     }
    32.     delete[] nickname;
    33.     Port::operator=(vp); //调用基类赋值运算符修改派生类的基类数据成员;
    34.     nickname = new char[std::strlen(vp.nickname) + 1];
    35.     std::strcpy(nickname, vp.nickname);
    36.     year = vp.year;
    37.     return *this;
    38. }
    39.  
    40. void VintagePort::Show() const
    41. {
    42.     Port::Show();
    43.     cout << "Nickname: " << nickname << endl;
    44.     cout << "Year: " << year << endl;
    45. }
    46.  
    47. ostream &operator<<(ostream &os, const VintagePort &vp)
    48. {
    49.     os << (const Port &)vp; //强制类型转换调用Port基类的重载输出流运算符方法;
    50.     os << ", " << vp.nickname << ", " << vp.year;
    51.     return os;
    52. }

  • 相关阅读:
    java计算机毕业设计会展中心招商服务平台MyBatis+系统+LW文档+源码+调试部署
    python毕业设计作品基于django框架 多用户商城平台系统毕设成品（7）中期检查报告
    手把手教你入门Python中的Web开发框架，干货满满！！
    redis数据库
    精准防疫有“利器”| 芯讯通助力数字哨兵护航复市
    聚观早报 | 苹果iOS 16正式版发布；任天堂直面会即将举办
    Spring Boot 开发环境热部署
    QT 状态机的使用
    Leetcode1732：找到最高海拔
    【spring cloud】(七)消息驱动——springcloud Stream
  • 原文地址：https://blog.csdn.net/sakura0908/article/details/132722528