C++ Primer Plus习题及答案-第十五章

最新推荐文章于 2023-06-01 12:20:24 发布
最新推荐文章于 2023-06-01 12:20:24 发布
阅读量383 收藏
点赞数 2
分类专栏： C++ Primer Plus习题及答案 文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jianmo1993/article/details/128298458
版权

习题选自：C++ Primer Plus(第六版)
内容仅供参考，如有错误，欢迎指正 !

友元类和嵌套类

RTTI和类型转换运算符

复习题

1. 下面建立友元的尝试有什么错误？

a.

class snap {
 friend clasp;
 ...
};
class clasp { ... };

b.

class cuff {
 public:
 void snip(muff &) { ... }
 ...
};
class muff {
 friend void cuff::snip(muff &);
 ...
};

c.

class muff {
friend void cuff::snip(muff &);
...
};
class cuff {
public:
void snip(muff &) { ... }
...
};

a. friend clasp;缺少class声明，应该改为 friend class clasp;。

b. 缺少muff的前项声明，应该在第一行添加class muff。

c. cuff类声明应在muff类之前，以便编译器可以理解cuff::snip( )。同时编译器需要muff的一个前向声明，以便可以理解snip(muff &)。修改后应该为：

class muff; // forward declaration
class cuff {
    public:
    void snip(muff &) { ... }
    ...
};
class muff {
    friend void cuff::snip(muff &);
    ...
};

2. 您知道了如何建立相互类友元的方法。能够创建一种更为严格的友情关系，即类B只有部分成员是类A的友元，而类A只有部分成员是类B的友元吗？请解释原因。

不能，为了使类B部分成员是类A的友元，需要将类B的声明位于类A的前面，并且要在类A指出类B中要作为类A友元的成员。同样的使类A部分成员成为类A的友元，需要同样的要求，而这两个要求是互斥的，因此无法创建该友情关系。

3. 下面的嵌套类声明中可能存在什么问题？

class Ribs
{
 private:
 class Sauce
 {
     int soy;
     int sugar;
     public:
     Sauce(int s1, int s2) : soy(s1), sugar(s2) { }
 };
 ...
};

嵌套类Sauce中的soy和sugar都是私有的，Ribs只能通过Sauce的构造函数创建它们。

4. throw和return之间的区别何在？

假设函数f1( )调用函数f2( )。f2( )中的返回语句导致程序执行在函数f1( )中调用函数f2( )后面的一条语句。throw语句导致程序沿函数调用的当前序列回溯，直到找到直接或间接包含对f2( )的调用的try语句块为止。它可能在f1( )中、调用f1( )的函数中或其他函数中。找到这样的try语句块后，将执行下一个匹配的catch语句块，而不是函数调用后的语句。

5. 假设有一个从异常基类派生来的异常类层次结构，则应按什么样的顺序放置catch块？

应按从子孙到祖先的顺序排列catch语句块。

6. 对于本章定义的Grand、Superb和Magnificent类，假设pg为Grand *指针，并将其中某个类的对象的地址赋给了它，而ps为Superb *指针，则下面两个代码示例的行为有什么不同？

if (ps = dynamic_cast<Superb *>(pg))
ps->say(); // sample #1
if (typeid(*pg) == typeid(Superb))
(Superb *) pg)->say(); // sample #2

对于dynamic_cast<Superb *>(pg)，如果pg指向一个Superb对象或从Superb派生而来的任何类的对象，则if条件为true。具体地说，如果pg指向Magnificent对象，则if条件也为true。

对于typeid(*pg) == typeid(Superb)，仅当指向Superb对象时，if条件才为true，如果指向的是从Superb派生出来的对象，则if条件不为true。

7. static_cast运算符与dynamic_cast运算符有什么不同？

dynamic_cast运算符只允许沿类层次结构向上转换，而static_cast运算符允许向上转换和向下转换。static_cast运算符还允许枚

举类型和整型之间以及数值类型之间的转换。

编程练习

1. 对Tv和Remote类做如下修改：

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

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

tv.h:

#ifndef TV_H_
#define TV_H_

#include <iostream>

class Remote;  // forward declaration

class Tv {
    public:
    friend class Remote;
    enum { Off, On };
    enum { MinVal, MaxVal = 20 };
    enum { Antenna, Cable };
    enum { TV, DVD };

    private:
    int state;
    int volume;
    int maxchannel;
    int channel;
    int mode;
    int input;

