c++primer（第五版） 第十五章 面向对象程序设计习题答案

纯原创    转载请注明出处:http://blog.csdn.net/axuan_k

略过书上有现成代码的题目

15.1  15.2

15.1
虚成员是基类中的概念
基类中的某些函数希望它的派生类能够重新定义自己的版本
则基类中这样的函数被称为虚函数(虚成员)


15.2
private的成员:只有本类的对象或友元函数或友元类的对象能调用它
protected的成员:除上述之外,本类的派生类的对象也能调用它

15.4

#include<iostream>
using namespace std;
//    15.4
class Base{};
class b1:public b1{};         //不能继承自己
class b2:private Base{};      //这是一个派生类的定义语句而不是声明语句
class b3:public Base{} ;      //派生类的声明应与普通类的声明一样,不该有列表
int main(){
    return 0;
}

15.8   15.9  15.10

#include<iostream>
using namespace std;
int main(){
//    15.8
//    静态类型的成员在进行编译的时候就知道它的类型了
//    动态类型的成员直到程序运行时才直到它自己的类型

//    15.9
//    基类对象的指针指向子类对象
//    基类对象的引用引用子类对象

//    15.10
//    read()函数的第一个参数虽然是istream类型的引用
//    但input对象是istream子类ifstream的对象,
//    即这个参数是动态类型的,所有可以正常工作
    return 0;
}

 

15.12       15.13   15.14

#include<iostream>
#include<string>
using namespace std;
class base
{
public:
   string name() { return basename; }
   virtual void print(ostream &os) { os << basename<<endl; }
private:
   string basename="sssss";
};

class derived : public base
{
public:
   void print(ostream &os) override { base::print(os); //改成这样
   os << "  " << i<<endl;
   }
private:
   int i=2;
};

int main(){
//    15.12
//    有必要,因为override和final的定义并不矛盾
//    override是覆盖基类同名的函数成员
//    而final则表示该函数成员不能继续继承下去
//    可以并且有必要存在两点都满足的成员函数

//    15.13
//    会产生无限递归,在派生类derived中paint方法会重复调用自己
//    从而产生递归,应该通过使用作用域运算符强迫调用基类的paint函数
//    即应改为：
//    Base::paint(os);
    derived a;
    a.print(cout);
    cout<<endl;



//    15.14
    base bobj;
    base *bp1=&bobj;
    base &br1=bobj;

    derived dobj;
    base *bp2=&dobj;
    base &br2=dobj;

    bobj.print(cout);
    //调用base::paint
    dobj.print(cout);
    //调用derived::paint
    cout<<bp1->name()<<endl;
    //父类对象bobj的name
    cout<<bp2->name()<<endl;
    //子类对象dobj继承来的name
    br1.print(cout);
    //调用base::paint
    br2.print(cout);
    //调用derived::paint
    return 0;
}

15.15  15.16  15.17

#include<iostream>
#include<string>
using namespace std;
//  15.15
class Quote{
public:
    Quote()=default;
    Quote(const string& book,double p):bookNo(book),price(p){}
    string isbn()const{return bookNo;}
    virtual double net_price(size_t n)const{
        return n*price;
    }
private:
    string bookNo;
protected:
    double price=0.0;
};

class Disc_quote:public Quote{
public:
    Disc_quote()=default;
    Disc_quote(const string& name,double p,size_t qty,double disc):Quote(name,p),quantity(qty),discount(disc){}
    double net_price(size_t)const =0;
protected:
    size_t quantity=0;
    double discount=0.0;
};

class Bulk_quote:public Disc_quote{
public:
    Bulk_quote()=default;
    Bulk_quote(const string& name,double p,size_t qty,double disc):Disc_quote(name,p,qty,disc){}
//    15.16
    double net_price(size_t cnt)const override{
        if(cnt>=quantity)
            return cnt*(1-discount)*price;
        else
            return cnt*price;
    }

};
int main(){
//    15.17
    Quote a("asdsad",1.2);
    Disc_quote b("sasda",1.2,123,2.2);
//D:\3.22\asd.cpp|45|error: cannot declare variable 'b' to be of abstract type 'Disc_quote'|
    Bulk_quote c("sasda",1.2,123,2.2);
    return 0;
}

15.18  15.19

#include <iostream>
#include<string>
#include<sstream>
using namespace std;

