c++ primer plus 习题答案(8)

p475.2

//头文件：

class Cd{

private:

    char *performers;

    char *label;

    int selections;

    double playtime;

public:

    Cd(char *s1, char *s2, int n, double x);

    Cd(const Cd & st);

    Cd();

    virtual ~Cd();

    virtual void Report()const;

    Cd & operator = (const Cd & st);

};

class Classic : public Cd

{

private:

    char *production;

public:

    Classic(char *s1 = "nullbody1", char *s2 = "nullbody2", char *s3 = "nullbody3", int n = , double x = );

    Classic(const Classic & st);

    virtual void Report()const;

    virtual ~Classic();

    Classic & operator=(const Classic & st);

};

//方法：

#include<iostream>

#include<cstring>

#include"classic.h"

using std::cout;

using std::endl;

Cd::Cd(char *s1, char *s2, int n, double x){

    performers = new char[strlen(s1) + ];

    strcpy(performers, s1);

    label = new char[strlen(s2) + ];

    strcpy(label, s2);

    selections = n;

    playtime = x;

}

Cd::Cd(const Cd & st){

    performers = new char[strlen(st.performers) + ];

    strcpy(performers, st.performers);

    label = new char[strlen(st.performers) + ];

    strcpy(label, st.label);

    selections = st.selections;

    playtime = st.playtime;

}

Cd::Cd(){

    performers = NULL;

    label = NULL;

    selections = ;

    playtime = ;

}

void Cd::Report()const{

    cout << "performers: " << performers << endl

        << "label: " << label << endl

        << "selections: " << selections << endl

        << "playtime: " << playtime << endl;

}

Cd & Cd::operator = (const Cd & st){

    if (this == &st)

        return *this;

    performers = new char[strlen(st.performers) + ];

    strcpy(performers, st.performers);

    label = new char[strlen(st.performers) + ];

    strcpy(label, st.label);

    selections = st.selections;

    playtime = st.playtime;

    return *this;

}

Classic::Classic(char *s1, char *s2, char *s3, int n, double x): Cd(s2, s3, n, x){

    production = new char[strlen(s1) + ];

    strcpy(production, s1);

}

Classic::Classic(const Classic & st): Cd(st){

    production = new char[strlen(st.production) + ];

    strcpy(production, st.production);

}

Cd::~Cd(){

    delete[]performers;

    delete[]label;

}

Classic::~Classic(){

    delete[]production;

}

void Classic::Report()const{

    cout << "production: " << production << endl;

    Cd::Report();

}

Classic & Classic::operator=(const Classic & st){

    if (this == &st)

        return *this;

    Cd::operator=(st);

    production = new char[strlen(st.production) + ];

    strcpy(production, st.production);

    return *this;

}

//驱动：

#include<iostream>

#include<cstdlib>

using namespace std;

#include"classic.h"

void Bravo(const Cd & disk);

