《C++ Primer Plus》（第6版）第15章编程练习

已于 2023-04-21 21:48:13 修改
阅读量618 收藏
点赞数
分类专栏： C++ Primer Plus 文章标签： c++
于 2023-04-20 11:06:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ProgramNovice/article/details/130261881
版权

《C++ Primer Plus》（第6版）第15章编程练习

《C++ Primer Plus》（第6版）第15章编程练习

1. Tv和Remote类

对Tv和Remote类做如下修改：

a. 让它们互为友元；
b. 在Remote类中添加一个状态变量成员，该成员描述遥控器是处于常规模式还是互动模式；
c. 在Remote中添加一个显示模式的方法；
d. 在Tv类中添加一个对Remote中新成员进行切换的方法，该方法应仅当TV处于打开状态时才能运行。

编写一个小程序来测试这些新特性。

程序：

tv.h：

#ifndef TV_H
#define TV_H

class Remote; // forward declaration

class Tv
{
private:
    int state;      // on or off
    int volume;     // assumed to be digitized
    int maxchannel; // maximum number of channels
    int channel;    // current channel setting
    int mode;       // broadcast or cable
    int input;      // TV or DVD

public:
    friend class Remote; // Remote can access Tv private parts
    enum
    {
        On,
        Off
    };
    enum
    {
        MinVal,
        MaxVal = 20
    };
    enum
    {
        Antenna,
        Cable
    };
    enum
    {
        TV,
        DVD
    };
    Tv(int s = Off, int mc = 125) : state(s), volume(5), maxchannel(mc), channel(2), mode(Cable), input(TV) {}
    void onoff() { state = (state == On) ? Off : On; }
    bool inon() const { return state == On; }
    bool volup();
    bool voldown();
    void chanup();
    void chandown();
    void set_mode() { mode = (mode == Antenna) ? Cable : Antenna; }
    void set_input() { input = (input == TV) ? DVD : TV; }
    void settings() const; // display all settings
    void set_rmode(Remote &r);
};

class Remote
{
private:
    int mode;  // control TV or DVD
    int rmode; // control Regular or Interact

public:
    friend class Tv;
    enum
    {
        Regular,
        Interact
    };
    Remote(int m = Tv::TV, int r = Regular) : mode(m), rmode(r) {}
    bool volup(Tv &t) { return t.volup(); }
    bool voldown(Tv &t) { return t.voldown(); }
    void onoff(Tv &t) { t.onoff(); }
    void chanup(Tv &t) { t.chanup(); }
    void chandown(Tv &t) { t.chandown(); }
    void set_chan(Tv &t, int c) { t.channel = c; }
    void set_mode(Tv &t) { t.set_mode(); }
    void set_input(Tv &t) { t.set_input(); }
    void show_rmode() const;
};

inline void Tv::set_rmode(Remote &r)
{
    using std::cout;

    if (state == On)
        r.rmode = (r.rmode == Remote::Regular) ? Remote::Interact : Remote::Regular;
    else
        cout << "The tv is off, please turn it on first.\n";
}

#endif

tv.cpp：

#include <iostream>
#include "tv.h"

bool Tv::volup()
{
    if (volume < MaxVal)
    {
        volume++;
        return true;
    }
    else
        return false;
}

bool Tv::voldown()
{
    if (volume > MinVal)
    {
        volume--;
        return true;
    }
    else
        return false;
}

void Tv::chanup()
{
    if (channel < maxchannel)
        channel++;
    else
        channel = 1;
}

void Tv::chandown()
{
    if (channel > 1)
        channel--;
    else
        channel = maxchannel;
}

void Tv::settings() const
{
    using std::cout;
    using std::endl;

    cout << "TV is " << (state == Off ? "Off" : "On") << endl;
    if (state == On)
    {
        cout << "Volume setting = " << volume << endl;
        cout << "Channel setting = " << channel << endl;
        cout << "Mode = " << (mode == Antenna ? "antenna" : "cable") << endl;
        cout << "Input = " << (input == TV ? "TV" : "DVD") << endl;
    }
}