    public:
    Tv(int s = Off, int mc = 125)
        : state(s),
    volume(5),
    maxchannel(mc),
    channel(2),
    mode(Cable),
    input(DVD) {}
    void onoff() { state = (state == On) ? Off : On; }
    bool ison() 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 show_settings() const;
    void set_remote_mode(Remote& r) const;
};

class Remote {
    public:
    friend class Tv;
    enum { Normal, Interactive };

    private:
    int mode;
    int gmode;

    public:
    Remote(int m = Tv::TV) : mode(m), gmode(Normal) {}
    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_remote_mode() const;
    void set_remote_mode();
};

inline void Remote::show_remote_mode() const {
    std::cout << (gmode == Normal ? "Normal" : "Interactive") << std::endl;
}

inline void Remote::set_remote_mode() {
    gmode = (gmode == Normal) ? Interactive : Normal;
}

#endif  // TV_H_

tv.cpp:

#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::show_settings() const {
    std::cout << "TV is " << (state == On ? "On" : "Off") << std::endl;
    if (state == On) {
        std::cout << "Volume setting = " << volume << std::endl;
        std::cout << "Channel setting = " << channel << std::endl;
        std::cout << "Mode = " << (mode == Antenna ? "Antenna" : "Cable")
            << std::endl;
        std::cout << "Input = " << (input == TV ? "TV" : "DVD") << std::endl;
    }
}

void Tv::set_remote_mode(Remote& r) const {
    if (state == On) r.set_remote_mode();
}

main.cpp:

#include <iostream>

#include "tv.h"

int main() {
    Tv t;
    t.show_settings();

    Remote r;
    r.show_remote_mode();

    r.onoff(t);
    t.show_settings();

    r.voldown(t);
    t.show_settings();

    t.set_remote_mode(r);
    r.show_remote_mode();

    return 0;
}

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

exc_mean.h:

#ifndef EXC_MEAN_H_
#define EXC_MEAN_H_

#include <stdexcept>

class bad_hmean : public std::logic_error {
    public:
    bad_hmean() : std::logic_error("hmean() invalid arguments: a = -b\n") {}
};

class bad_gmean : public std::logic_error {
    public:
    bad_gmean() : std::logic_error("gmean() arguments should be >= 0\n") {}
};

#endif  // EXC_MEAN_H_

error4.cpp:

// error4.cpp ?using exception classes
#include <cmath>  // or math.h, unix users may need -lm flag
#include <iostream>

#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& he)  // start of catch block
        {
            cout << he.what();
            cout << "Try again.\n";
            continue;
        } catch (bad_gmean& ge) {
            cout << ge.what();
            cout << "Sorry, you don't get to play any more.\n";
            break;
        }  // end of catch block
    }
    cout << "Bye!\n";
    return 0;
}

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

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

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

exc_mean.h:

#ifndef EXC_MEAN_H_
#define EXC_MEAN_H_

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

class bad_base : public std::logic_error {
    private:
    double v1;
    double v2;
    std::string fun_name;

    public:
    bad_base(double a = 0, double b = 0, std::string name = "none")
        : std::logic_error("hmean() invalid arguments: a = -b\n"),
    v1(a),
    v2(b),
    fun_name(name) {}

    void mesg() {
        std::cout << v1 << ", " << v2 << ", " << fun_name << std::endl;
    }
};

class bad_hmean : public bad_base {
    public:
    bad_hmean(double a = 0, double b = 0, std::string name = "none")
        : bad_base(a, b, name) {}
};

class bad_gmean : public bad_base {
    public:
    bad_gmean(double a = 0, double b = 0, std::string name = "none")
        : bad_base(a, b, name) {}
};

#endif  // EXC_MEAN_H_

error4.cpp:

// error4.cpp ?using exception classes
#include <cmath>  // or math.h, unix users may need -lm flag
#include <iostream>

#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& he)  // start of catch block
        {
            he.mesg();
            cout << "Try again.\n";
            continue;
        } catch (bad_gmean& ge) {
            ge.mesg();
            cout << "Sorry, you don't get to play any more.\n";
            break;
        }  // end of catch block
        catch (bad_base& ge) {
            ge.mesg();
            cout << "Sorry, you don't get to play any more.\n";
            break;
        }  // end of catch block
    }
    cout << "Bye!\n";
    return 0;
}

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

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

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

sales.h:

#ifndef SALES_H_
#define SALES_H_

// sales.h  -- exceptions and inheritance
#include <stdexcept>
#include <string>

