C++Primer-课后习题第十五章

最新推荐文章于 2022-09-26 19:28:11 发布
最新推荐文章于 2022-09-26 19:28:11 发布
阅读量480 收藏 4
点赞数
分类专栏： C++ Primer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Huangpengyu123/article/details/110448952
版权

本文答案,部分参考于C++ Primer 习题集

前面章节的习题答案

第一章

第二章

第三章

第四章

第五章

第六章

第七章

第八章

第九章

第十章

第十一章

第十二章

第十三章

第十四章

配套的学习资料

https://www.jianguoyun.com/p/DTK5uJgQldv8CBjKv80D

15.1

​ 在类中被声明为virtual的成员.基类都希望这种成员在派生类中重定义,除了构造函数之外.任意非static成员都可以为虚成员.

15.2

​ proteceted为受保护的访问标号.protected成员可以被该类的成员.友元和派生类成员(非友元)访问,而不可以被该类型的普通用户访问.而private成员只能被基类的成员和友元访问.派生类不能访问.

15.3

class Quote {
public:
	Quote() = default;
	Quote(const string& book, double sales_price) : bookNo(book), price(sales_price) {}
	string isbn() const { return bookNo; }
	//返回给定数量的书籍的销售总额,派生类改写并使用不同的折扣计算方法
	virtual double net_price(size_t n)const { return n * price; }
	virtual ~Quote() = default;
private:
	string bookNo;				//书籍的ISBN编号
protected:
	double price = 0.0;			//代表普通状态下不打折的价格
};
double print_total(ostream& os, const Quote& item, size_t n) {
	//根据传入item形参的对象类型调用Quote::net_price
	//或者Bulk_quote::net_price
	double ret = item.net_price(n);
	os << "ISBN: " << item.isbn() << " # sold:" << n << " total due:" << ret << endl;
	return ret;
}

15.4

(a) 错误,不能用类本身作为类的基类.

© 声明类时,不可以包含派生列表

15.5

class Bulk_quote :public Quote {
public:
	double net_price(size_t cnt) const override {
		if (cnt >= min_qty)	return cnt * (1 - discount) * price;
		else return cnt * price;
	}
private:
	size_t min_qty;
	double discount;
};

15.6

略

15.7

class Limited_quote :public Quote {
public:
	double net_price(size_t cnt) const override {
		if (cnt <= min_qty)	return cnt * (1 - discount) * price;
		else return min_qty * (1 - discount) * price + (cnt - min_qty) * price;
	}
private:
	size_t min_qty;
	double discount;
};

15.8

​ 静态类型在编译时已经确定了,它是变量声明时的类型或表达式生成的类型.而动态类型则是变量或表达式表示的内存中的对象的类型.动态类型直到运行时才能知道.

例如:

Quote *pQuote=new Bulk_quote;

​ 指针pQuote的静态类型是Quote,在编译时就已经确定了.但是它的动态类型是Bulk_quote.直到运行时才知道它指向的是基类还是派生类.如果一个变量非指针也能引用.则它的静态类型和动态类型永远一致.但基类的指针或引用可能与其动态类型不一致.

15.9

	Bulk_quote bulk;
	Quote* pQuote = &bulk;
	Quote& rQuote = bulk;
	//传递给item的如果是派生类对象,即是静态类型和动态类型不同的情况.
	double print_total(ostream & os, const Quote & item, size_t n);

15.10

​ 在要求使用基类对象的地方,可以使用派生类型的对象来代替,是静态类型和动态类型不同的经典例子.

15.11

	virtual void debug() {			//题目要加的东西
		cout << "bookNo=" << bookNo << " price=" << price << endl;
	}

	virtual void debug() {
		Quote::debug();	//bookNo变量为private,所以不能直接访问bookNo
						//只能调用基类的debug()函数来显示
		cout << "min_qty=" << min_qty << "discount=" << discount << endl;
	}