int main(){

    Cd c1("Beatles", "Capitol", , 35.5);

    Classic c2 = Classic("piano sonata in B flat", "Alfred Brendel", "Philips", , 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: ";

    Classic copy;

    copy = c2;

    copy.Report();

    system("pause");

    return ;

}

void Bravo(const Cd & disk){

    disk.Report();

}

p475.3

 //头文件：

 #include<iostream>

 #ifndef BASE_H_

 #define BASE_H_

 class baseABC

 {

 private:

     char *label;

     int rating;

 public:

     baseABC(const char *s1="null", int r = );

     baseABC(const baseABC &st);

     virtual ~baseABC() = ;

     baseABC & operator=(const baseABC &rs);

     friend std::ostream & operator<<(std::ostream & os, const baseABC & rs);

 };

 class baseDMA : public baseABC

 {

 public:

     baseDMA(const char *s1="null", int r = );

     baseDMA(const baseDMA &st);

     baseDMA & operator=(const baseDMA &rs);

     friend std::ostream & operator<<(std::ostream & os, const baseDMA & rs);

 };

 class lacksDMA : public baseABC

 {

 private:

     enum{COL_LEN=};

     char color[COL_LEN];

 public:

     lacksDMA(const char *pt = "blank", const char *ct = "null", int r = );

     lacksDMA(const char *pt, const baseABC & st);

     friend std::ostream & operator<<(std::ostream & os, const lacksDMA & st);

 };

 class hasDMA : public baseABC

 {

 private:

     char *style;

 public:

     hasDMA(const char *pt = "none", const char *ct = "null", int r = );

     hasDMA(const char *ct, const baseABC &st);

     hasDMA(const hasDMA &st);

     virtual ~hasDMA();

     hasDMA & operator=(const hasDMA & st);

     friend std::ostream & operator <<(std::ostream &os, const hasDMA &st);

 };

 #endif

 //方法：

 #include<iostream>

 #include<cstring>

 #include"classic.h"

 using std::endl;

 baseABC::baseABC(const char *s1, int r){

     label = new char[strlen(s1) + ];

     strcpy(label, s1);

     rating = r;

 }

 baseABC::baseABC(const baseABC &st){

     label = new char[strlen(st.label) + ];

     strcpy(label, st.label);

     rating = st.rating;

 }

 baseABC::~baseABC(){

     delete[]label;

 }

 baseABC & baseABC::operator=(const baseABC &rs){

     if (this == &rs)

         return *this;

     label = new char[strlen(rs.label) + ];

     strcpy(label, rs.label);

     rating = rs.rating;

     return *this;

 }

 std::ostream & operator<<(std::ostream & os, const baseABC & rs){

     os << "label: " << rs.label << endl

         << "rating: " << rs.rating << endl;

     return os;

 }

 baseDMA::baseDMA(const char *s1, int r): baseABC(s1, r){

 }

 baseDMA::baseDMA(const baseDMA &st): baseABC(st){

 }

 baseDMA & baseDMA::operator=(const baseDMA &rs){

     if (this == &rs)

         return *this;

     baseABC::operator=(rs);

     return *this;

 }

 std::ostream & operator<<(std::ostream & os, const baseDMA & rs){

     os << (const baseABC &)rs;

     return os;

 }

 lacksDMA::lacksDMA(const char *pt, const char *ct, int r): baseABC(ct, r){

     strncpy(color, pt, COL_LEN);

     color[COL_LEN - ] = '\0';

 }

 lacksDMA::lacksDMA(const char *pt, const baseABC & st): baseABC(st){

     strncpy(color, pt, COL_LEN);

     color[COL_LEN - ] = '\0';

 }

 std::ostream & operator<<(std::ostream & os, const lacksDMA & st){

     os << (const baseABC &)st<<endl

     <<"color: "<<st.color;

     return os;

 }

 hasDMA::hasDMA(const char *pt, const char *ct, int r): baseABC(ct, r){

     style = new char[strlen(pt) + ];

     strcpy(style, pt);

 }

 hasDMA::hasDMA(const char *ct, const baseABC &st): baseABC(st){

     style = new char[strlen(ct) + ];

     strcpy(style, ct);

 }

 hasDMA::hasDMA(const hasDMA &st): baseABC(st){

     style = new char[strlen(st.style) + ];

     strcpy(style, st.style);

 }

 hasDMA::~hasDMA(){

     delete[]style;

 }

 hasDMA & hasDMA::operator=(const hasDMA & st){

     if (this == &st)

         return *this;

     delete[]style;

     baseABC::operator=(st);

     style = new char[strlen(st.style) + ];

     strcpy(style, st.style);

     return *this;

 }

 std::ostream & operator <<(std::ostream &os, const hasDMA &st){

     os << (const baseABC &)st<<endl

     <<"style: "<< st.style << endl;

     return os;

 }

 //驱动：

 #include<iostream>

 #include<cstdlib>

 #include"classic.h"

 const int CLIENTS = ;

 const int LEN = ;

 int main(){

     using namespace std;

     int i;

     baseABC *pt[CLIENTS];

     for (i = ; i < CLIENTS; i++){

         char temp[LEN];

         cout << "enter the label\n";

         cin.get(temp, LEN).get();

         int r;

         cout << "enter the rating\n";

         cin >> r;

         while (cin.get() != '\n')

             continue;

         char kind;

         cout << "enter 1/2/3 to choice a model to fit baseDMA/lacksDMA/hasDMA\n";

         cin >> kind;

         while (cin.get() != '\n')

             continue;

         if (kind == '')

             pt[i] = new baseDMA(temp, r);

         else if (kind == ''){

             char ar[];

             cout << "enter a color\n";

             cin.get(ar, ).get();

             baseDMA test1(temp, r);

             pt[i] = new lacksDMA(ar, test1);

         }

         else if (kind == ''){

             char ptr[];

             cout << "enter a style\n";

             cin.get(ptr, ).get();

             pt[i] = new hasDMA(ptr, temp, r);

         }

     }

     for (i = ; i < CLIENTS; i++)

         cout << *pt[i] << endl;

     system("pause");

     return ;

 }