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 ;
 }