void Remote::show_rmode() const
{
    using std::cout;
    using std::endl;

    cout << "Remote mode = " << (rmode == Regular ? "Regular" : "Interact") << endl;
}

use_tv.cpp：

// use_tv.cpp -- using the Tv and Remote classes
#include <iostream>
#include "tv.h"

int main()
{
    using std::cout;

    Tv s42;
    Remote grey;
    cout << "Initial settings for 42\" TV:\n";
    s42.settings();
    s42.onoff();
    s42.chanup();
    grey.show_rmode();
    s42.set_rmode(grey);
    cout << "\nAdjusted settings for 42\" TV:\n";
    s42.settings();
    s42.set_rmode(grey);
    grey.set_chan(s42, 10);
    grey.volup(s42);
    grey.volup(s42);
    cout << "\n42\" settings after using remote:\n";
    s42.settings();
    s42.set_rmode(grey);

    Tv s58(Tv::On);
    s58.set_mode();
    grey.set_chan(s58, 28);
    cout << "\n58\" settings:\n";
    s58.settings();
    grey.show_rmode();
    s58.set_rmode(grey);

    system("pause");
    return 0;
}

运行结果：

在这里插入图片描述

2. 异常

修改程序清单15.11，使两种异常类型都是从头文件提供的logic_error类派生出来的类。让每个what()方法都报告函数名和问题的性质。异常对象不用存储错误的参数值，而只需支持what()方法。

程序：

exc_mean.h：

#include <iostream>
#include <stdexcept>
#include <string>

class bad_hmean : public std::logic_error
{
public:
    double v1;
    double v2;
    bad_hmean(double a = 0, double b = 0, const std::string &s = "hmean() argument should not bo negative to each other.\n") : std::logic_error(s), v1(a), v2(b){};
};

class bad_gmean : public std::logic_error
{
public:
    double v1;
    double v2;
    bad_gmean(double a = 0, double b = 0, const std::string &s = "gmean() argument should be >= 0.\n") : std::logic_error(s), v1(a), v2(b){};
};

error.cpp：

#include <iostream>
#include <cmath>
#include "exc_mean.h"

double hmean(double a, double b);
double gmean(double a, double b);

int main()
{
    using std::cin;
    using std::cout;
    using std::endl;

    double x, y, z;

    cout << "Enter two numbers: ";
    while (cin >> x >> y)
    {
        try
        {
            z = hmean(x, y);
            cout << "Harmonic mean of " << x << " and " << y
                 << " is " << z << endl;
            cout << "Geometric mean of " << x << " and " << y
                 << " is " << gmean(x, y) << endl;
            cout << "Enter next set of numbers <q to quit>:";
        }
        catch (bad_hmean &h)
        {
            cout << h.what();
            cout << "Values used: " << h.v1 << ", " << h.v2 << endl;
            cout << "Try again.\n";
            continue;
        }
        catch (bad_gmean &g)
        {
            cout << g.what();
            cout << "Values used: " << g.v1 << ", " << g.v2 << endl;
            cout << "Sorry, you don't get to play any more." << endl;
            break;
        }
    }
    cout << "Bye!" << endl;

    system("pause");
    return 0;
}

double hmean(double a, double b)
{
    if (a == -b)
        throw bad_hmean(a, b);
    return 2.0 * a * b / (a + b);
}

double gmean(double a, double b)
{
    if (a < 0 || b < 0)
        throw bad_gmean(a, b);
    return std::sqrt(a * b);
}

运行结果：

在这里插入图片描述

3. 派生异常

这个练习与编程练习2相同，但异常类是从一个这样的基类派生而来的：它是从logic_error派生而来的，并存储两个参数值。异常类应该有一个这样的方法：报告这些值以及函数名。程序使用一个catch块来捕获基类异常，其中任何一种从该基类异常派生而来的异常都将导致循环结束。