#include<iostream>
#include<string>
#include<vector>
#include <algorithm>
#include <functional>
#include<map>
using namespace std;
class Quote {
public:
	Quote() = default;
	Quote(const string& book, double sales_price) : bookNo(book), price(sales_price) {}
	string isbn() const { return bookNo; }
	//返回给定数量的书籍的销售总额,派生类改写并使用不同的折扣计算方法
	virtual double net_price(size_t n)const { return n * price; }
	virtual ~Quote() = default;
	virtual void debug() {			//题目要加的东西
		cout << "bookNo=" << bookNo << " price=" << price << endl;
	}
private:
	string bookNo;				//书籍的ISBN编号
protected:
	double price = 0.0;			//代表普通状态下不打折的价格
};
double print_total(ostream& os, const Quote& item, size_t n) {
	//根据传入item形参的对象类型调用Quote::net_price
	//或者Bulk_quote::net_price
	double ret = item.net_price(n);
	os << "ISBN: " << item.isbn() << " # sold:" << n << " total due:" << ret << endl;
	return ret;
}
class Bulk_quote :public Quote {
public:
	double net_price(size_t cnt) const override {
		if (cnt >= min_qty)	return cnt * (1 - discount) * price;
		else return cnt * price;
	}
	virtual void debug() {
		Quote::debug();	//bookNo变量为private,所以不能直接访问bookNo
						//只能调用基类的debug()函数来显示
		cout << "min_qty=" << min_qty << "discount=" << discount << endl;
	}
private:
	size_t min_qty;
	double discount;
};

class Limited_quote :public Quote {
public:
	double net_price(size_t cnt) const override {
		if (cnt <= min_qty)	return cnt * (1 - discount) * price;
		else return min_qty * (1 - discount) * price + (cnt - min_qty) * price;
	}
private:
	size_t min_qty;
	double discount;
};
int main(void) {
	Bulk_quote bulk;
	Quote* pQuote = &bulk;
	Quote& rQuote = bulk;
	//传递给item的如果是派生类对象,即是静态类型和动态类型不同的情况.
	double print_total(ostream & os, const Quote & item, size_t n);
	return 0;
}

15.12

​ override:在C++11新标准中我们可以使用override关键字来说明派生类中的虚函数,这么做的好处是在使得我们的意图更加清晰即明确地告诉编译器我们想要覆盖掉已存在的虚函数.如果定义了一个函数与基类中的名字相同但是形参列表不同.在不使用override关键字的时候这种函数定义是合法的.在使用了override关键字之后这种行为是非法的.编译器会提示出错.

​ final.如果我们将某个函数定义成final.则不允许后续的派生类来覆盖这个函数,否则会报错.

15.13

没有声明类derived是从base派生过来的

struct base {
	base(string szNm) :basename(szNm) {}
	string name() {
		return basename;
	}
	virtual void print(ostream& os) {
		os << basename;
	}
private:
	string basename;
};
struct derived :public base {
	derived(string szName, int iVal) :base(szName), mem(iVal) {}
	void print(ostream &os) override{
		base::print(os);
		os << "--" << mem;
	}
private:
	int mem;
};
int main(void) {
	string a = "Link";
	base T(a);
	ostream& os=cout;
	//T.print(cout);
	derived Test(a,9);
	Test.print(os);
	return 0;
}

15.14

(a) base

(b) de

© b

(d) b

(e) b

(f) de

15.15

class Disc_quote :public Quote {
public :
	Disc_quote(const string& book = " ", double sales_price = 0.0, size_t  qty = 0, double disc = 0.0) :
		Quote(book, sales_price), quantity(qty), discount(disc) {}
	double net_price(size_t cnt) const = 0;
protected:
	size_t quantity;
	double discount;
};
class Bulk_quote :public Disc_quote {
public:
	Bulk_quote(const string& book = "", double sales_price = 0, size_t qty = 0, double disc_rate = 0) :
		Disc_quote(book, sales_price, qty, disc_rate) {}
	double net_price(size_t cnt)const {
		if (cnt > quantity)	return cnt * (1 - discount) * price;
		else return cnt * price;
	}
};

15.16

class Limited_quote :public Disc_quote {
public:
	Limited_quote(const string& book = "", double sales_price = 0.0, size_t qty = 0, double disc_rate = 0.0) :
		Disc_quote(book, sales_price, qty, disc_rate) {}
	double net_price(size_t cnt) const override {
		if (cnt <= quantity)
			return cnt * (1 - discount) * price;
		else
			return quantity * (1 - discount) * price + (cnt - quantity) * price;
	}
private:
	size_t min_qty;
	double discount;
};

15.17

Severity Code Description Project File Line Suppression State
Error (active) E0322 object of abstract class type “Disc_quote” is not allowed: C++Primer E:\File\VS\C++Primer\Source.cpp 101

这个是我的编译器的错误.

15.18