int main() {

//    15.18
    Base *p = &d1; //legal
    p = &d2; //illegal
    p = &d3; //illegal
    p = &dd1; //legal
    p = &dd2; //illegal
    p = &dd3; //illegal
    //只有第一个和第四个是正确的 这里是 在用户代码中 派生类向基类的转换(指针)
    //书中原话:只有当D公有的继承B时,用户代码  才能使用派生类向基类转换

//    15.19
//    因为转换发生在函数中,所有这里用到书中第二条规则:不论D以什么方式继承B,D
//    的成员函数和友元都能使用派生类向基类的转换
//    所以所有继承于Base的类Pub_Derv,Priv_Derv,Prot_Derv都可以转换
//    Derived_from_Public ,Derived_from_Protected 这两个类也可以转换两次得到
	return 0;
}

15.23

#include <iostream>
#include <string>
class Base
{
public:
    virtual int fcn(){ std::cout << "Base::fcn()\n"; return 0; }
};

class D1 : public Base
{
public:
    //去掉参数列表中的int 同时可在()后面添加override
    int fcn() override  { std::cout << "D1::fcn()\n";return 0; }
    virtual void f2() { std::cout << "D1::f2()\n"; }
};

class D2 : public D1
{
public:
    int fcn(int);
    int fcn() override { std::cout << "D2::fcn()\n";return 0; }
    void f2() override { std::cout << "D2::f2()\n"; }
};

int main()
{
    Base bobj;
    D1 d1obj;
    D2 d2obj;

    Base *bp1 = &bobj, *bp2 = &d1obj, *bp3 = &d2obj;
    bp1->fcn(); //Base::fcn()
    bp2->fcn(); // D1::fcn()
    bp3->fcn(); //  D2::fcn()

    D1 *d1p = &d1obj; D2 *d2p = &d2obj;

    //bp2->f2();     //同书上 Base没有f2()
    //d1p->f2();    // D1::f2()
    //d2p->f2();    // D2::f2()

    return 0;
}

15.24

基类需要虚析构函数
在这些类完成动态绑定的同时,通过调用正确的析构函数来执行正确的销毁操作

15.25

会产生编译错误          
因为Bulk_quote中也有默认构造函数,而这个构造函数的状态是由Disc_quote的默认构造函数决定的;
Bulk_quote删除了默认构造函数,同时存在另一个4个参数的构造函数,所以编译器也不会再合成默认构造函数

 15.26

#include<iostream>
#include<string>
using namespace std;
//  15.15
class Quote{
public:
    Quote(){cout<<"Quote()"<<endl;};
    Quote(const string& book,double p):bookNo(book),price(p){
        cout<<"Quote(const string& book,double p)"<<endl;
    }
    Quote(const Quote& q):bookNo(q.bookNo),price(q.price){
        cout<<"Quote(const Quote& q)"<<endl;
    }
    Quote& operator=(const Quote& q){
        cout<<"Quote& operator=(const Quote& q)"<<endl;
        bookNo=q.bookNo;
        price=q.price;
        return *this;
    }
    virtual ~Quote(){cout<<"virtual ~Quote()"<<endl;}
    string isbn()const{return bookNo;}
    virtual double net_price(size_t n)const{
        return n*price;
    }
private:
    string bookNo;
protected:
    double price=0.0;
};


class Disc_quote:public Quote{
public:
    Disc_quote()=default;
    Disc_quote(const string& name,double p,size_t qty,double disc):Quote(name,p),quantity(qty),discount(disc){}
    Disc_quote(const Disc_quote& dq):Quote(dq),quantity(dq.quantity),discount(dq.discount){}
    Disc_quote& operator=(const Disc_quote& dq){
        Quote::operator=(dq);
        quantity=dq.quantity;
        discount=dq.discount;
        return *this;
    }
    double net_price(size_t)const =0;
protected:
    size_t quantity=0;
    double discount=0.0;
};