程序：

exc_mean.h：

// exc_mean.h  -- exception classes for hmean(), gmean()
#include <iostream>
#include <stdexcept>
#include <string>
using namespace std;

class bad : public logic_error
{
public:
    double v1;
    double v2;
    string name;
    explicit bad(double a = 0, double b = 0, const string &n = "hmean", const string &s = "Error in hmean()\n")
        : v1(a), v2(b), name(n), logic_error(s) {}
    void mesg();
    virtual ~bad() throw() {}
};

class bad_hmean : public bad
{
public:
    explicit bad_hmean(double a = 0, double b = 0, const string &n = "hmean", const string &s = "Error in hmean()\n")
        : bad(a, b, n, s) {}
    void mesg() { cout << "hmean(" << v1 << ", " << v2 << "): "
                       << "invalid arguments: a = -b.\n"; }
    virtual ~bad_hmean() throw() {}
};

class bad_gmean : public bad
{
private:
    string name;

public:
    explicit bad_gmean(double a = 0, double b = 0, const string &n = "gmean", const string &s = "Error in gmean()\n")
        : bad(a, b, n, s) {}
    string mesg() { return "gmean() arguments should be >= 0\n"; }
    virtual ~bad_gmean() throw() {}
};

error.cpp：

// error.cpp
#include <iostream>
#include <cmath> // or math.h, unix users may need -lm flag
#include "exc_mean.h"

// function prototypes
double hmean(double a, double b);
double gmean(double a, double b);

int main()
{
    using std::cin;
    using std::cout;
    using std::endl;

    double x, y, z;

    cout << "Enter two numbers: ";
    while (cin >> x >> y)
    {
        try
        { // start of try block
            z = hmean(x, y);
            cout << "Harmonic mean of " << x << " and " << y
                 << " is " << z << endl;
            cout << "Geometric mean of " << x << " and " << y
                 << " is " << gmean(x, y) << endl;
            cout << "Enter next set of numbers <q to quit>: ";
        }                     // end of try block
        catch (bad_hmean &bg) // start of catch block
        {
            cout << bg.what();
            cout << "Error message:\n";
            bg.mesg();
            cout << "Try again.\n";
            continue;
        }
        catch (bad_gmean &hg)
        {
            cout << hg.what();
            cout << "Error message:\n"
                 << hg.mesg();
            cout << "Values used: " << hg.v1 << " , " << hg.v2 << endl;
            cout << "Sorry, you don't get to play any more.\n";
            break;
        } // end of catch block
    }
    cout << "Bye!\n";

    system("pause");
    return 0;
}

double hmean(double a, double b)
{
    if (a == -b)
        throw bad_hmean(a, b);
    return 2.0 * a * b / (a + b);
}

double gmean(double a, double b)
{
    if (a < 0 || b < 0)
        throw bad_gmean(a, b);
    return std::sqrt(a * b);
}

运行结果：

在这里插入图片描述

4. RTTI

程序清单15.16在每个try后面都使用两个catch块，以确保nbad_index异常导致方法label_val()被调用。请修改该程序，在每个try块后面只使用一个catch块，并使用RTTI来确保合适时调用label_val()。

程序：

sales.h：

#include <stdexcept>
#include <string>
using std::string;

class Sales
{
public:
    enum
    {
        MONTHS = 12
    };
    class bad_index : public std::logic_error
    {
    private:
        int bi; // bad index value
    public:
        explicit bad_index(int ix, const string &s = "Index error in Sales object\n");
        int bi_val() const { return bi; }
        virtual ~bad_index() throw() {}
    };
    explicit Sales(int yy = 0);
    Sales(int yy, const double *gr, int n);
    virtual ~Sales() {}
    int Year() const { return year; }
    virtual double operator[](int i) const;
    virtual double &operator[](int i);

private:
    double gross[MONTHS];
    int year;
};