只有d1和dd1类可以

因为只有它们是公有的继承类.

15.19

Derived_from_Private:private Priv_Derv这个类的函数不合法

1 无论派生类以什么方式继承基类,派生类的成员函数和友元都能使用派生类向基类的转换.派生类向其直接基类的类型转换对于派生类的成员和函数来说永远是可访问的

2 如果派生类继承基类的方式是公有的或者受保护的.则派生类的成员和友元可以使用派生类的类型转换.反之,如果派生类继承基类的方式是私有的.则不能使用.

15.20

-----------------占位符----------------

15.21

对b中的几何图元组织成了一个继承层次:

1 公共基类 Figure,表示几何图元:

2 类Rectangle,Circle,Sphere和Cone 分别表示 矩形,圆,球形,锥形

定义为Figure的派生类.

15.22

class Figure {
public:
	Figure(double, double);
protected:
	double xSize, ySize;
};
class Figure_2D :public Figure {
public:
	Figure_2D(double, double);
	virtual double area() = 0;			//求面积操作:纯虚函数
	virtual double pcrimeter() = 0;		//求周长操作:纯虚函数
};
class Figure_3D :public Figure {
public:
	Figure_3D(double, double, double);
	virtual double cubage() = 0;
protected:
	double zSize;
};
class Rectangle :public Figure_2D {
public:
	Rectangle(double, double);
	virtual double area();
	virtual double perimeter();
};
class Circle :public Figure_2D {
public:
	Circle(double, double);
	virtual double area();
	virtual double perimeter();
};
class Sphere :public Figure_3D {
public:
	Sphere(double, double, double);
	virtual double cubage();
};
class Cone :public Figure_3D {
public:
	Cone(double, double, double);
	virtual double cubage();
};

15.23

1 将D1类的fcn函数更改为int fcn()

2 p2->fcn(42) 这一条调用语句将会出错.

15.24

​ 作为基类使用的类应该具有虚析构函数,以保证在删除指向动态分配对象的基类指针时,根据指针实际指向的对象所属的类型运行适当的析构函数.

​ 虚析构函数可以为空.即不执行任何操作.一般而言,析构函数的主要作用是清楚本类中定义的数据成员.如果该类没有定义指针类

15.25

​ 因为Disc_quote的默认构造函数会运行Quote的默认构造函数,而Quote默认构造函数会完成成员的初始化工作

​ 如果去掉该构造函数的话.Bulk_quote的默认构造函数而无法完成Disc_quote的初始化工作.

15.26

#include<iostream>
#include<string>
#include<vector>
#include <algorithm>
#include <functional>
#include<map>
using namespace std;
class Quote {
public:
	Quote() = default;
	Quote(const string& book=" ", double sales_price=0.0) : bookNo(book), price(sales_price) {
		cout << "Quote constructor is running " << endl;
	}
	string isbn() const { return bookNo; }
	//返回给定数量的书籍的销售总额,派生类改写并使用不同的折扣计算方法
	virtual double net_price(size_t n)const { return n * price; }
	virtual ~Quote() {
		cout << "Quote destructor is running " << endl;
	}
	virtual void debug() {			//题目要加的东西
		cout << "bookNo=" << bookNo << " price=" << price << endl;
	}
	friend ostream& operator <<(ostream&, Quote&);
private:
	string bookNo;				//书籍的ISBN编号
protected:
	double price = 0.0;			//代表普通状态下不打折的价格
};
ostream& operator<<(ostream& os, Quote &e) {
	os << "\tUsing operato << (ostream&, Quote&);" << endl;
	return os;
}
double print_total(ostream& os, const Quote& item, size_t n) {
	//根据传入item形参的对象类型调用Quote::net_price
	//或者Bulk_quote::net_price
	double ret = item.net_price(n);
	os << "ISBN: " << item.isbn() << " # sold:" << n << " total due:" << ret << endl;
	return ret;
}
class Bulk_quote :public Quote {
public:
	Bulk_quote(const string& book = " ", double sales_price = 0.0, size_t qty = 0, double disc = 0.0) :
		Quote(book, sales_price), min_qty(qty), discount(disc) {
		cout << "Bulk_constructor is running " << endl;
	}
	double net_price(size_t cnt) const override {
		if (cnt > min_qty)	return cnt * (1 - discount) * price;
		else return cnt * price;
	}
	virtual void debug() override{
		Quote::debug();	//bookNo变量为private,所以不能直接访问bookNo
						//只能调用基类的debug()函数来显示
		cout << "min_qty=" << min_qty << "discount=" << discount << endl;
	}
	~Bulk_quote() {
		cout << "Bulk_quote destructor is running " << endl;
	}
private:
	size_t min_qty;
	double discount;
};
ostream& operator <<(ostream& os, Bulk_quote& bq) {
	os << "\tUsing operator<<(ostream &,Bulk_quote&)" << endl;
	return os;
}
//class Limited_quote :public Disc_quote {
//public:
//	Limited_quote(const string& book = "", double sales_price = 0.0, size_t qty = 0, double disc_rate = 0.0) :
//		Disc_quote(book, sales_price, qty, disc_rate) {}
//	double net_price(size_t cnt) const override {
//		if (cnt <= quantity)
//			return cnt * (1 - discount) * price;
//		else
//			return quantity * (1 - discount) * price + (cnt - quantity) * price;
//	}
//private:
//	size_t min_qty;
//	double discount;
//};