class Sales {
    public:
    enum { MONTHS = 12 };  // could be a static const
    class bad_index : public std::logic_error {
        private:
        int bi;  // bad index value
        public:
        explicit bad_index(int ix,
                           const std::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 {
    public:
    class nbad_index : public Sales::bad_index {
        private:
        std::string lbl;

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

    private:
    std::string label;
};

#endif  // SALES_H_

sales.cpp:

// sales.cpp -- Sales implementation
#include "sales.h"
using std::string;

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 lim = (n < MONTHS) ? n : MONTHS;
    int i;
    for (i = 0; i < lim; ++i) gross[i] = gr[i];
    // for i > n and i < MONTHS
    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 <typeinfo>

#include "sales.h"

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

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

    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 (Sales::bad_index &bad) {
        cout << bad.what();
        if (typeid(bad) == typeid(LabeledSales::nbad_index)) {
            cout << "Company: " << ((LabeledSales::nbad_index &)bad).label_val()
                << endl;
        }
        cout << "bad index: " << bad.bi_val() << endl;
    }
    cout << "\nNext try block:\n";
    try {
        sales2[2] = 37.5;
        sales1[20] = 23345;
        cout << "End of try block 2.\n";
    } catch (Sales::bad_index &bad) {
        cout << bad.what();
        if (typeid(bad) == typeid(LabeledSales::nbad_index)) {
            cout << "Company: " << ((LabeledSales::nbad_index &)bad).label_val()
                << endl;
        }
        cout << "bad index: " << bad.bi_val() << endl;
    }
    cout << "done\n";
    return 0;
}
艰默
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++ Primer Plus（第六版）编程练习答案 第15章 友元、异常和其他
清水河C罗——Leonardo-Liu
12-25 1132
本章所有编程练习的工程源码可在此处下载（点击此链接下载），供大家参考交流！   1. 对Tv和Remote类做如下修改： a. 让它们互为友元； b. 在Remote类中添加一个状态变量成员，该成员描述遥控器是处于常规模式还是互动模式； c. 在Remote中添加一个显示模式的方法； d. 在Tv类中添加一个对Remote中新成员进行切换的方法，该方法应仅当TV处于打开状态时才能运行。...
C++ Primer Plus第六版编程题（第15章）
vmxhc1314的博客
02-22 399
C++ Primer Plus第六版编程题（第15章）题目程序 题目 1.对Tv和Remote类做如下修改： a. 让它们互为友元； b. 在Remote类中添加一个状态变量成员，该成员描述遥控器是处于常规模式还是互动模式； c. 在Remote中添加一个显示模式的方法； d. 在Tv类中添加一个对Remote中新成员进行切换的方法，该方法应仅当TV处于打开状态时才能运行。 编写一个小程序来测试...
C++ primer Plus（第六版）第十五章 友元、异常和其他 章节编程练习答案
是鲤鱼啊
02-11 235
1.对Tv和Remote类做如下修改： a. 让它们互为友元； b. 在Remote类中添加一个状态变量成员，该成员描述遥控器是处于常规模式还是互动模式； c. 在Remote中添加一个显示模式的方法； d. 在Tv类中添加一个对Remote中新成员进行切换的方法，该方法应仅当TV处于打开状态时才能运行。 编写一个小程序来测试这些新特性。 完成如下： ...
C++primerplus习题+答案
yj
06-01 645
部分互为友元的关系是无法建立的。为了使A拥有一个本身为类B的成员函数的友元，B的声明必须位于A的声明之前，因此需要多个前向声明以表示B是一个类，且要表示B类的多个成员方法。同样，如果B以A的一个成员函数作为友元，则在B之前也需要多个前向声明。因此，A,B的前向声明均无法实现。题目内没有使用关键字class，从而造成编译错误。声明一个友元类需要使用以下格式。
c++primer plus第十五章练习参考答案（自己写的欢迎批评并留言指正）
weixin_43227941的博客
02-15 326
注意： 凡是注释处就是解决问题的新增或修改后的代码； 思路分析： 第一题：首先两个类种声明互为友元，再在remote类中设置一int成员代表其模式，还要在Rmote类中设置相应的枚举是互动还是常规；在Tv类添加一change(Remote &remote)友元来访问Remote中的私有成员:remote.state_mode ^= 1;常用于0 1切换； 第二题：利用继承思想，在bad_hmean类应该继承logic_error，并重写what()虚函数 （我没有这样采取，正确的做法应该是这样） .
C++Primer（第4版）-课后习题答案.pdf
11-01
C++Primer（第4版）_课后习题答案
C++ primer plus 课后习题答案
03-30
这个文件是我买的资料。我看过，和C++ primer plus 这本书的课后习题非常吻合。
C++ primer plus课后编程练习题答案
04-22
C++ primer plus 答案，QT亲自运行成功，含有课后练习题，编程练习题。
C++ Primer Plus 编程练习源码工程 第15章
12-25
C++ Primer Plus 编程练习源码工程 第15章 ，这是本人自己学习书籍时写的编程练习的源码工程，供大家参考交流。
C++ Primer Plus 第6版 中文版课后代码习题答案
03-10
包括第六版的中文思维导图 课后以及代码例程代码
《C++ primer plus》第15章：友元、异常和其他（4）
weixin_40064300的博客
01-26 695
栈解退
C++ Primer Plus 第十五章 （15章） 编程题答案
shengda_mao1118的博客
08-09 759
习题1 （15.8.1） 细节上“状态成员”没有放在remote类里，切换状态成员的我放在remote里了，原理一样。 //标头.h #pragma once #ifndef INTERTV_H_ #define INTERTV_H_ #include &lt;iostream&gt; using namespace std; c...
C++ Primer Plus 第六版 第十五章课后编程练习答案
是鲤鱼啊
04-14 325
1.
C Primer Plus 第十五章 课后答案
asdgyy的博客
10-08 4352
目录   复习题 1.把下面的十进制转换为二进制： a.3        b.13        c.59        d.119 2.将下面的二进制值转换为十进制、八进制和十六进制的形式： a.00010101        b.01010101        c.01001100        d.10011101 3.对下面的表达式求值，假设每个值都为8位： a.～3   ...
C Primer Plus第十五章编程练习答案
sakura0908的博客
06-01 571
学完C语言之后，我就去阅读《C Primer Plus》这本经典的C语言书籍，对每一章的编程练习题都做了相关的解答，仅仅代表着我个人的解答思路，如有错误，请各位大佬帮忙点出！由于使用的是命令行参数常用于linux系统或者vscode，但此代码是运行于vs2022的，测试截图就不弄了。
C++ Primer Plus（第六版）第十五章课后习题
Francis_U的博客
01-08 326
C++ Primer Plus（第六版）第十五章课后习题 15.8.1 tv.h #ifndef TV_H_ #define TV_H_ class Remote; class Tv { private: int state; int volume; int maxchannel; int channel; int mode; int input; public: friend cl...
C++ Primer Plus 第十五章 课后编程练习题1-4
Tekkenwxp的博客
04-11 174
//1题//////////////////////////////////////////////////////////////////////////////////////////// //类定义 #ifndef tv_remote_hpp #define tv_remote_hpp class Remote; class Tv { public: friend class Remote;...
《C++ Primer Plus（第六版）》（32）（第十五章 友元、异常和其他 复习题答案）
肥宝的实验室
12-29 2760
15.7 复习题 1.下面建立友元的尝试有什么错误? a. class snap { friend clasp; ... }; class clasp{ ... };b. class cuff { public: void snip(muff&){..} ... }; class muff { friend void cuff::snip
C++ Primer Plus 第六版第十五章编程练习答案
biubiu_buaa的博客
05-18 818
//question1 //tv.h #ifndef TV_H #define TV_H class Remote; class Tv { private: int state; int volume; int maxchannel; int channel; int mode; int i...
c++ primer plus 习题 pdf
最新发布
11-07
"C Primer Plus 习题 PDF" 是一个面向习题的电子书，主要用于帮助学习者巩固和加强对 C 语言编程的理解和实践。 该电子书提供了大量的习题和解答，通过完成这些习题，学习者可以锻炼和巩固自己的编程技能。书中的习题既有基础的语法和编程概念的练习，也有更加复杂的编程挑战，帮助学习者逐步提升自己的编程水平。 通过习题解答，学习者可以更好地理解和掌握书中所讲解的知识点。习题解答不仅仅是给出答案，更重要的是对问题进行解析和思考，从而帮助学习者理解问题的解决方法和原理。 该电子书以 PDF 格式发布，方便学习者在线或离线学习和阅读。学习者可以根据自己的进度和需要选择适合的习题进行练习，也可以根据自己的掌握情况选择相应的难度。 总之，"C Primer Plus 习题 PDF" 是一个有助于学习者巩固和提高 C 语言编程能力的资源，通过完成其中的习题，学习者可以更好地掌握并应用 C 语言编程知识。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

艰默

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

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

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

打赏作者

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

抵扣说明：

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

余额充值