class Bulk_quote:public Disc_quote{
public:
    Bulk_quote(){cout<<"Bulk_quote()"<<endl;};
    Bulk_quote(const string& name,double p,size_t qty,double disc):Disc_quote(name,p,qty,disc){
        cout<<"Bulk_quote(const string& name,double p,size_t qty,double disc)"<<endl;
    }
    Bulk_quote(const Bulk_quote& bq):Disc_quote(bq){
        cout<<"Bulk_quote(const Bulk_quote& bq)"<<endl;
    }
    Bulk_quote& operator=(const Bulk_quote& bq){
        cout<<"Bulk_quote& operator=(const Bulk_quote& bq)"<<endl;
        Disc_quote::operator=(bq);
        return *this;
    }
    ~Bulk_quote()override{
        cout<<"~Bulk_quote()"<<endl;
    }
    double net_price(size_t cnt)const override{
        if(cnt>=quantity)
            return cnt*(1-discount)*price;
        else
            return cnt*price;
    }

};
int main(){
//    15.17    Quote a("asdsad",1.2);

    Bulk_quote c("sasda",1.2,123,2.2);
    cout<<endl<<endl;
    Bulk_quote d(c);
    cout<<endl<<endl;
    c=d;
    cout<<endl<<endl;
    return 0;
}

15.27

上题加上using声明即可

15.28  15.29

#include<iostream>
#include<vector>
#include<memory>
#include"Bulk_quote.h"
using namespace std;
int main(){
    double ans1=0.0,ans2=0.0;
    vector<Quote>vec1;
    vector<shared_ptr<Quote> >vec2;

    vec1.push_back(Quote("11111-1",3.3));
    vec1.push_back(Bulk_quote("2222-2",3.3,2,0.5));

    vec2.push_back(make_shared<Quote>("11111-1",3.3));
    vec2.push_back(make_shared<Bulk_quote>("2222-2",3.3,2,0.5));
    for(int i=0;i<vec1.size();i++){
        ans1+=vec1[i].net_price(2);
        ans2+=vec2[i]->net_price(2);
    }
    cout<<ans1<<" "<<ans2<<endl;
    //13.2    9.9
    //答案不一样 因为vec1保存的全部是Quote的对象(静态类型) 也就是说Bulk_quote强行转换成了Quote
    //而vec2保存的是(动态类型) 转换的仅是指针
    return 0;
}

15.31  15.32   15.33

15.31
(a) OrQuery, AndQuery, NotQuery, WordQuery
(b) OrQuery, AndQuery, NotQuery, WordQuery
(c) OrQuery, AndQuery, WordQuery



15.32
拷贝,移动,赋值和销毁使用的都是编译器自动合成的版本

拷贝,赋值:新对象的智能指针q将指向原对象中q指向的Query_base体系下的对象
所以成员智能指针的use count +1

移动:原对象的q(智能指针)指向空nullptr,新对象指向原对象中成员q(智能指针)指向的对象
use count不变

销毁:对象成员q(智能指针)的use count -1,如果use count为0
则它指向的对象就会自动销毁



15.33
Query_base是一个纯虚类,没有自己的对象

15.34

15.34
(a)
WordQuery    三次   "fiery","bird" and "wind"
Query        三次   "fiery","bird" and "wind"

AndQuery     一次   
BinaryQuery  一次
Query        一次   &运算结果

OrQuery      一次
BinaryQuery  一次
Query        一次   |运算结果

(b)
BinaryQuery
BinaryQuery
Query 
WordQuery
Query
WordQuery
Query
WordQuery


(c)
Query::eval()
Query_base的派生类的各种eval

15.35

Query.h

#ifndef QUERY
#define QUERY

#include<string>
#include<memory>
#include"Query_base.h"
#include"WordQuery.h"
#include"QueryResult.h"
using namespace std;
class Query{
    friend operator|(const Query& l,const Query& r);
    friend operator&(const Query& l,const Query& r);
    friend operator~(const Query& obj);
public:
    Query(const string& str):q(new WordQuery(str)){}
    QueryResult eval(const TextQuery& tq)const{
        return q->eval(tq);
    }
    string rep()const{
        return q->rep();
    }
private:
    shared_ptr<Query_base>q;
};

#endif // QUERY

Query_base.h

#ifndef QUERY_BASE
#define QUERY_BASE

#include<string>
#include"QueryResult.h"
using namespace std;
class Query_base{
public:
    virtual QueryResult eval(const TextQuery&)const=0;
    virtual string rep()const =0;
    virtual ~Query_base(){};
};

#endif // QUERY_BASE

15.38

BinaryQuery a = Query("fiery") & Query("bird");
//不合法   纯虚类没有对象
AndQuery b = Query("fiery") & Query("bird");
//不合法   &操作后返回的是Query的对象  无法转换为AndQuery的对象    
OrQuery c = Query("fiery") & Query("bird");
//不合法   &操作后返回的是Query的对象  无法转换为OrQuery的对象

15.42

不会发生任何意外