struct base {
	base(string szNm) :basename(szNm) {}
	string name() {
		return basename;
	}
	virtual void print(ostream& os) {
		os << basename;
	}
private:
	string basename;
};
struct derived :public base {
	derived(string szName, int iVal) :base(szName), mem(iVal) {}
	void print(ostream &os) override{
		base::print(os);
		os << "--" << mem;
	}
private:
	int mem;
};
class Disc_quote :public Quote {
public :
	Disc_quote(const string& book = " ", double sales_price = 0.0, size_t  qty = 0, double disc = 0.0) :
		Quote(book, sales_price), quantity(qty), discount(disc) {}
	double net_price(size_t cnt) const = 0;
protected:
	size_t quantity;
	double discount;
};
//class Bulk_quote :public Disc_quote {
//public:
//	Bulk_quote(const string& book = "", double sales_price = 0, size_t qty = 0, double disc_rate = 0) :
//		Disc_quote(book, sales_price, qty, disc_rate) {}
//	double net_price(size_t cnt)const {
//		if (cnt > quantity)	return cnt * (1 - discount) * price;
//		else return cnt * price;
//	}
//};
class Figure {
public:
	Figure(double, double);
protected:
	double xSize, ySize;
};
class Figure_2D :public Figure {
public:
	Figure_2D(double, double);
	virtual double area() = 0;			//求面积操作:纯虚函数
	virtual double pcrimeter() = 0;		//求周长操作:纯虚函数
};
class Figure_3D :public Figure {
public:
	Figure_3D(double, double, double);
	virtual double cubage() = 0;
protected:
	double zSize;
};
class Rectangle :public Figure_2D {
public:
	Rectangle(double, double);
	virtual double area();
	virtual double perimeter();
};
class Circle :public Figure_2D {
public:
	Circle(double, double);
	virtual double area();
	virtual double perimeter();
};
class Sphere :public Figure_3D {
public:
	Sphere(double, double, double);
	virtual double cubage();
};
class Cone :public Figure_3D {
public:
	Cone(double, double, double);
	virtual double cubage();
};
int main(void) {
	Quote base("C++ Primer", 128.0);
	Bulk_quote  bulk("Core Python Programming", 89, 5, 0.19);
	cout << base << endl;
	cout << bulk << endl;
	return 0;
}

输入和输出

Quote constructor is running
Quote constructor is running
Bulk_constructor is running
        Using operato << (ostream&, Quote&);

        Using operator<<(ostream &,Bulk_quote&)

Bulk_quote destructor is running
Quote destructor is running
Quote destructor is running

15.27

class Disc_quote :public Quote {
public :
	Disc_quote(const string& book = " ", double sales_price = 0.0, size_t  qty = 0, double disc = 0.0) :
		Quote(book, sales_price), quantity(qty), discount(disc) {}
	double net_price(size_t cnt) const = 0;
protected:
	size_t quantity;
	double discount;
};

class Bulk_quote :public Disc_quote {
public:
	/*Bulk_quote(const string& book = "", double sales_price = 0, size_t qty = 0, double disc_rate = 0) :
		Disc_quote(book, sales_price, qty, disc_rate) {}*/
	using Disc_quote::Disc_quote;
	double net_price(size_t cnt)const {
		if (cnt > quantity)	return cnt * (1 - discount) * price;
		else return cnt * price;
	}
};

