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

C++PrimerPlus第6版第15章编程练习：Tv,Remote类与异常处理
原创 已于 2023-04-21 21:48:13 修改 · 689 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++

于 2023-04-20 11:06:12 首次发布

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

运行结果：

在这里插入图片描述

C++ Primer Plus 第6版 第6章 编程练习答案
Anna_L的博客
07-30 754
1
C++ Primer Plus(第6版) 中文版 第六章编程练习
weixin_62370184的博客
03-06 992
该程序只显示这两种类别，而不进行排序。然后，该程序指出有多少个单词以元音打头，有多少个单词以辅音打头，还有多少个单词不属于这两类。为此，方法之一是，使用isalpha()来区分以字母和其他字符打头的单词，然后对于通过了isalpha()测试的单词，使用if或switch 语句来确定哪些以元音打头。8.编写一个程序，它打开一个文件文件，逐个字符地读取该文件，直到到达文件末尾，然后指出该文件中包含多少个字符。1.编写一个程序，读取键盘输入，直到遇到@符号为止，并回显输入(数字除外)，同时将大写字符。
《C++ Primer Plus》（第6版）第16章编程练习
ProgramNovice的博客
04-21 786
《C++ Primer Plus》（第6版）第16章编程练习
C++ Primer Plus 第六版 所有章节课后编程练习答案
热门推荐
xiaojimmychen的专栏
11-01 9万+
C++ Primer Plus 第六版 所有章节课后编程练习答案
C Primer Plus 第6版 编程练习——第8章
geesehoward20000的博客
07-10 782
注意，在ASCII序列中，空格字符前面的字符都是非打印字符，要特殊处理这些字符。获得用户选择的选项后，程序提示用户输入两个数字，然后执行用户刚才选择的操作。程序使用 float 类型的变量存储用户输入的数字，如果用户输入失败，则允许再次输入。实际上，标点符号也不应该统计，但是现在暂时不同考虑这么多(如果你比较在意这点，考虑使用ctype.h系列中的ispunct()函数)。6.修改程序清单8.8中的get_first()函数，让该函数返回读取的第1个非空白字符，并在一个简单的程序中测试。
C++ primer plus (第6版)第七章编程练习答案
yd_xiaocheng的博客
03-29 224
【代码】C++ primer plus 第6版第7章编程练习答案
《C++ Primer Plus》（第6版）第11章编程练习
ProgramNovice的博客
03-13 478
《C++ Primer Plus》（第6版）第11章编程练习
《C++ Primer Plus》（第6版）第6章编程练习
ProgramNovice的博客
02-28 633
《C++ Primer Plus》（第6版）第6章编程练习
C++ Primer Plus（第六版）编程练习答案 所有章节汇总
清水河C罗——Leonardo-Liu
01-14 4万+
本博客汇总了本人历时一年学完《C++ Primer Plus （第6版）》所做的所有编程练习的答案，供大家学习参考和交流。 以下附上各章节的答案详解博客地址，以及源码工程下载地址。 PS：源码下载大部分都是需要积分的，当时设置的时候好像有点乱，有的是1积分，有的是3积分，最难的第12章和第13章我设置的是不要积分，大家都可以下载下来自己运行一下看看结果。 第 2 章 开始学习C++： ...
C++Primer Plus第6版第14章编程练习答案
yd_xiaocheng的博客
05-23 271
结束符windows为ctal + z。
《C Primer Plus》第六版 第十一章编程练习答案
11-19
"《C Primer Plus》第六版 第十一章编程练习答案" 本资源摘要信息是关于《C Primer Plus》第六版 第十一章的编程练习答案，涵盖了多个与C语言相关的知识点。下面对这些知识点进行详细的解释和分析。 1. 输入字符串...
C++ CSP-J 2022年复赛题目
BanyeBirth的博客
11-22 337
给定正整数a和b，求a^b的值。如果a^b的值超过10^9，则输出-1，否则输出a^b的值。
UVa10514 River Crossing
hlhgzx的博客
11-22 362
有一条很宽的河，中间有n（0≤n≤11）个小岛。给出两条河岸线（均为最多有100 个顶点的折线）和小岛（均为简单多边形）的信息，求一条过河的路径，使得淌水部分的总长度最短。假定只能从图中看得见的地方过河。用floyd算法即可，需要预先计算河道-河道、河道-小岛、小岛-小岛的直接淌水最小长度作为dp的初值。
中国计算机学会（CCF）推荐学术会议-A（人工智能）：ACL 2026
iaast的博客
11-24 456
大会官网：https://2026.aclweb.org/录用率：20.3%（1699/8360，2025年）时间地点：2026年7月2日-加州·美国。截稿时间：2026年1月5日。CCF推荐：A（人工智能）
【免费】中国电子学会C语言（C++）scratch python 机器人技术 三维创意 所有历年真题卷全部免费2025年09月己更新
星卯教育-信奥教练tony
11-22 298
电子学会scratch等级考试1-4级 链接：https://pan.quark.cn/s/ab0f0a0ffd6c电子学会python等级考试料1-6级链接：https://pan.quark.cn/s/88f82804f7a2电子学会机器人考级1-6级链接：https://pan.quark.cn/s/4479f423f2ed电子学会C++语言考级1-8级链接：https://pan.quark.cn/s/61d890a7d94e电子学会三维创意设计链接：https://pan.quark.cn/s/6
SystemC：sc_spawn
数字IC那些事儿的博客
11-24 72
下面给你 最清晰、最系统 的 讲解，包含概念、用法、典型例子、同步方式以及为什么它比 SC_THREAD 更强。 是 SystemC 动态创建进程（process）的机制，可在 运行时 创建线程或方法进程。普通 SystemC 写法：是 静态创建进程（在 elaboration 阶段创建）。但 可以在程序运行中创建进程：这是 动态进程（dynamic process）。类似于操作系统的： 动态创建线程Verilog 的 对应线程函数：函数：可以：你可以指定：它是 METHOD 还是 THREAD初始敏感
C++在量化交易中的应用
最新发布
2509_93946429的博客
11-25 245
但当你需要在纳秒的世界里与全球的交易者竞争时，它所提供的极致性能、底层控制力和可预测性，是其他工具难以替代的。例如，一个处理10000只股票的策略，与其创建10000个包含价格、成交量、指标的Stock对象，不如设计成几个大的并行数组：，。零成本抽象：这是C++设计的核心理念之一。直接内存操作：C++的指针和手动内存管理，在大多数领域被认为是“危险的”，但在量化领域却是“精准的武器”。对于海量的、高速涌入的行情数据（Tick Data），直接在一块连续的内存上进行操作，其效率是带GC的语言无法比拟的。
C++在系统中的编译优化
2509_93942966的博客
11-25 228
我在网络模块里就遇到过典型案例：某个数据包处理函数被频繁调用，由于分散在不同编译单元，传统模式下始终无法内联。原理其实很直观：先编译带插桩的程序，用典型工作负载训练，编译器根据真实执行路径重新调整代码布局。后来我把-O2换成-O3的瞬间，性能直接飙涨18%，这让我重新审视编译器这把双刃剑——用好了是火箭推进器，用不好就是性能杀手。编译器优化就像在跟编译器对话，需要理解它的思维模式。建议大家在发布构建中至少开启LTO，对性能敏感模块尝试PGO，记住编译器再智能也看不透你的业务逻辑，必要的提示永远不嫌多。
C异步流处理
2509_93945939的博客
11-25 224
在C 8.0之前，要用异步处理集合，基本得靠Task<IEnumerable<T>>这类组合，但这就得等整个集合准备好才能返回，效率低还占资源。举个例子，假如要从一个远程API分页拉取用户行为记录，用老方法可能得先阻塞线程等所有页数据下载完，而异步流可以逐页 yield return，用户看到第一屏结果时，后台还在默默抓后续数据。改成IAsyncEnumerable后，用Channel做中间队列，消费者通过异步流按需拉取，内存占用直接降了七成。调试异步流时容易踩坑，因为堆栈跟踪可能被拆得支离破碎。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

UestcXiye

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

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

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

打赏作者

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

抵扣说明：

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

余额充值