class LabeledSales : public Sales
{
private:
    string label;

public:
    class nbad_index : public Sales::bad_index
    {
    private:
        string lbl;

    public:
        nbad_index(const string &lb, int ix, const string &s = "Index error in LabeledSales object\n");
        const string &label_val() const { return lbl; }
        virtual ~nbad_index() throw() {}
    };
    explicit LabeledSales(const string &lb = "none", int yy = 0);
    LabeledSales(const string &lb, int yy, const double *gr, int n);
    virtual ~LabeledSales() {}
    const string &Label() const { return label; }
    virtual double operator[](int i) const;
    virtual double &operator[](int i);
};

sales.cpp：

#include "sales.h"

Sales::bad_index::bad_index(int ix, const string &s) : std::logic_error(s)
{
    bi = ix;
}

Sales::Sales(int yy) : year(yy)
{
    for (int i = 0; i < MONTHS; i++)
        gross[i] = 0;
}

Sales::Sales(int yy, const double *gr, int n) : year(yy)
{
    int i;
    int lim = (n < MONTHS) ? n : MONTHS;
    for (i = 0; i < lim; i++)
        gross[i] = gr[i];
    for (; i < MONTHS; i++)
        gross[i] = 0;
}

double Sales::operator[](int i) const
{
    if (i < 0 || i >= MONTHS)
        throw bad_index(i);
    return gross[i];
}

double &Sales::operator[](int i)
{
    if (i < 0 || i >= MONTHS)
        throw bad_index(i);
    return gross[i];
}

LabeledSales::nbad_index::nbad_index(const string &lb, int ix, const string &s) : Sales::bad_index(ix, s)
{
    lbl = lb;
}

LabeledSales::LabeledSales(const string &lb, int yy) : Sales(yy)
{
    label = lb;
}

LabeledSales::LabeledSales(const string &lb, int yy, const double *gr, int n) : Sales(yy, gr, n)
{
    label = lb;
}

double LabeledSales::operator[](int i) const
{
    if (i < 0 || i >= MONTHS)
        throw nbad_index(Label(), i);
    return Sales::operator[](i);
}

double &LabeledSales::operator[](int i)
{
    if (i < 0 || i >= MONTHS)
        throw nbad_index(Label(), i);
    return Sales::operator[](i);
}

use_sales.cpp：

// use_sales.cpp  -- nested exceptions
#include <iostream>
#include "sales.h"
using namespace std;

int main()
{
    double vals1[12] = {1220, 1100, 1122, 2212, 1232, 2334, 2884, 2393, 3302, 2922, 3002, 3544};
    double vals2[12] = {12, 11, 22, 21, 32, 34, 28, 29, 33, 29, 32, 35};
    Sales sales1(2011, vals1, 12);
    LabeledSales sales2("Blogstar", 2012, vals2, 12);
    LabeledSales::nbad_index *nb;
    Sales::bad_index *b;

    cout << "First try block:\n";
    try
    {
        int i;
        cout << "Year = " << sales1.Year() << endl;
        for (i = 0; i < 12; ++i)
        {

            cout << sales1[i] << ' ';
            if (i % 6 == 5)
                cout << endl;
        }
        cout << "Year = " << sales2.Year() << endl;
        cout << "Label = " << sales2.Label() << endl;
        for (i = 0; i <= 12; ++i)
        {

            cout << sales2[i] << ' ';
            if (i % 6 == 5)
                cout << endl;
        }
        cout << "End of try block 1.\n";
    }
    catch (logic_error &bad)
    {
        cout << bad.what();
        if (nb = dynamic_cast<LabeledSales::nbad_index *>(&bad))
        {
            cout << "Company: " << nb->label_val() << endl;
            cout << "bad index: " << nb->bi_val() << endl;
        }
        else if (b = dynamic_cast<Sales::bad_index *>(&bad))
            cout << "bad index: " << b->bi_val() << endl;
    }
    cout << "\nNext try block:\n";
    try
    {
        sales2[2] = 37.5;
        sales1[20] = 23345;
        cout << "End of try block 2.\n";
    }
    catch (logic_error &bad)
    {
        cout << bad.what();
        if (nb = dynamic_cast<LabeledSales::nbad_index *>(&bad))
        {
            cout << "Company: " << nb->label_val() << endl;
            cout << "bad index: " << nb->bi_val() << endl;
        }
        else if (b = dynamic_cast<Sales::bad_index *>(&bad))
            cout << "bad index: " << b->bi_val() << endl;
    }
    cout << "done\n";

    system("pause");
    return 0;
}