15.28

#include<iostream>
#include<string>
#include<vector>
#include <algorithm>
#include <functional>
#include<map>
using namespace std;
class Quote {
public:
	Quote() = default;
	Quote(const string& book=" ", double sales_price=0.0) : bookNo(book), price(sales_price) {
		//cout << "Quote constructor is running " << endl;
	}
	string isbn() const { return bookNo; }
	//返回给定数量的书籍的销售总额,派生类改写并使用不同的折扣计算方法
	virtual double net_price(size_t n)const { return n * price; }
	virtual ~Quote() {
		//cout << "Quote destructor is running " << endl;
	}
	virtual void debug() {			//题目要加的东西
		//cout << "bookNo=" << bookNo << " price=" << price << endl;
	}
	//friend ostream& operator <<(ostream&, Quote&);
private:
	string bookNo;				//书籍的ISBN编号
protected:
	double price = 0.0;			//代表普通状态下不打折的价格
};
ostream& operator<<(ostream& os, Quote &e) {
	//os << "\tUsing operato << (ostream&, Quote&);" << endl;
	return os;
}
double print_total(ostream& os, const Quote& item, size_t n) {
	//根据传入item形参的对象类型调用Quote::net_price
	//或者Bulk_quote::net_price
	double ret = item.net_price(n);
	os << "ISBN: " << item.isbn() << " # sold:" << n << " total due:" << ret << endl;
	return ret;
}

class Bulk_quote :public Quote {
public:
	Bulk_quote(const string& book = " ", double sales_price = 0.0, size_t qty = 0, double disc = 0.0) :
		Quote(book, sales_price), min_qty(qty), discount(disc) {
		//cout << "Bulk_constructor is running " << endl;
	}
	double net_price(size_t cnt) const override {
		if (cnt > min_qty)	return cnt * (1 - discount) * price;
		else return cnt * price;
	}
	virtual void debug() override{
		Quote::debug();	//bookNo变量为private,所以不能直接访问bookNo
						//只能调用基类的debug()函数来显示
		//cout << "min_qty=" << min_qty << "discount=" << discount << endl;
	}
	~Bulk_quote() {
		//cout << "Bulk_quote destructor is running " << endl;
	}
private:
	size_t min_qty;
	double discount;
};
ostream& operator <<(ostream& os, Bulk_quote& bq) {
	os << "\tUsing operator<<(ostream &,Bulk_quote&)" << endl;
	return os;
}




//class Limited_quote :public Disc_quote {
//public:
//	Limited_quote(const string& book = "", double sales_price = 0.0, size_t qty = 0, double disc_rate = 0.0) :
//		Disc_quote(book, sales_price, qty, disc_rate) {}
//	double net_price(size_t cnt) const override {
//		if (cnt <= quantity)
//			return cnt * (1 - discount) * price;
//		else
//			return quantity * (1 - discount) * price + (cnt - quantity) * price;
//	}
//private:
//	size_t min_qty;
//	double discount;
//};

//struct base {
//	base(string szNm) :basename(szNm) {}
//	string name() {
//		return basename;
//	}
//	virtual void print(ostream& os) {
//		os << basename;
//	}
//private:
//	string basename;
//};
//struct derived :public base {
//	derived(string szName, int iVal) :base(szName), mem(iVal) {}
//	void print(ostream &os) override{
//		base::print(os);
//		os << "--" << mem;
//	}
//private:
//	int mem;
//};

class Disc_quote :public Quote {
public :
	Disc_quote(const string& book = " ", double sales_price = 0.0, size_t  qty = 0, double disc = 0.0) :
		Quote(book, sales_price), quantity(qty), discount(disc) {}
	double net_price(size_t cnt) const = 0;
protected:
	size_t quantity;
	double discount;
};
//class Bulk_quote :public Disc_quote {
//public:
//	/*Bulk_quote(const string& book = "", double sales_price = 0, size_t qty = 0, double disc_rate = 0) :
//		Disc_quote(book, sales_price, qty, disc_rate) {}*/
//	using Disc_quote::Disc_quote;
//	double net_price(size_t cnt)const {
//		if (cnt > quantity)	return cnt * (1 - discount) * price;
//		else return cnt * price;
//	}
//};



