C++ Primer Plus第十四章复习题

1、以A栏的类为基类时，B栏的类采用公有派生还是私有派生更合适？

         A                                          B
——————————————————————————————————————————————————————————————————————————
class Bear                                    class PolarBear
class Kitchen                                 class Home
class Person                                  class Programmer
class Person                                  class HorseAndJockey
class Person,class Automobile                 class Driver

如图所示： 

2、假设有下面的定义；

class Frabjous
{
private:
    char fab[20];
public:
    Frabjous(const char * s = "C++") : fab(s){}
    virtual void tell() { cout << fab;}
};

class Gloam
{
private:
    int glip;
    Frabjous fb;
public:
    Gloam(int g = 0, const char * s = "C++");
    Gloam(int g, const Frabjous & f);
    void tell();
};

 假设Gloam版本的tell()应显示glip和fb的值，请为这3个Gloam方法提供定义。

答：
 

Gloam::Gloam(int g,const char * s):glip(g), fb(s){}
Gloam::Gloam(int g,const Frabjous & fr) : glip(g)， fb(fr){}
void Gloam::tell()
{
    fb.tell();
    cout<< glip<< endl;
}

3、假设有下面的定义：

class Frabjous
{
private:
    char fab[20];
public:
    Frabjous(const char * s = "C++") : fab(s){}
    virtual void tell(){ cout << fab;}
};
class Gloam: private Frabjous
{
private:
    int glip;
public:
    Gloam(int g = 0, const char *s = "C++");
    Gloam(int g, const Frabjous & f);
    void tell();
}

 假设Gloam版本的tell（）应显示glip和fab的值，请为这3个Gloam方法提供定义。

答：

Gloam::Gloam (int g, const char * s):glip(g), Frabjous(s){}
Gloam::Gloam (int g, const Frabjous & fr):glip(g), Frabjous(fr) {}
void Gloam ::tell()
{
    Frabjous::tell();
    cout << glip << endl;
}

4、假设有下面的定义，它是基于所示程序中的Stack模板和程序中的Worker类的：

#ifnedf STACKTP_H_
#define STACKTP_H_
template <class Type>
class Stack
{
private:
    enum{MAX = 10};
    Type items[MAX];
    int top;
public:
    Stack();
    bool isempty();
    bool isfull();
    bool push(const Type & item);
    bool pop(Type & item);
};

template <class Type>
Stack<Type>::Stack()
{
    top = 0;
}
bool Stack<Type>::isempty()
{
    return top == 0;
}

template <class Type>
bool Stack<Type>::isfull()
{
    return top == MAX;
}

template <class Type>
bool Stack<Type>::push(const Type & item)
{
    if(top < MAX)
    {
        items[top++] = item;
        return true;
    }
    else
        return false;
}

template <class Type>
bool Stack<Type>::pop(Type & item)
{
    if(top >0)
    {
        item = items[--top];
        return true;
    }
    else
        return false;
}
#endif

 

#inndef WORKERMI_H_
#define WORKERMI_H_

#include <string>

class Worker
{
private:
    std::string fullname;
    long id;
protected:
    virtual void Data() const;
    virtual void Get();
public:
    Worker() : fullname("no one"), id(0L){}
    Worker(const std::string & s,long n) : fullname(s), id(n) {}
    virtual ~Worker() = 0;
    virtual void Set() = 0;
    virtual void Show() const = 0;
};

class Waiter : virtual public Worker
{
private:
    int panache;
protected:
    void Data() const;
    void Get();
public:
    Waiter() : Worker() , panache(0){}
    Waiter(const std::string & s,long n, int p = 0) : Worker(s,n), panache(p){}
    Waiter(const Worker & wk, int p = 0) : Worker(wk) , panache(p){}
    void Set();
    void Show() const;
}

class Singer : virtual public Worker
{
protected:
enum{other ,alto , contralto, soprano, bass, baritone, tenor};
    enum {Vtypes = 7};
    void Data() const;
    void Get();
private:
    static char *pv[Vtypes];
    int voice;
public:
    Singer() : Worker(), voice(other) {}
    Singer(const std::string & s, long n, int v = other) : Worker(s, n), voice(v){}
    Singer(const Worker & wk, int v = other) : Worker(wk), voice(v){}
    void Set();
    void Show() const;
};

class SingingWaiter: public Singer, public Waiter
{
protected:
    void Data() const;
    void Get();
public:
    SingingWaiter(){}
    SingingWaiter(const std::string & s, long n, int p = 0, int v = other): Worker(s, n),Waiter(s,n,p), Singer(s,n,v){}
    SingingWaiter(const Worker & wk, int p = 0, int v = other) : Worker(wk), Waiter(wk,p),Winger(wk,v){}
    SingingWaiter(const Singer & wt, int p = 0) : Worker(wt),Waiter(wt,p),Singer(wt){}
    void Set();
    void Show() const;
}

#endif

 

Stack<Worker *> sw;

请写出将生成的类声明。只实现类声明，不实现非内联类方法。 

答：

class Stack<Worker *>
{
private:
    enum {MAX = 10} ;
    Worker * items [MAX];
    int top;
public:
    stack();
    Boolean isempty();
    Boolean isfull();
    Boolean push(const Worker * & item);
    Boolean pop (Worker * & item) ;
};

5、使用本章中的模板定义对下面的内容进行定义：

string对象数组；
double数组栈；
指向Worker独享的指针的栈数据。

所示程序中生成了多少个模板类定义?

#include <iostream>
#include "arraytp.h"
int main(void)
{
    using std::cout;
    using std::endl;
    ArrayTP<int ,10>sums;
    ArrayTP<double , 10> aves;
    ArrayTP<ArrayTP<int ,5>,10> twodee;
    
    int i,j;
    for(i = o;i <10 ;i++)
    {
        sums[i] = 0;
        for(j = 0;j<5 ;j++)
        {
            twodee[i][j] = (i+1) * (j+1);
            sums[i] += twodee[i][j];
        }
        aves[i] = (double) sums[i] / 10;
    }
    for(i = 0;i<10 ;i++)
    {
        for(j = 0; j<5 ;j++)
        {
            cout.width(2);
            cout << twodee[i][j] << ' ';
        }
        cout << ": sum = ";
        cout.width(3);
        cout << sums[i] << ", average = " << aves[i] << endl;
    }
    cout << "Done.\n";
    return 0;
}

答：

ArrayTP<string> sa;
StackTP< ArrayTP<double> > stck_arr_db;
ArrayTP< StackTP<Worker *> > arr_stk_wpr;
程序清单14.18生成4个模板: ArrayTP<int, 10>、ArrayTP<double, 10>、ArrayTP<int, 5>和Array<ArrayTP<int, 5>,10>。

6、指出虚基类与非虚基类之间的区别。

答；
如果两条继承路线有相同的祖先，则类中将包含祖先成员的两个拷贝。将祖先类作为虚基类可以解决这种问题。