前言
这些习题解答全部是自己做的以及参考答案而得出来的，可供大家参考。
定义抽象数据类型
成员函数通过一个名为this的隐式参数来调用它的对象，例：
total.isbn()可以等价为Sales_data::isbn(&total);，调用isbn函数传入了total对象的地址。
7.1.1节练习
7.1
使用2.6.1节练习的Sales_data类为1.6节（21页）的交易处理程序编写一个新版本。
答：
#include<iostream>
#include<vector>
using namespace std;
struct Sales_data {
string bookNo;
unsigned units_sold = 0;
double revenue = 0;
};
int main() {
Sales_data total;
if (cin >> total.bookNo >> total.units_sold >> total.revenue) {
Sales_data trans;
while (cin >> trans.bookNo >> trans.units_sold >> trans.revenue) {
if (total.bookNo == trans.bookNo) {
total.units_sold += trans.units_sold;
total.revenue += trans.revenue;
}
else {
cout << "书号:"<<total.bookNo << endl << "销售量:"<<total.units_sold << endl << "销售金额:"<<total.revenue << endl;
total = trans;
}
}
cout << "书号:" << total.bookNo << endl << "销售量:" << total.units_sold << endl << "销售金额:" << total.revenue << endl;
}
else {
cout << "no data?" << endl;
}
return 0;
};
7.1.2节练习
7.2
曾在2.6.2节的练习中编写了一个Sale_data的类，请问这个类添加combine和isbn成员。
答：
#include<iostream>
#include<vector>
using namespace std;
class Sales_data {
private:
string bookNo;
unsigned units_sold = 0;
double sellingprice = 0.0;
double saleprice = 0.0;
double discount = 0;
public:
string isbn() const { return bookNo; }
Sales_data& combine(const Sales_data &rus) {
units_sold += rus.units_sold;
saleprice = (rus.saleprice * rus.units_sold + saleprice * units_sold);
if (sellingprice != 0)
discount = saleprice / sellingprice;
return * this;
}
};
int main() {
return 0;
};
7.3
修改7.1.1的交易处理程序，令其使用这些成员。
答：
#include<iostream>
#include<vector>
#include"Sales_data.h"
using namespace std;
int main() {
Sales_data total;
if (cin >> total) {
Sales_data trans;
while (cin >> trans) {
if (total.isbn() == trans.isbn())
total.combine(trans);
else {
cout << total << endl;
total = trans;
}
}
cout << total << endl;
}
else {
cerr << "NO data?" << endl;
return -1;
}
return 0;
};
7.4
编写一个名为Person的类，使其表示人员的姓名和住址。使用string对象
存放这些元素，接下来的练习将会不断充实这个类的其他特征。
7.5
在你的Person类中提供一些操作使其返回姓名和地址，这些函数是否应该是const的呢？解释原因。
答：以上两题
#include<iostream>
#include<vector>
using namespace std;
class Person {
private:
string person_name;
string person_address;
public:
string getName() {
return person_name;
}
string getAddress() {
return person_address;
}
};
int main() {
return 0;
};
加不加const在于是否需要常量对象。
7.1.3节练习
7.6
对于add,read,print定义自己的版本
答：
Sales_data add(const Sales_data &lhs,Sales_data &rhs){
Sales_data sum=lhs;
sum.combine(rhs);
}
std::istream &read(std::istream &is,Sales_data &item){
is>>item.bookNo>>item.units_sold>>item.sellingprice>>item.saleprice;
return is;
}
std::ostream &print(std::ostream &os,const Sales_data &item){
os<<item.isbn()<<" "<<item.units_sold<<" "<<item.Sellingprice<<" "<<item.saleprice<<" "<<item.discount;
return os;
7.7
使用这些新函数重写7.1.2节练习中的交易处理函数。
答：
#include<iostream>
#include"Sales_data.h"
using namespace std;
int main() {
cout << "请输入交易记录（ISBN 、销售量、原价、实际售价):" << endl;
Sales_data total;
if (read(cin, total)) {
Sales_data trans;
while (read(cin, trans)) {
if (total.isbn() == trans.isbn())
total = add(total, trans);
else {
print(cout, total);
cout << endl;
total = trans;
}
}
print(cout, total);
cout << endl;
}
else {
cerr << "No data?" << endl;
reutrn - 1;
}
return 0;
};
7.8
为什么read函数将其Sales_data参数定义为普通的引用，而print定义为其参数为常量引用？
答：read函数是将流读入Sales_data对象里，需要改变对象中的值，而print不需要。
7.9
对于7.1.2节中练习的代码，添加读取和打印Person对象的操作。
答：
#include<string>
#include<iostream>
using namespace std;
class Person {
private:
string name;
string address;
public:
string getName() const {
return name;
}
string getAddress() const {
return address;
}
istream& read(istream& is, Person& p) {
is >> p.name >> p.address;
return is;
}
ostream& print(ostream& os,const Person& p) {
os << p.name << p.address;
return os;
}
};
7.10
在下面这条if语句中，条件部分的作用是什么？
if(read(read(cin,data1),data2)
答：首先读取文件到data1中，然后将剩余的读到data2中
7.1.2节练习
7.11
在Sales_data中添加构造函数。
答：
#ifndef SALESITEM_H
#define SALESITEM_H
#include<iostream>
#include<string>
using namespace std;
class Sales_data {
public:
string bookNo;
unsigned units_sold = 0;
double sellingprice = 0.0;
double saleprice = 0.0;
double discount = 0;
friend std::istream& operator>>(std::istream&, Sales_data&);
friend std::ostream& operator<<(std::ostream&, const Sales_data&);
public:
string isbn() const { return bookNo; }
Sales_data& combine(const Sales_data& rus) {
units_sold += rus.units_sold;
saleprice = (rus.saleprice * rus.units_sold + saleprice * units_sold);
if (sellingprice != 0)
discount = saleprice / sellingprice;
return *this;
}
public:
Sales_data(istream& is) { is >> *this; }
Sales_data() = default;
Sales_data(const string& book) :bookNo(book) {};
Sales_data(const string& book, const unsigned num, const double sellp, const double salep) {
bookNo = book;
units_sold = num;
sellingprice = sellp;
saleprice = salep;
if (sellingprice != 0)
discount = saleprice / sellingprice;
}
};
inline istream& operator >> (istream& in, Sales_data&s)
{
in >> s.bookNo >> s.units_sold >> s.sellingprice>>s.saleprice;
if (in) {
if (s.sellingprice)
s.discount = s.saleprice / s.sellingprice;
}
return in;
}
inline ostream& operator<<(ostream& out, const Sales_data& s)
{
out << s.bookNo << "\t" << s.units_sold << "\t" << s.sellingprice << "\t" << s.saleprice << "\t" << s.discount << endl;
return out;
}
#endif
#pragma once
主函数检验：
#include"Sales_data.h"
int main() {
Sales_data data1;
Sales_data data2("978-1-121-15535-2");
Sales_data data3("978-7-121-15355", 100, 128, 109);
Sales_data data4(cin);
cout << "书籍的销售情况是：" << endl;
cout << data1 << endl << data2 << endl << data3 << endl << data4 << endl;
return 0;
};
7.12
把只接受一个istream作为参数的构造函数定义移动到类的内部。
答：
将其移动到内的内部即可
7.13
使用istream构造函数重写第229页的程序。
答：
#include"Sales_data.h"
int main() {
Sales_data total(cin);
if (cin) {
Sales_data trans(cin);
while (cin) {
if (total.isbn() == trans.isbn())
total.combine(trans);
else {
cout << total << endl;
total = trans;
}
Sales_data trans(cin);
}
cout << total << endl;
}
else {
cerr << "No data?" << endl;
return - 1;
}
return 0;
};
7.14
答：
Sales_data(const std::string &book):bookNo(book),units_sold(0),sellingprice(0),saleprice(0),discount(0){};
7.15
为你的Person类添加正确的构造函数
答：
#include<string>
#include<iostream>
using namespace std;
class Person {
private:
string name;
string address;
public:
string getName() const {
return name;
}
string getAddress() const {
return address;
}
istream& read(istream& is, Person& p) {
is >> p.name >> p.address;
return is;
}
ostream& print(ostream& os,const Person& p) {
os << p.name << p.address;
return os;
}
Person() = default;
Person(const string strName,const string strAddress) :name(strName),address(strAddress) {};
};
7.2节练习
7.16
在类的定义中对于访问说明符出现的位置和次数有限定吗？如果有，是什么限定？什么样的成员应该定义在public 说明符之后？什么样的成员应
该定义在private说明符之前？
答：
没有限定，私有的，不被类外直接访问用private可供任何访问的用public
7.17
使用class和struct有区别吗，如果有，是什么？
答：有区别，默认情况下class中防问符是private而struct是public
7.18
封装有何含义，它有什么好处？
答：更加安全
7.19
在你的Person类中，哪些public哪些private
答：属性一般private函数一般public
7.2.1节练习
7.20
友元在什么时候用？请分别列举使用友元的利弊？
答：在不破换类中访问权限又需要某个函数或者类能够访问类中。
7.21
修改你的Sales_data类使其隐藏实现的细节。你之前写的关于Sales_data操作的程序应该能继续使用。
答：
#ifndef SALESITEM_H
#define SALESITEM_H
#include<iostream>
#include<string>
using namespace std;
class Sales_data {
private:
string bookNo;
unsigned units_sold = 0;
double sellingprice = 0.0;
double saleprice = 0.0;
double discount = 0;
friend std::istream& operator>>(std::istream&, Sales_data&);
friend std::ostream& operator<<(std::ostream&, const Sales_data&);
public:
string isbn() const { return bookNo; }
Sales_data& combine(const Sales_data& rus) {
units_sold += rus.units_sold;
saleprice = (rus.saleprice * rus.units_sold + saleprice * units_sold);
if (sellingprice != 0)
discount = saleprice / sellingprice;
return *this;
}
public:
Sales_data(istream& is) { is >> *this; }
Sales_data() = default;
Sales_data(const string& book) :bookNo(book) {};
Sales_data(const string& book, const unsigned num, const double sellp, const double salep) {
bookNo = book;
units_sold = num;
sellingprice = sellp;
saleprice = salep;
if (sellingprice != 0)
discount = saleprice / sellingprice;
}
};
inline istream& operator >> (istream& in, Sales_data&s)
{
in >> s.bookNo >> s.units_sold >> s.sellingprice>>s.saleprice;
if (in) {
if (s.sellingprice)
s.discount = s.saleprice / s.sellingprice;
}
return in;
}
inline ostream& operator<<(ostream& out, const Sales_data& s)
{
out << s.bookNo << "\t" << s.units_sold << "\t" << s.sellingprice << "\t" << s.saleprice << "\t" << s.discount << endl;
return out;
}
#endif
#pragma once
7.22
修改你的Person类使其隐藏细节。
答：
#include<string>
#include<iostream>
using namespace std;
class Person {
private:
string name;
string address;
public:
string getName() const {
return name;
}
string getAddress() const {
return address;
}
istream& read(istream& is, Person& p) {
is >> p.name >> p.address;
return is;
}
ostream& print(ostream& os,const Person& p) {
os << p.name << p.address;
return os;
}
Person() = default;
Person(const string strName,const string strAddress) :name(strName),address(strAddress) {};
};
7.3.1节练习
7.23
编写你自己的Screen类
答：
#include<string>
class Screen {
public :
typedef std::string::size_type pos;
private:
pos cursor = 0;
pos height = 0;
pos width = 0;
std::string contents;
};
#pragma once
7.24
给你的Screen类添加三个构造函数，一个为默认构造函数，一个构造函数
接受宽度和高度的值，然后将contents初始化为给定数量的空白，第三个
构造函数接受宽和高的值以及一个字符，该字符作为初始化之间的内容。
答：
#include<string>
class Screen {
public :
typedef std::string::size_type pos;
private:
pos cursor = 0;
pos height = 0;
pos width = 0;
std::string contents;
public:
Screen() = default;
Screen(const unsigned _height, const unsigned _width, const int num) :height(_height), width(_width), contents(_height*_width,' ') {};
Screen(const unsigned _height, const unsigned _width, const char ch) :height(_height), width(_width), contents(_height* _width,ch) {};
};
#pragma once
7.25
Screen能安全依赖于拷贝和赋值操作的默认版本吗？如果能，为什么？
答：一般内置类型可以依赖，而指针类型则不适合
7.26
将Sales_data::avg_price定义成内联函数
答：
inline double Sales_data::avg_price() const
{
if (units_sold)
return saleprice / units_sold;
else
return 0;
}
7.27节练习
7.27
给你自己的Screen类添加move,set,display函数，通过执行下面的代码检验你的类是否正确。
Screen myScreen(5,5,'x');
myScreen.move(4,0).set('#').display(cout);
cout<<"\n";
myScreen.display(cout);
cout<<"\n";
答：
#include<string>
class Screen {
public :
typedef std::string::size_type pos;
private:
pos cursor = 0;
pos height = 0;
pos width = 0;
std::string contents;
public:
Screen() = default;
Screen(const unsigned _height, const unsigned _width, const int num) :height(_height), width(_width), contents(_height*_width,' ') {};
Screen(const unsigned _height, const unsigned _width, const char ch) :height(_height), width(_width), contents(_height* _width,ch) {};
Screen& move(pos r, pos c);
Screen& set(const char ch);
Screen& display(std::ostream& os) {
do_display(os);
return *this;
}
const Screen& display(std::ostream& os)const {
do_display(os);
return *this;
}
void do_display(std::ostream& os) const{
os << contents;
}
};
inline Screen& Screen::move(pos r, pos c) {
unsigned num = r * width;
cursor = num + c;
return *this;
}
inline Screen& Screen::set(const char ch) {
contents[cursor] = ch;
return *this;
}
#pragma once
7.28，7.29
如果move,set和display函数返回Screen，则在上一个练习中会发生什么。
答：不是返回引用则没有真正改变原来的对象，返回的是对象的副本。
7.30
通过this指针使用成员的做法虽然合理，但是有点多余，讨论显示地使用指针访问成员的优缺点。
答：
优点：明显，缺点:多余
7.3.3节练习
7.31
定义一对类x和y,其中x包含一个指向y的指针，而y包含一个类型为x的对象。
答：
class y;
class x {
y* _y;
};
class y {
x _x;
};
友元再探
如果一个类成为了一个类的友元类，则友元类的任何成员函数可以访问此类所有成员。友元不存在传递性。
7.3.4节练习
7.32
定义你自己的Screen和Window_mgr，其中clear是window_mgr的成员，是Screen的友元。
答：
#include<string>
#include<vector>
class Window_mgr {
public :
using ScreenIndex = std::vector<Screen>::size_type;
void clear(ScreenIndex);
private:
std::vector<Screen>screen{ Screen(24,60,' ') };
};
void Window_mgr::clear(ScreenIndex i) {
Screen& s = screen[i];
s.contents = string(s.height * s.width, ' ');
}
class Screen {
public :
typedef std::string::size_type pos;
private:
pos cursor = 0;
pos height = 0;
pos width = 0;
std::string contents;
friend void Window_mgr::clear(ScreenIndex i);
public:
Screen() = default;
Screen(const unsigned _height, const unsigned _width, const int num) :height(_height), width(_width), contents(_height*_width,' ') {};
Screen(const unsigned _height, const unsigned _width, const char ch) :height(_height), width(_width), contents(_height* _width,ch) {};
Screen move(pos r, pos c);
Screen set(const char ch);
Screen display(std::ostream& os) {
do_display(os);
return *this;
}
const Screen display(std::ostream& os)const {
do_display(os);
return *this;
}
void do_display(std::ostream& os) const{
os << contents;
}
};
inline Screen Screen::move(pos r, pos c) {
unsigned num = r * width;
cursor = num + c;
return *this;
}
inline Screen Screen::set(const char ch) {
contents[cursor] = ch;
return *this;
}
#pragma once
7.4 类的作用域
函数的返回类型通常出现在函数名之前。因此当函数名定义在类的外部时，假若返回类型也在类的外部，则必须要指明属于哪个类。
例：
class Window_mgr{
public:
ScreenIndex addscreen(const Screen&);
}
Window_mgr::ScreenIndex Window_mgr::addscreen(const Screen &s){};
7.4节练习
7.33
如果我们给Screen添加如图所示的size函数会发生什么情况？如果出现了问题，请修复他。
pos Screen::size()const{
return height*width;
}
答：
Screen::pos Screen::size()const {
return height * width;
}
7.4.1节练习
7.34
如果我们把第256页的Screen类的pos的typedef放在类的最后一行会发生什么情况？
答：
会报错，对pos的使用在它之前。
7.35
解释下面代码的含义，说明其中Type和initVal分别使用了哪个定义。
typedef string Type;
Type initVal();
class Exercise {
public:
typedef double Type;
Type setVal(Type);
Type initVal();
private:
int val;
};
Type Exercise::setVal(Type parm) {
val += parm + initVal();
return val;
}
答：
Type使用全局，而initval()使用类中
修改如下：
typedef string Type;
Type initVal();
class Exercise {
public:
typedef double Type;
Type setVal(Type);
Type initVal();
private:
int val;
};
Exercise::Type Exercise::setVal(Type parm) {
val += parm + initVal();
return val;
}
7.5.1节练习
7.36
下面的初始值是错误的，请找出问题。
struct x {
x(int i, int j) :base(i), rem(base% j) {}
int rem, base;
};
答：
在声明的时候rem更先声明，所以在构造初始值时也是rem先初始化，但是用了还未初始化的base,修改的话调换位置即可。
7.37
使用本节提供的Sales_data类，确定初始化下面的变量时分别使用了哪个构造函数，然后罗列出每个对象成员的值。
Sales_data first_item(cin);
int main() {
Sales_data next;
Sales_data("9-9999-999");
return 0;
};
答：
所用的构造函数为：
Sales_data(istream& is) { is >> *this; }
Sales_data() = default;
Sales_data(const string& book) :bookNo(book) {};
7.38
有些情况我们希望提供cin作为接受istream&参数的构造函数的默认构造函数，请声明这样的构造函数。
答：
Sales_data(istream& is=cin) { is >> *this; }
7.39
如果接受string的构造函数和接受istream&的构造函数都使用默认实参，这种行为合法吗？
答：不合法，这样由于都有参数所以编译器不知道选择哪个，有二义性。
7.5.3节练习
7.43
假定有一个名为NoDefault的类，它有一个接受int的构造函
数，但是没有默认构造函数。定义类C,C有一个NoDefault类型的成员，定义C的默认构造函数。
答：
class NoDefault {
public:
NoDefault(int n) {};
};
class c {
NoDefault noDefault;
c(int i = 0) :noDefault(i) {};
};
7.44
下面这个声明合法吗？
vector<NoDefault>vec(10)
答：不合法，没有默认初始化
7.45
如果在上一个练习中定义的vector的元素类型是c，则声明合法吗？
答：合法，此时能够执行默认参数的构造函数
7.46
下面哪些论断是不正确的？
(a)一个类必须至少提供一个构造函数
(b)默认构造函数至少是参数列表为空的构造函数
(c)如果对于类来说不存在有意义的默认值，则类不应该提供默认构造函数。
(d)如果类没有默认构造函数，则编译器将为其生成一个并把每个数据成员初始化成相应的默认值。
7.5.4节练习
7.47
说明接受string参数的Sales_data构造函数是否应该是explicit的，并解释。
答：
explicit代表屏蔽了隐式转换
7.48
假定Sales_data的构造函数不是explicit的，则下面的定义将执行什么？
string null_isbn("0-0000-000");
Sales_data item1(null_isbn);
Sales_data item2("0-0000-000");
答：由于没有explicit所以没有限制隐式转换，所以都执行了创建对象并且对其执行string参数的构造函数
7.49
对于combine函数的三种不同声明，当我们调用i.combine(s)时分别发生了什么情况？其中i是Sales_data,而s是一个string对象。
答：
(a)Sales_data &combine(Sales_data);
正确
(b)Sales_data &combine(Sales_data&);
无法编译通过，编译器用s自动创建了一个临时Sales_data对象，但是combine需要一个非常量引用对象作为参数，而这不符合。
(c)Sales_data &combine(const Sales_data&)const;
无法编译通过，由于这个函数是常量函数，无法修改对象。
7.50
确定你的Person类中是否有一些构造函数应该是explicit的。
答：explicit是为了避免一些隐式转换。
7.51
vector将其单参数的构造函数定义成explicit的，而string不是，原因何在？
答：主要看隐式转换的语义距离的远近来决定是否需要explicit
7.5.5节练习
7.52
使用2.6.1(64p)的Sales_data类，解释下面的初始化过程，如果存在问题，尝试修改它。
Sales_data item={"978-09384",25,15.99};
答：正确，聚合类的初始值列表
7.5.6节练习
7.53
定义自己Debug
答：
class Debug {
public:constexpr Debug(bool b = true) :hw(b), io(b), other(b) {};
constexpr Debug(bool b, bool i, bool o) :hw(b), io(i), other(i) {};
constexpr bool any() { return io || hw || other };
void set_io(bool b) { io = b };
void set_hw(bool b) { hw = b; }
void set_other(bool b) { other = b; }
private:
bool hw;
bool io;
bool other;
};
7.54
Debug中以set_开头的函数应该需要被声明为constexpr吗？
答：不需要，constexpr声明的函数只能有返回语句
7.55
7.5.5节的Data类是字面值常量类吗？
答：是，其为数据成员都是字面值类型的聚合类。
7.6节练习
7.56
什么是类的静态成员？它有何优点？静态成员与普通成员有啥区别？
答：静态成员与与类相关而与任何对象都毫无关系，同时被所有对象共享。
7.57
编写你自己的Account类
答：
class Account {
public:
void calculate() { amount += amount * interestRate; };
static double rate() { return interestRate; };
static void rate(double);
private:
std::string owner;
double amount;
static double interestRate;
static double initRate();
};
7.58
下面静态成员的声明和定义有错误吗？
class Example {
public:
static double rate = 6.5;
static const int vecSize = 20;
static vector<double>vec(vecSize);
};
double Example::rate;
vector<double>Example::vec;
答：有错误，除了静态常量成员，其他静态成员都不能在类内初始化，同时在类外必须要初始化静态成员。
|