//class Figure {
//public:
//	Figure(double, double);
//protected:
//	double xSize, ySize;
//};
//class Figure_2D :public Figure {
//public:
//	Figure_2D(double, double);
//	virtual double area() = 0;			//求面积操作:纯虚函数
//	virtual double pcrimeter() = 0;		//求周长操作:纯虚函数
//};
//class Figure_3D :public Figure {
//public:
//	Figure_3D(double, double, double);
//	virtual double cubage() = 0;
//protected:
//	double zSize;
//};
//class Rectangle :public Figure_2D {
//public:
//	Rectangle(double, double);
//	virtual double area();
//	virtual double perimeter();
//};
//class Circle :public Figure_2D {
//public:
//	Circle(double, double);
//	virtual double area();
//	virtual double perimeter();
//};
//class Sphere :public Figure_3D {
//public:
//	Sphere(double, double, double);
//	virtual double cubage();
//};
//class Cone :public Figure_3D {
//public:
//	Cone(double, double, double);
//	virtual double cubage();
//};


int main(void) {
	vector<Quote> T;
	for (size_t i = 0; i != 10; ++i) {
		Bulk_quote item("C++ Primer", 6.5, 0.5);
		T.push_back(item);
	}
	double sum = 0;
	for (auto i : T) {
		sum += i.net_price(10);
	}
	cout << sum << endl;
	return 0;
}

15.29

改

vector<shared_ptr<Quote>> T;

15.30

class Basket {
public:
	//Basket使用合成的默认构造函数和拷贝控制成员
	void add_item(const shared_ptr<Quote>& sale) { items.insert(sale); }
private:
	//该函数用于比较shared_ptr,multiset成员会用到它
	static bool compare(const shared_ptr<Quote>& lhs, const shared_ptr<Quote>& rhs) {
		return lhs->isbn() < rhs->isbn();
	}
	//multiset保存多个报价,按照compare成员排序
	multiset<shared_ptr<Quote>, decltype(compare)*>items{compare};
	double total_receipt(ostream& os) const;
};
double Basket::total_receipt(ostream& os) const {
	double sum = 0.0;					//保存实时计算出的总价格.
	//iter指向ISBN相同的一批元素中的第一个
	//upper_bound返回一个迭代器,该迭代器指向这批元素中的最后一个的下一个位置
	for (auto iter = items.cbegin(); iter != items.cend(); iter = items.upper_bound(*iter)) {
		sum += print_total(os, **iter, items.count(*iter));
	}
	os << "Total Sale:" << sum << endl;
	return sum;
}

15.31

(a) 创建12个对象,6个Query_base

3个WordQuery

1 个NotQuery

1个AndQuery

1个OrQuery

(b) 与(a)同

© 共创建14个对象,7个Query_base对象及其相关联的句柄,7个Query_base对象分别是4个WordQuery对象 2个AndQuery对象1个OrQuery对象.

15.32

​ Query类未定义自己的拷贝/移动控制成员,当进行这些操作时,执行默认语义,而其唯一的数据成员是Query_base的shared_ptr.因此,当拷贝,移动,赋值或销毁其唯一的数据成员 Query_base的shared_ptr时,会调用shared_ptr的对应控制成员.从而实现多个Query对象正确共享一个Query_base.而shared_ptr的控制成员调用Query_base的控制成员时,由于指向的可能是Query_base的派生类对象.因此可能在类层次中进行相应的拷贝/移动操作,调用Query_base的派生类的相应控制成员.

15.33

​ Query_base是一个虚基类,不允许直接声明其对象.

​ 当其派生类对象进行这些操作时,会调用Query_base的相应控制成员.而Query_base没有定义自己的拷贝/移动控制成员.实际上没有任何数据成员.无序定义这些操作,因此进行这些操作时,执行默认定义,什么也不会发生.

15.34

在这里插入图片描述

15.35

在这里插入图片描述

15.36

​ 在各个类的构造函数和rep中添加打印语句即可,注意,Query类有一个public,和一个private共两个构造函数

15.37

​ 书中的实现方式是用Query类封装了Query_base指针.管理实际查询处理用到的不同Query类型对象.

​ 如果不适用Query类.则涉及使用Query类型的地方.都要改成Query_base指针.如创建单个词查询时,就必须创建WordQuery类而不是Query对象.几个重载的布尔类型运算符也不能再针对Query对象.而需针对Query_base指针.从而复杂的查询请求无法携程目前的简单形式.需要逐个运算完成.将结果赋予Query_base指针.

15.38