运行结果：

在这里插入图片描述

UestcXiye
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
《c++ primer plus 第五版》编程练习答案
03-23
《C++ Primer Plus 第五版》是一本深受程序员喜爱的C++学习书籍，它深入浅出地介绍了C++编程语言的基础知识和高级特性。这本书的编程练习是学习过程中的重要环节，通过解决这些练习，读者可以巩固理论知识，提高实际...
C++Primer（第4版）-课后习题答案.pdf
11-01
《C++ Primer（第4版）》是一本深入学习C++编程语言的经典教材，其课后习题答案提供了丰富的实践练习和问题解析，帮助读者巩固并深化对C++语法、概念的理解。以下将针对各章节的主要知识点进行详细阐述： 1. 第一章...
C Primer Plus 第六版中文版勘误表
10-22
【C Primer Plus 第六版中文版勘误表】 在学习C语言的过程中，使用正确的教材是非常重要的，而《C Primer Plus》第六版是一本备受推崇的教程。然而，任何书籍都可能存在印刷错误，为了确保读者获取准确的信息，出版...
C语言：文件（写入，读取）
2301_80311224的博客
08-21 685
区分二者很简单，我们可以选定一个文件，以记事本打开，如果其中的内容你能看懂，他就是一个文本文件，相反，如果是一堆你看不懂的东西，那他就是二进制文件。w+：既能读又能写，若文件不存在则创建，若文件存在则清空。若成功打开会返回文件指针，若失败则返回NULL。w：写入，若文件不存在则创建，若文件存在则清空。r：只读取，若文件不存在，fopen调用失败。a+：既能读又能写，若文件不存在则创建。在打开和关闭文件中，进行操作文件。a：追加写入，若文件不存在则创建。r+：既能读又能写，文件必须存在。
QT C++上位机软件开发，相比较C#上位机软件开发，有哪些特点和区别
曾经的我也很优秀，现在的我一无所有。
08-20 427
在开发上位机软件时，选择使用Qt C++还是C#取决于多种因素，包括项目需求、团队技能、开发速度等因素。
c++ error: ‘this’ was not captured for this lambda function
xiaozhi
08-20 374
c++ error: ‘this’ was not captured for this lambda function
C++ 基础
weixin_51883798的博客
08-22 265
MyClass&& other:这是一个右值引用参数，指向要移动的对象。右值引用允许我们访问即将被销毁的对象，从中“窃取”资源。该关键字表示移动构造函数不会抛出异常。这是一个优化提示，告诉编译器在需要时可以安全地使用移动构造函数。这是C++11标准中新引入的一个特性，旨在提高性能，尤其是在涉及临时对象和资源管理时。特殊的成员函数，允许将一个对象的状态转移到另一个新创建的对象中，不需要进行复制。
Java以JNI形式调用C/C++动态库实现回调方法
liuyuxuan2388的博客
08-24 338
由于我需要做的是在DLL中的一个线程里改变某个java对象的值,所以,还必须获取那个java对象的jobject指针.同 JNIEnv 指针一样,jobject指针也不能在多个线程中共享. 就是说,不能直接在保存一个线程中的jobject指针到全局变量中,然后在另外一个线程中使用它.幸运的是,可以用。然而JNI文档上说，JNI接口的指针JNIEnv*不能在c++的线程间共享，在我的程序中，如果接收线程试图调用java对象的方法，程序会突然退出。Java生成.h头文件（以Test.java为例）
c语言用if语句制作点单程序
2301_81968528的博客
08-20 189
printf("数字1代表喝咖啡，数字2代表喝雪碧:");这里的点单程序是用户输入相应的数字自动出来相应的饮品。puts("您要喝的是咖啡");puts("您要喝雪碧");比如输入1是咖啡，输入2是雪碧。c语言里面，if语句的语法是。
c++11（三）
qhy850716的博客
08-21 1091
function<返回类型(参数包类型)> fc;
【C++指南】深入剖析：C++中的引用
2302_78391795的博客
08-19 2074
引用在C++中扮演着重要的角色。它允许我们为已存在的变量创建一个别名，通过这个别名，我们可以直接访问和操作原始变量。这一特性不仅简化了代码，提高了代码的可读性，还带来了性能上的优势。因为引用本身不是一种数据类型，不占用存储单元，所以使用引用可以减少数据的复制，降低内存占用，提高程序的执行效率。 然而，尽管引用在C++编程中如此重要，但初学者往往对其感到困惑。他们可能不清楚何时使用引用，如何正确地使用引用，以及引用与指针之间的区别和联系。因此，深入学习和理解C++中的引用变得尤为重要。
初识顺序表---C语言
weixin_74202161的博客
08-23 299
顺序表是一种以数组为基础的结构，对数组进行封装，实现常用的增删改查等操作的。//销毁。
C++中隐藏和重写的区别
m0_63764282的博客
08-20 623
在继承过程中，子类（派生类）的同名函数屏蔽了基类（父类）中的同名函数。这种机制使得通过子类对象调用该函数时，默认调用的是子类的函数，而基类的同名函数被隐藏。隐藏的目的并非出于设计上的直接需求，而是继承关系带来的自然结果，但可能会导致一些非预期的行为。在继承关系中，子类重新定义了基类中的虚函数。这要求函数名、参数列表和返回类型都与基类中的虚函数完全一致，只有函数体（实现）不同。重写的目的是为了实现多态性，即允许通过基类指针或引用来调用子类的函数。
贪心算法3
2301_79555067的博客
08-14 1050
贪心算法leetcode题解包括：134. 加油站 135. 分发糖果 860.柠檬水找零 406.根据身高重建队列
Dijkstra(c++)
最新发布
weixin_73378557的博客
08-24 441
迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是从起始点开始，采用贪心算法的策略，每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止。同时dijkstra算法主要用于解决单源最短路问题（边权为正数），其可以分为两种版本，两种版本各有用处，并不存在好坏之分，接下来我们用n代表点的数量，用m代表边的数量。
Openvino2024.3版部署YOLO （C++）
恐龙先生的博客
08-22 470
到这一步openvino的环境算是全部装好了，前提是上面的安装都没有报错，验证的话先使用pycharm进行转换，pt->onnx->xml/bin。cmd,进入虚拟环境->D盘openvino_2024文件夹中，运行setupvars.bat，再把下面的都运行，可能需要先更新一下你的pip。下载好后解压出来，放C盘D盘都一样，我放在D盘了，这个文件夹名字有点长，自己修改成openvino_2024。运行效果图就不展示了，代码没有问题的，如果报错了，肯定是你自己的细节问题，不懂的下面评论。
C语言01 每日一练01
小蜗的房子
08-24 677
C语言01 每日一练01
《重生到现代之从零开始的C语言生活》—— 指针3
yttandb的博客
08-20 725
《重生到现代之从零开始的C语言生活》—— 指针3
《C++ Primer Plus（第6版）中文版》编程练习答案汇总（第1-5章）
"《C++ Primer Plus（第6版）中文版》编程练习答案第1-5章" 本资源是《C++ Primer Plus（第6版）中文版》编程练习答案的集合，涵盖了第1-5章的编程练习答案。这些练习题是学习C++编程语言的基础，涵盖了基本语法、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

UestcXiye

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值