第一条声明不合法,BinaryQuery是纯虚函数

第二条声明不合法,不能将Query转换为AndQuery

第三条声明不合法,不能将Query转换为OrQuery

15.39

略

15.40

​ OrQuery的eval从lhs到rhs获取范围来构造set(或向其插入),而set的构造和插入操作可以正确处理空范围.因此无论lhs和rhs的结果是否为空集.eval都能得到正确结果.

15.41

在这里插入图片描述

在这里插入图片描述

15.42

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

Camilleferros
关注
专栏目录
C++Primer第五版 第十五章习题答案（1~10）
MISAYAONE的博客
03-11 7189
1：知识点1：面向对象程序设计的三个基本概念：数据抽象、继承和动态绑定(核心概念) 数据抽象：将类的接口与实现分离 继承：我们可以定义与其他类相似但完全不相同的新类 动态绑定：在使用这些彼此相似的类时，在一定程度上忽略他们的区别，统一使用它们的对象 知识点2：类的继承构成一种层次关系，在层次根部的为基类，其他类则直接或者间接的从基类中继承而来，称为派生类 基类负责定义在层次关系中所有类共
C++Primer第五版——习题答案+详解(完整版)
热门推荐
MISAYAONE的博客
12-21 33万+
C++Primer第五版——习题答案详解 看的也比较快，但是有很多东西确实用不上，所以很多都没有深入的探讨，但是知识点覆盖的很全面，每一道题涉及的知识点我都写上简单的解释了。 文中代码的中文注释也尽量都写上，自己皆编译通过。 水平有限，如有有误之处，希望大家不吝指教！ 下面的链接是 第一章：全部题目(第一章基础较多)http:/
C++笔记-构造函数与拷贝控制
I'm here
03-14 196
如果基类的析构函数不是虚函数，则delete一个指向派生类对象的基类指针将产生未定义的形为。 class Quote { public: virtual ~Quote() = default; //动态绑定析构函数 }; Quote *itemp = new Quote; //静态类型与动态类型一致 delete itemp; //调用Quote...
C++primer第15章习题解答
宝剑锋从磨砺出 梅花香自苦寒来
06-06 5228
练习15.1：什么是虚成员？ 在类中被声明成virtual的成员，基类希望这种成员在派生类中重定义。除了构造函数外，任意非static成员都可以为虚成员。 练习15.2：protected访问说明符与private有何区别？ protected为受保护的访问标号，protected成员可以被该类的成员、友元和派生类成员(非友元)访问，而不可以被该类型的普通用户访问。而private成
C++Primer第五版 习题答案 第十五章 面向对象程序设计（Object-Oriented Programming）
shamozhizhoutx的博客
05-25 3696
练习15.1 什么是虚成员？ 虚函数是基类希望其派生类进行覆盖的函数。 练习15.2 protected 访问说明符与 private 有何区别？ 派生类的成员函数可以访问protected访问运算符的成员，而不能访问private的。 练习15.3 定义你自己的 Quote 类和 print_total 函数。 Quote_ex03.h #ifndef QUOTE_H_ #defin...
C++primer第十五章答案（第五版）
sdlkj1的博客
09-01 490
C++primer第十五章答案（第五版） 15.1 在C++语言中基类必须将它的两种成员函数区分开来：一种是基类希望其派生类进行覆盖的函数；一种是基类希望派生类直接继承而不要改变的函数。对于前者，基类通常将其定义为虚函数（virtual）。 15.2 protected访问说明符和private一样不能够在类外被调用，但是派生类的成员函数可以访问基类的protected成员，而不能访问基类的private成员。 15.3 #pragma once #include <iostream> usin
C++Primer（第4版）-课后习题答案.pdf
最新发布
11-01
《C++ Primer（第4版）》是一本深入学习C++编程语言的经典教材，其课后习题答案提供了丰富的实践练习和问题解析，帮助读者巩固并深化对C++语法、概念的理解。以下将针对各章节的主要知识点进行详细阐述： 1. 第一章...
C++ primer plus 课后习题答案
03-30
C++ Primer Plus的课后习题涵盖了许多关键知识点，包括但不限于： 1. **基本语法**：变量声明、数据类型、运算符、流程控制（如if、switch、for、while）、函数的使用等。 2. **指针与引用**：理解内存地址、指针...
C++Primer课后习题解答完整版.pdf
02-13
1. C++基础语法与程序结构：文件提到了C++程序的基本结构，包括main函数的定义、输入输出流的使用、变量的声明、标准库头文件的包含等。例如，使用#include来包含标准输入输出流库，以及main函数的返回类型int。 2....
C++ Primer Plus课后练习题 代码
03-27
通过实践这些课后练习题，你可以逐步加深对C++的理解，提高编程能力，为解决更复杂的问题打下坚实基础。在学习过程中，不断交流和讨论是至关重要的，因为它能帮助你发现自己的不足，从他人的经验中受益，从而共同...
c++primer plus第十五章练习参考答案（自己写的欢迎批评并留言指正）
weixin_43227941的博客
02-15 359
注意： 凡是注释处就是解决问题的新增或修改后的代码； 思路分析： 第一题：首先两个类种声明互为友元，再在remote类中设置一int成员代表其模式，还要在Rmote类中设置相应的枚举是互动还是常规；在Tv类添加一change(Remote &remote)友元来访问Remote中的私有成员:remote.state_mode ^= 1;常用于0 1切换； 第二题：利用继承思想，在bad_hmean类应该继承logic_error，并重写what()虚函数 （我没有这样采取，正确的做法应该是这样） .
C++ Primer第五版 第十五章习题答案
kwdecsdn的博客
10-17 210
C++ Primer第五版 第十五章习题答案3、4、5、 3、 #include<iostream> #include<string> class Quote{ public: Quote(const std::string &book,double sales_price):bookNo(book),price(sales_price){ } std::string isbn() const { return bookNo; } virtual doub
《C++ Primer》第15章 15.9节习题答案
chenyijun的专栏
10-27 794
《C++ Primer》第15章 面向对象程序设计 15.9节 文本查询程序再探 习题答案 练习15.30：编写你自己的Basket类，用它计算上一个练习中交易记录的总价格。 【出题思路】 本题是类构造编程练习。 【解答】 #include <iostream> #include <string> #include <ostream> #include <vector> #include <memory> #include &lt
C++ primer 第五版 第十五章练习答案
Leslie5205912的博客
05-26 619
第15章 面向对象程序设计 15.3 #include &lt;iostream&gt; #include &lt;string&gt; using namespace std; class Quote { public: Quote() = default; Quote(const string &amp;book,double sales_price):bookNo...
【c++ primer】第五版第十五章习题答案
qq_51931826的博客
09-26 1010
【c++ primer】第五版第十五章习题答案
c++ primer 第十五章习题
无所知的博客
10-14 962
c++ primer 第十五章习题 练习15.3 class Quote { public: Quote() = default; Quote(const string&amp;amp;amp;amp; book, double sales_price): bookNo(book), price(sales_price) {} string isbn() const { return bookNo;} ...
C++ Primer(第五版)|练习题答案与解析(第十五章:面向对象程序设计)
qq_24739717的博客
02-28 719
C++ Primer(第五版)|练习题答案与解析(第十五章:面向对象程序设计) 本博客主要记录C++ Primer(第五版)中的练习题答案与解析。 参考:C++ Primer C++ Primer 练习题15.1 什么是虚成员？ P526-52。.虚成员是基类希望派生类进行覆盖的函数，在其成员前加关键字virtual，使得该成员可以实现动态绑定。 练习题15.2 protected访问说明符...
C++Primer学习笔记第十五章(15/18)类 面向对象编程
BUILD
10-28 688
<br />面向对象<br />面向对象的三个基本概念是继承，多态，动态绑定。<br /> <br />protected成员<br />1像 private 成员一样，protected 成员不能被类的用户访问。<br />2像 public 成员一样，protected 成员可被该类的派生类访问。<br />3派生类只能通过派生类对象访问其基类的 protected 成员，派生类对其基类类型对象的 protected 成员没有特殊访问权限。<br /> <br />名字查找与集成<br />函数调用遵循
C++Primer第五版 第十五章习题答案（41~42）
MISAYAONE的博客
03-14 2989
41：非智能指针，所有的new都需要进行手动delete. 42：写出自己的思路吧，就不具体实现了 (a)：这一小问感觉有点问题，描述不清楚。个人理解：将文件读入之后，每行保存在一个vector中，根据输入单词，每行查询，输出对应单词 (b)：重新定义一个类，将每次的查询结果用一个map保存起来就好了，int为编号，map为查询结果 (c)：指定文本范围，根据输入限制一下vecto
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值