Home Cpp Cpp-Primer

# Chapter 15 Object-Oriented Programming

# OOP: An Overview

# OOP：概述

  • 面向对象程序设计（object-oriented programming）的核心思想是数据抽象、继承和动态绑定。
  • 继承（inheritance）：
    • 通过继承联系在一起的类构成一种层次关系。
    • 通常在层次关系的根部有一个基类（base class）。
    • 其他类直接或者简介从基类继承而来，这些继承得到的类成为派生类（derived class）。
    • 基类负责定义在层次关系中所有类共同拥有的成员，而每个派生类定义各自特有的成员。
    • 对于某些函数，基类希望它的派生类个自定义适合自己的版本，此时基类就将这些函数声明成虚函数（virtual function）。
    • 派生类必须通过使用类派生列表（class derivation list）明确指出它是从哪个基类继承而来。形式：一个冒号，后面紧跟以逗号分隔的基类列表，每个基类前都可以有访问说明符。 class Bulk_quote : public Quote{};
    • 派生类必须在其内部对所有重新定义的虚函数进行声明。可以在函数之前加上 virtual 关键字，也可以不加。C++11 新标准允许派生类显式地注明它将使用哪个成员函数改写基类的虚函数，即在函数的形参列表之后加一个 override 关键字。
  • 动态绑定（dynamic binding，又称运行时绑定）：
    • 使用同一段代码可以分别处理基类和派生类的对象。
    • 函数的运行版本由实参决定，即在运行时选择函数的版本。

# Defining Base and Derived Classes

# 定义基类和派生类

# 定义基类

  • 基类通常都应该定义一个虚析构函数，即使该函数不执行任何实际操作也是如此。
  • 基类通过在其成员函数的声明语句前加上关键字 virtual 使得该函数执行动态绑定。
  • 如果成员函数没有被声明为虚函数，则解析过程发生在编译时而非运行时。
  • 访问控制：
    • protected ： 基类和和其派生类还有友元可以访问。
    • private ： 只有基类本身和友元可以访问。

# 定义派生类

  • 派生类必须通过类派生列表（class derivation list）明确指出它是从哪个基类继承而来。形式：冒号，后面紧跟以逗号分隔的基类列表，每个基类前面可以有一下三种访问说明符的一个： public 、 protected 、 private 。
  • C++11 新标准允许派生类显式地注明它将使用哪个成员函数改写基类的虚函数，即在函数的形参列表之后加一个 override 关键字。
  • 派生类构造函数：派生类必须使用基类的构造函数去初始化它的基类部分。
  • 静态成员：如果基类定义了一个基类成员，则在整个继承体系中只存在该成员的唯一定义。
  • 派生类的声明：声明中不包含它的派生列表。
  • C++11 新标准提供了一种防止继承的方法，在类名后面跟一个关键字 final 。

# 类型转换与继承

  • 理解基类和派生类之间的类型抓换是理解 C++ 语言面向对象编程的关键所在。
  • 可以将基类的指针或引用绑定到派生类对象上。
  • 不存在从基类向派生类的隐式类型转换。
  • 派生类向基类的自动类型转换只对指针或引用类型有效，对象之间不存在类型转换。

# Exercise 15.1

什么是虚成员？

解：

对于某些函数，基类希望它的派生类各自定义适合自身的版本，此时基类就将这些函数声明成虚函数。

# Exercise 15.2

protected 访问说明符与 private 有何区别？

解：

  • protected ： 基类和和其派生类还有友元可以访问。
  • private ： 只有基类本身和友元可以访问。

# Exercise 15.3

定义你自己的 Quote 类和 print_total 函数。

解：

Quote :

#include <string>
class Quote
{
public:
	Quote() = default;
	Quote(const std::string &b, double p) :
		bookNo(b), price(p){}
	std::string isbn() const { return bookNo; }
	virtual double net_price(std::size_t n) const { return n * price; }
	virtual ~Quote() = default;
private:
	std::string bookNo;
protected:
	double  price = 0.0;
};
主函数：
#include "ex_15_3.h"
#include <iostream>
#include <string>
#include <map>
#include <functional>
double print_total(std::ostream& os, const Quote& item, size_t n);
int main()
{
	return 0;
}
double print_total(std::ostream &os, const Quote &item, size_t n)
{
	double ret = item.net_price(n);
	os << "ISBN:" << item.isbn()
		<< "# sold: " << n << " total due: " << ret << std::endl;
	return ret;
}
# Exercise 15.4
下面哪条声明语句是不正确的？请解释原因。
class Base { ... };
(a) class Derived : public Derived { ... };
(b) class Derived : private Base { ... };
(c) class Derived : public Base;
解：
  • (a) 不正确。类不能派生自身。
  • (b) 不正确。这是定义而非声明。
  • (c) 不正确。派生列表不能出现在这。
# Exercise 15.5
定义你自己的 Bulk_quote 类。
解：
#include "ex_15_3.h"
class Bulk_quote : public Quote
{
public:
	Bulk_quote() = default;
	Bulk_quote(const std::string& b, double p, std::size_t q, double disc) :
		Quote(b, p), min_qty(q), discount(disc) {}
	double net_price(std::size_t n) const override;
private:
	std::size_t min_qty = 0;
	double      discount = 0.0;
};
# Exercise 15.6
将 Quote 和 Bulk_quote 的对象传给 15.2.1 节练习中的 print_total 函数，检查该函数是否正确。
解：
#include "ex_15_3.h"
#include "ex_15_5.h"
#include <iostream>
#include <string>
double print_total(std::ostream& os, const Quote& item, size_t n);
int main()
{
	// ex15.6
	Quote q("textbook", 10.60);
	Bulk_quote bq("textbook", 10.60, 10, 0.3);
	print_total(std::cout, q, 12);
	print_total(std::cout, bq, 12);
	return 0;
}
double print_total(std::ostream &os, const Quote &item, size_t n)
{
	double ret = item.net_price(n);
	os << "ISBN:" << item.isbn()
		<< "# sold: " << n << " total due: " << ret << std::endl;
	return ret;
}
# Exercise 15.7
定义一个类使其实现一种数量受限的折扣策略，具体策略是：当购买书籍的数量不超过一个给定的限量时享受折扣，如果购买量一旦超过了限量，则超出的部分将以原价销售。
解：
#include "ex_15_5.h"
class Limit_quote : public Quote
{
public:
	Limit_quote();
	Limit_quote(const std::string& b, double p, std::size_t max, double disc) :
		Quote(b, p), max_qty(max), discount(disc)
	{}
	double net_price(std::size_t n) const override;
private:
	std::size_t max_qty = 0;
	double      discount = 0.0;
};
double Limit_quote::net_price(std::size_t n) const
{
	if (n > max_qty)
		return max_qty * price * discount + (n - max_qty) * price;
	else
		return n * discount *price;
}
# Exercise 15.8
给出静态类型和动态类型的定义。
解：
表达式的静态类型在编译时总是已知的，它是变量声明时的类型或表达式生成的类型。动态类型则是变量或表达式表示的内存中的对象的类型。动态类型直到运行时才可知。
# Exercise 15.9
在什么情况下表达式的静态类型可能与动态类型不同？请给出三个静态类型与动态类型不同的例子。
解：
基类的指针或引用的静态类型可能与其动态类型不一致。
# Exercise 15.10
回忆我们在 8.1 节进行的讨论，解释第 284 页中将 ifstream 传递给 Sales_data 的 read 函数的程序是如何工作的。
解：
std::ifstream 是 std::istream 的派生基类，因此 read 函数能够正常工作。
# Virtual Functions
# 虚函数
  • 使用虚函数可以执行动态绑定。
  • OOP 的核心思想是多态性（polymorphism）。
  • 当且仅当对通过指针或引用调用虚函数时，才会在运行时解析该调用，也只有在这种情况下对象的动态类型才有可能与静态类型不同。
  • 派生类必须在其内部对所有重新定义的虚函数进行声明。可以在函数之前加上 virtual 关键字，也可以不加。
  • C++11 新标准允许派生类显式地注明它将使用哪个成员函数改写基类的虚函数，即在函数的形参列表之后加一个 override 关键字。
  • 如果我们想覆盖某个虚函数，但不小心把形参列表弄错了，这个时候就不会覆盖基类中的虚函数。加上 override 可以明确程序员的意图，让编译器帮忙确认参数列表是否出错。
  • 如果虚函数使用默认实参，则基类和派生类中定义的默认实参最好一致。
  • 通常，只有成员函数（或友元）中的代码才需要使用作用域运算符（ :: ）来回避虚函数的机制。
# Exercise 15.11
为你的 Quote 类体系添加一个名为 debug 的虚函数，令其分别显示每个类的数据成员。
解：
void Quote::debug() const
{
    std::cout << "data members of this class:\n"
              << "bookNo= " <<this->bookNo << " "
              << "price= " <<this->price<< " ";
}
# Exercise 15.12
有必要将一个成员函数同时声明成 override 和 final 吗？为什么？
解：
有必要。 override 的含义是重写基类中相同名称的虚函数， final 是阻止它的派生类重写当前虚函数。
# Exercise 15.13
给定下面的类，解释每个 print 函数的机理：
class base {
public:
	string name() { return basename;}
	virtual void print(ostream &os) { os << basename; }
private:
	string basename;
};
class derived : public base {
public:
	void print(ostream &os) { print(os); os << " " << i; }
private:
	int i;
};
在上述代码中存在问题吗？如果有，你该如何修改它？
解：
有问题。应该改为：
void print(ostream &os) override { base::print(os); os << " derived\n " << i; }
# Exercise 15.14
给定上一题中的类以及下面这些对象，说明在运行时调用哪个函数：
base bobj; 		base *bp1 = &bobj; 	base &br1 = bobj;
derived dobj; 	base *bp2 = &dobj; 	base &br2 = dobj;
(a) bobj.print();	(b)dobj.print();	(c)bp1->name();
(d)bp2->name();		(e)br1.print();		(f)br2.print();
解：
  • (a) 编译时。
  • (b) 编译时。
  • (c) 编译时。
  • (d) 编译时。
  • (e) 运行时。 base::print()
  • (f) 运行时。 derived::print()
# Abstract Base Classes
# 抽象基类
  • 纯虚函数（pure virtual）：清晰地告诉用户当前的函数是没有实际意义的。纯虚函数无需定义，只用在函数体的位置前书写 =0 就可以将一个虚函数说明为纯虚函数。
  • 含有纯虚函数的类是抽象基类（abstract base class）。不能创建抽象基类的对象。
# Exercise 15.15
定义你自己的 Disc_quote 和 Bulk_quote 。
解：
Disc_quote :
#include "quote.h"
class Disc_quote : public Quote
{
public:
    Disc_quote();
    Disc_quote(const std::string& b, double p, std::size_t q, double d) :
        Quote(b, p), quantity(q), discount(d)   { }
    virtual double net_price(std::size_t n) const override = 0;
protected:
    std::size_t quantity;
    double      discount;
};
Bulk_quote :
#include "disc_quote.h"
class Bulk_quote : public Disc_quote
{
public:
    Bulk_quote() = default;
    Bulk_quote(const std::string& b, double p, std::size_t q, double disc) :
        Disc_quote(b, p, q, disc) {   }
    double net_price(std::size_t n) const override;
    void  debug() const override;
};
# Exercise 15.16
改写你在 15.2.2 节练习中编写的数量受限的折扣策略，令其继承 Disc_quote 。
解：
Limit_quote ：
#include "disc_quote.h"
class Limit_quote : public Disc_quote
{
public:
    Limit_quote() = default;
    Limit_quote(const std::string& b, double p, std::size_t max, double disc):
        Disc_quote(b, p, max, disc)  {   }
    double net_price(std::size_t n) const override
    { return n * price * (n < quantity ? 1 - discount : 1 ); }
    void debug() const override;
};
# Exercise 15.17
尝试定义一个 Disc_quote 的对象，看看编译器给出的错误信息是什么？
解：
error: cannot declare variable 'd' to be of abstract type 'Disc_quote': Disc_quote d;
# Access Control and Inheritance
# 访问控制与继承
  • 受保护的成员：
    • protected 说明符可以看做是 public 和 private 中的产物。
    • 类似于私有成员，受保护的成员对类的用户来说是不可访问的。
    • 类似于公有成员，受保护的成员对于派生类的成员和友元来说是可访问的。
    • 派生类的成员或友元只能通过派生类对象来访问基类的受保护成员。派生类对于一个基类对象中的受保护成员没有任何访问特权。
  • 派生访问说明符：
    • 对于派生类的成员（及友元）能否访问其直接积累的成员没什么影响。
    • 派生访问说明符的目的是：控制派生类用户对于基类成员的访问权限。比如 struct Priv_Drev: private Base{} 意味着在派生类 Priv_Drev 中，从 Base 继承而来的部分都是 private 的。
  • 友元关系不能继承。
  • 改变个别成员的可访问性：使用 using 。
  • 默认情况下，使用 class 关键字定义的派生类是私有继承的；使用 struct 关键字定义的派生类是公有继承的。
# Exercise 15.18
假设给定了第 543 页和第 544 页的类，同时已知每个对象的类型如注释所示，判断下面的哪些赋值语句是合法的。解释那些不合法的语句为什么不被允许：
Base *p = &d1;  //d1 的类型是 Pub_Derv
p = &d2;		//d2 的类型是 Priv_Derv
p = &d3;		//d3 的类型是 Prot_Derv
p = &dd1;		//dd1 的类型是 Derived_from_Public	
p = &dd2;		//dd2 的类型是 Derived_from_Private
p = &dd3;		//dd3 的类型是 Derived_from_Protected
解：
Base *p = &d1; 合法
p = &d2; 不合法
p = &d3; 不合法
p = &dd1; 合法
p = &dd2; 不合法
p = &dd3; 不合法
只有在派生类是使用 public 的方式继承基类时，用户代码才可以使用派生类到基类（ derived-to-base ）的转换。
# Exercise 15.19
假设 543 页和 544 页的每个类都有如下形式的成员函数：
void memfcn(Base &b) { b = *this; }
对于每个类，分别判断上面的函数是否合法。
解：
合法：
  • Pub_Derv
  • Priv_Derv
  • Prot_Derv
  • Derived_from_Public
  • Derived_from_Protected
    不合法：
  • Derived_from_Private
这段代码是在成员函数中使用 Base 。 Priv_Drev 中的 Base 部分虽然是 private 的，但其成员函数依然可以访问； Derived_from_Private 继承自 Priv_Drev ，不能访问 Priv_Drev 中的 private 成员，因此不合法。
# Exercise 15.20
编写代码检验你对前面两题的回答是否正确。
解：
#include <iostream>
#include <string>
#include "exercise15_5.h"
#include "bulk_quote.h"
#include "limit_quote.h"
#include "disc_quote.h"
class Base
{
public:
	void pub_mem();   // public member
protected:
	int prot_mem;     // protected member
private:
	char priv_mem;    // private member
};
struct Pub_Derv : public    Base
{
	void memfcn(Base &b) { b = *this; }
};
struct Priv_Derv : private   Base
{
	void memfcn(Base &b) { b = *this; }
};
struct Prot_Derv : protected Base
{
	void memfcn(Base &b) { b = *this; }
};
struct Derived_from_Public : public Pub_Derv
{
	void memfcn(Base &b) { b = *this; }
};
struct Derived_from_Private : public Priv_Derv
{
	//void memfcn(Base &b) { b = *this; }
};
struct Derived_from_Protected : public Prot_Derv
{
	void memfcn(Base &b) { b = *this; }
};
int main()
{
	Pub_Derv d1;
	Base *p = &d1;
	Priv_Derv d2;
	//p = &d2;
	Prot_Derv d3;
	//p = &d3;
	Derived_from_Public dd1;
	p = &dd1;
	Derived_from_Private dd2;
	//p =& dd2;
	Derived_from_Protected dd3;
	//p = &dd3;
	return 0;
}
# Exercise 15.21
从下面这些一般性抽象概念中任选一个（或者选一个你自己的），将其对应的一组类型组织成一个继承体系：
(a) 图形文件格式（如gif、tiff、jpeg、bmp）
(b) 图形基元（如方格、圆、球、圆锥）
(c) C++语言中的类型（如类、函数、成员函数）
解：
#include <iostream>
#include <string>
#include "quote.h"
#include "bulk_quote.h"
#include "limit_quote.h"
#include "disc_quote.h"
// just for 2D shape
class Shape
{
public:
    typedef std::pair<double, double>    Coordinate;
    Shape() = default;
    Shape(const std::string& n) :
        name(n) { }
    virtual double area()       const = 0;
    virtual double perimeter()  const = 0;
    virtual ~Shape() = default;
private:
    std::string name;
};
class Rectangle : public Shape
{
public:
    Rectangle() = default;
    Rectangle(const std::string& n,
              const Coordinate& a,
              const Coordinate& b,
              const Coordinate& c,
              const Coordinate& d) :
        Shape(n), a(a), b(b), c(c), d(d) { }
    ~Rectangle() = default;
protected:
    Coordinate  a;
    Coordinate  b;
    Coordinate  c;
    Coordinate  d;
};
class Square : public Rectangle
{
public:
    Square() = default;
    Square(const std::string& n,
           const Coordinate& a,
           const Coordinate& b,
           const Coordinate& c,
           const Coordinate& d) :
        Rectangle(n, a, b, c, d) { }
    ~Square() = default;
};
int main()
{
    return 0;
}
# Exercise 15.22
对于你在上一题中选择的类，为其添加函数的虚函数及公有成员和受保护的成员。
解：
参考 15.21。
# Class Scope under Inheritance
# 继承中的类作用域
  • 每个类定义自己的作用域，在这个作用域内我们定义类的成员。当存在继承关系时，派生类的作用域嵌套在其基类的作用域之内。
  • 派生类的成员将隐藏同名的基类成员。
  • 除了覆盖继承而来的虚函数之外，派生类最好不要重用其他定义在基类中的名字。
# Exercise 15.23
假设第 550 页的 D1 类需要覆盖它继承而来的 fcn 函数，你应该如何对其进行修改？如果你修改之后 fcn 匹配了 Base 中的定义，则该节的那些调用语句将如何解析？
解：
移除 int 参数。
# Constructors and Copy Control
# 构造函数与拷贝控制
# 虚析构函数
  • 基类通常应该定义一个虚析构函数，这样我们就能动态分配继承体系中的对象了。
  • 如果基类的析构函数不是虚函数，则 delete 一个指向派生类对象的基类指针将产生未定义的行为。
  • 虚析构函数将阻止合成移动操作。
# 合成拷贝控制与继承
  • 基类或派生类的合成拷贝控制成员的行为和其他合成的构造函数、赋值运算符或析构函数类似：他们对类本身的成员依次进行初始化、赋值或销毁的操作。
# 派生类的拷贝控制成员
  • 当派生类定义了拷贝或移动操作时，该操作负责拷贝或移动包括基类部分成员在内的整个对象。
  • 派生类析构函数：派生类析构函数先执行，然后执行基类的析构函数。
# 继承的构造函数
  • C++11 新标准中，派生类可以重用其直接基类定义的构造函数。
  • 如 using Disc_quote::Disc_quote; ，注明了要继承 Disc_quote 的构造函数。
# Exercise 15.24
哪种类需要虚析构函数？虚析构函数必须执行什么样的操作？
解：
基类通常应该定义一个虚析构函数。
# Exercise 15.25
我们为什么为 Disc_quote 定义一个默认构造函数？如果去掉该构造函数的话会对 Bulk_quote 的行为产生什么影响？
解：
因为 Disc_quote 的默认构造函数会运行 Quote 的默认构造函数，而 Quote 默认构造函数会完成成员的初始化工作。
如果去除掉该构造函数的话， Bulk_quote 的默认构造函数而无法完成 Disc_quote 的初始化工作。
# Exercise 15.26
定义 Quote 和 Bulk_quote 的拷贝控制成员，令其与合成的版本行为一致。为这些成员以及其他构造函数添加打印状态的语句，使得我们能够知道正在运行哪个程序。使用这些类编写程序，预测程序将创建和销毁哪些对象。重复实验，不断比较你的预测和实际输出结果是否相同，直到预测完全准确再结束。
解：
Quote :
#include <string>
#include <iostream>
class Quote
{
	friend bool operator !=(const Quote& lhs, const Quote& rhs);
public:
	Quote() { std::cout << "default constructing Quote\n"; }
	Quote(const std::string &b, double p) :
		bookNo(b), price(p)
	{
		std::cout << "Quote : constructor taking 2 parameters\n";
	}
	// copy constructor
	Quote(const Quote& q) : bookNo(q.bookNo), price(q.price)
	{
		std::cout << "Quote: copy constructing\n";
	}
	// move constructor
	Quote(Quote&& q) noexcept : bookNo(std::move(q.bookNo)), price(std::move(q.price))
	{ std::cout << "Quote: move constructing\n"; }
	// copy =
	Quote& operator =(const Quote& rhs)
	{
		if (*this != rhs)
		{
			bookNo = rhs.bookNo;
			price = rhs.price;
		}
		std::cout << "Quote: copy =() \n";
		return *this;
	}
	// move =
	Quote& operator =(Quote&& rhs)  noexcept
	{
		if (*this != rhs)
		{
			bookNo = std::move(rhs.bookNo);
			price = std::move(rhs.price);
		}
		std::cout << "Quote: move =!!!!!!!!! \n";
		return *this;
	}
	std::string     isbn() const { return bookNo; }
	virtual double  net_price(std::size_t n) const { return n * price; }
	virtual void    debug() const;
	virtual ~Quote()
	{
		std::cout << "destructing Quote\n";
	}
private:
	std::string bookNo;
protected:
	double  price = 10.0;
};
bool inline
operator !=(const Quote& lhs, const Quote& rhs)
{
	return lhs.bookNo != rhs.bookNo
		&&
		lhs.price != rhs.price;
}
Bulk_quote :
#include "Disc_quote.h"
#include <iostream>
class Bulk_quote : public Disc_quote
{
public:
	Bulk_quote() { std::cout << "default constructing Bulk_quote\n"; }
	Bulk_quote(const std::string& b, double p, std::size_t q, double disc) :
		Disc_quote(b, p, q, disc)
	{
		std::cout << "Bulk_quote : constructor taking 4 parameters\n";
	}
	// copy constructor
	Bulk_quote(const Bulk_quote& bq) : Disc_quote(bq)
	{
		std::cout << "Bulk_quote : copy constructor\n";
	}
	// move constructor
	Bulk_quote(Bulk_quote&& bq) : Disc_quote(std::move(bq)) noexcept
	{
		std::cout << "Bulk_quote : move constructor\n";
	}
	// copy =()
	Bulk_quote& operator =(const Bulk_quote& rhs)
	{
		Disc_quote::operator =(rhs);
		std::cout << "Bulk_quote : copy =()\n";
		return *this;
	}
	// move =()
	Bulk_quote& operator =(Bulk_quote&& rhs) noexcept
	{
		Disc_quote::operator =(std::move(rhs));
		std::cout << "Bulk_quote : move =()\n";
		return *this;
	}
	double net_price(std::size_t n) const override;
	void  debug() const override;
	~Bulk_quote() override
	{
		std::cout << "destructing Bulk_quote\n";
	}
};
程序输出结果：
default constructing Quote
default constructing Disc_quote
default constructing Bulk_quote
Quote : constructor taking 2 parameters
Disc_quote : constructor taking 4 parameters.
Bulk_quote : constructor taking 4 parameters
Quote: copy constructing
Quote: copy constructing
destructing Quote
destructing Quote
Disc_quote : move =()
Bulk_quote : move =()
destructing Bulk_quote
destructing Dis_quote
destructing Quote
destructing Bulk_quote
destructing Dis_quote
destructing Quote

# Exercise 15.27
重新定义你的 Bulk_quote 类，令其继承构造函数。
解：
#include "disc_quote.h"
#include <iostream>
class Bulk_quote : public Disc_quote
{
public:
	Bulk_quote() { std::cout << "default constructing Bulk_quote\n"; }
	// changed the below to the inherited constructor for ex15.27.
	// rules:  1. only inherit from the direct base class.
	//         2. default, copy and move constructors can not inherit.
	//         3. any data members of its own are default initialized.
	//         4. the rest details are in the section section 15.7.4.
	/*
	Bulk_quote(const std::string& b, double p, std::size_t q, double disc) :
	Disc_quote(b, p, q, disc) { std::cout << "Bulk_quote : constructor taking 4 parameters\n"; }
	*/
	using Disc_quote::Disc_quote;
	// copy constructor
	Bulk_quote(const Bulk_quote& bq) : Disc_quote(bq)
	{
		std::cout << "Bulk_quote : copy constructor\n";
	}
	// move constructor
	Bulk_quote(Bulk_quote&& bq) : Disc_quote(std::move(bq))
	{
		std::cout << "Bulk_quote : move constructor\n";
	}
	// copy =()
	Bulk_quote& operator =(const Bulk_quote& rhs)
	{
		Disc_quote::operator =(rhs);
		std::cout << "Bulk_quote : copy =()\n";
		return *this;
	}
	// move =()
	Bulk_quote& operator =(Bulk_quote&& rhs)
	{
		Disc_quote::operator =(std::move(rhs));
		std::cout << "Bulk_quote : move =()\n";
		return *this;
	}
	double net_price(std::size_t n) const override;
	void  debug() const override;
	~Bulk_quote() override
	{
		std::cout << "destructing Bulk_quote\n";
	}
};
# Containers and Inheritance
# 容器与继承
  • 当我们使用容器存放继承体系中的对象时，通常必须采用间接存储的方式。
  • 派生类对象直接赋值给积累对象，其中的派生类部分会被切掉。
  • 在容器中放置（智能）指针而非对象。
  • 对于 C++ 面向对象的编程来说，一个悖论是我们无法直接使用对象进行面向对象编程。相反，我们必须使用指针和引用。因为指针会增加程序的复杂性，所以经常定义一些辅助的类来处理这些复杂的情况。
# Exercise 15.28
定义一个存放 Quote 对象的 vector ，将 Bulk_quote 对象传入其中。计算 vector 中所有元素总的 net_price 。
解：
#include <iostream>
#include <string>
#include <vector>
#include <memory>
#include "quote.h"
#include "bulk_quote.h"
#include "limit_quote.h"
#include "disc_quote.h"
int main()
{
	/**
	* @brief ex15.28   outcome == 9090
	*/
	std::vector<Quote> v;
	for (unsigned i = 1; i != 10; ++i)
		v.push_back(Bulk_quote("sss", i * 10.1, 10, 0.3));
	double total = 0;
	for (const auto& b : v)
	{
		total += b.net_price(20);
	}
	std::cout << total << std::endl;
	std::cout << "======================\n\n";
	/**
	* @brief ex15.29   outccome == 6363
	*/
	std::vector<std::shared_ptr<Quote>> pv;
	for (unsigned i = 1; i != 10; ++i)
		pv.push_back(std::make_shared<Bulk_quote>(Bulk_quote("sss", i * 10.1, 10, 0.3)));
	double total_p = 0;
	for (auto p : pv)
	{
		total_p += p->net_price(20);
	}
	std::cout << total_p << std::endl;
	return 0;
}
# Exercise 15.29
再运行一次你的程序，这次传入 Quote 对象的 shared_ptr 。如果这次计算出的总额与之前的不一致，解释为什么；如果一直，也请说明原因。
解：
因为智能指针导致了多态性的产生，所以这次计算的总额不一致。
# Exercise 15.30
编写你自己的 Basket 类，用它计算上一个练习中交易记录的总价格。
解：
Basket h :
#include "quote.h"
#include <set>
#include <memory>
// 购物篮
// a basket of objects from Quote hierachy, using smart pointers.
class Basket
{
public:
	// Basket 使用合成的默认构造函数和拷贝控制成员
	// copy verison
	void add_item(const Quote& sale)
	{
		items.insert(std::shared_ptr<Quote>(sale.clone()));
	}
	// move version
	void add_item(Quote&& sale)
	{
		items.insert(std::shared_ptr<Quote>(std::move(sale).clone()));
	}
	// 打印每本书的总价和购物篮中所有书的总价
	double total_receipt(std::ostream& os) const;
private:
	// function to compare needed by the multiset member
	static bool compare(const std::shared_ptr<Quote>& lhs,
		const std::shared_ptr<Quote>& rhs)
	{
		return lhs->isbn() < rhs->isbn();
	}
	// hold multiple quotes, ordered by the compare member
	std::multiset<std::shared_ptr<Quote>, decltype(compare)*>
		items{ compare };
};
Basket cpp :
#include "basket.h"
double Basket::total_receipt(std::ostream &os) const
{
	double sum = 0.0;  // 保存实时计算出的总价格
	//iter 指向 ISBN 相同的一批元素中的第一个
	//upper_bound 返回一个迭代器，该迭代器指向这批元素的尾后位置
	for (auto iter = items.cbegin(); iter != items.cend();
		iter = items.upper_bound(*iter))
		//  ^^^^^^^^^^^^^^^^^^^^^^^^^^^
		// @note   this increment moves iter to the first element with key
		//         greater than  *iter.
	{
		sum += print_total(os, **iter, items.count(*iter));
	}                                   // ^^^^^^^^^^^^^ using count to fetch
	// the number of the same book.
	os << "Total Sale: " << sum << std::endl;
	return sum;
}
main :
#include <iostream>
#include <string>
#include <vector>
#include <memory>
#include <fstream>
#include "quote.h"
#include "bulk_quote.h"
#include "limit_quote.h"
#include "disc_quote.h"
#include "basket.h"
int main()
{
	Basket basket;
	for (unsigned i = 0; i != 10; ++i)
		basket.add_item(Bulk_quote("Bible", 20.6, 20, 0.3));
	for (unsigned i = 0; i != 10; ++i)
		basket.add_item(Bulk_quote("C++Primer", 30.9, 5, 0.4));
	for (unsigned i = 0; i != 10; ++i)
		basket.add_item(Quote("CLRS", 40.1));
	std::ofstream log("log.txt", std::ios_base::app | std::ios_base::out);
	basket.total_receipt(log);
	return 0;
}
# Text Queries Revisited
# 文本查询程序再探
  • 使系统支持：单词查询、逻辑非查询、逻辑或查询、逻辑与查询。
# 面向对象的解决方案
  • 将几种不同的查询建模成相互独立的类，这些类共享一个公共基类：
    • WordQuery
    • NotQuery
    • OrQuery
    • AndQuery
  • 这些类包含两个操作：
    • eval ：接受一个 TextQuery 对象并返回一个 QueryResult 。
    • rep ：返回基础查询的 string 表示形式。
  • 继承和组合：
    • 当我们令一个类公有地继承另一个类时，派生类应当反映与基类的 “是一种（Is A）” 的关系。
    • 类型之间另一种常见的关系是 “有一个（Has A）” 的关系。
  • 对于面向对象编程的新手来说，想要理解一个程序，最困难的部分往往是理解程序的设计思路。一旦掌握了设计思路，接下来的实现也就水到渠成了。
Query 程序设计:
操作解释
Query 程序接口类和操作
TextQuery该类读入给定的文件并构建一个查找图。包含一个 query 操作，它接受一个 string 实参，返回一个 QueryResult 对象；该 QueryResult 对象表示 string 出现的行。
QueryResult该类保存一个 query 操作的结果。
Query是一个接口类，指向 Query_base 派生类的对象。
Query q(s)将 Query 对象 q 绑定到一个存放着 string s 的新 WordQuery 对象上。
q1 & q2返回一个 Query 对象，该 Query 绑定到一个存放 q1 和 q2 的新 AndQuery 对象上。
q1 | q2返回一个 Query 对象，该 Query 绑定到一个存放 q1 和 q2 的新 OrQuery 对象上。
~q返回一个 Query 对象，该 Query 绑定到一个存放 q 的新 NotQuery 对象上。
Query 程序实现类
Query_base查询类的抽象基类
WordQueryQuery_base 的派生类，用于查找一个给定的单词
NotQueryQuery_base 的派生类，用于查找一个给定的单词
BinaryQueryQuery_base 的派生类，查询结果是 Query 运算对象没有出现的行的集合
OrQueryQuery_base 的派生类，返回它的两个运算对象分别出现的行的并集
AndQueryQuery_base 的派生类，返回它的两个运算对象分别出现的行的交集
# Exercise 15.31
已知 s1 、 s2 、 s3 和 s4 都是 string ，判断下面的表达式分别创建了什么样的对象：
(a) Query(s1) | Query(s2) & ~Query(s3);
(b) Query(s1) | (Query(s2) & ~Query(s3));
(c) (Query(s1) & (Query(s2)) | (Query(s3) & Query(s4)));
解：
(a) OrQuery, AndQuery, NotQuery, WordQuery
(b) OrQuery, AndQuery, NotQuery, WordQuery
(c) OrQuery, AndQuery, WordQuery
# Exercise 15.32
当一个 Query 类型的对象被拷贝、移动、赋值或销毁时，将分别发生什么？
解：
  • 拷贝：当被拷贝时，合成的拷贝构造函数被调用。它将拷贝两个数据成员至新的对象。而在这种情况下，数据成员是一个智能指针，当拷贝时，相应的智能指针指向相同的地址，计数器增加 1.
  • 移动：当移动时，合成的移动构造函数被调用。它将移动数据成员至新的对象。这时新对象的智能指针将会指向原对象的地址，而原对象的智能指针为 nullptr ，新对象的智能指针的引用计数为 1。
  • 赋值：合成的赋值运算符被调用，结果和拷贝的相同的。
  • 销毁：合成的析构函数被调用。对象的智能指针的引用计数递减，当引用计数为 0 时，对象被销毁。
# Exercise 15.33
当一个 Query_base 类型的对象被拷贝、移动赋值或销毁时，将分别发生什么？
解：
由合成的版本来控制。然而 Query_base 是一个抽象类，它的对象实际上是它的派生类对象。
# Exercise 15.34
针对图 15.3 构建的表达式：
(a) 例举出在处理表达式的过程中执行的所有构造函数。
(b) 例举出 cout << q 所调用的 rep。
(c) 例举出 q.eval() 所调用的 eval。
解：
  • a： Query q = Query("fiery") & Query("bird") | Query("wind");
  1. Query::Query(const std::string& s) where s == "fiery","bird" and "wind"
  2. WordQuery::WordQuery(const std::string& s) where s == "fiery","bird" and "wind"
  3. AndQuery::AndQuery(const Query& left, const Query& right);
  4. BinaryQuery(const Query&l, const Query& r, std::string s);
  5. Query::Query(std::shared_ptr<Query_base> query) 2times
  6. OrQuery::OrQuery(const Query& left, const Query& right);
  7. BinaryQuery(const Query&l, const Query& r, std::string s);
  8. Query::Query(std::shared_ptr<Query_base> query) 2times
  • b：
  1. query.rep() inside the operator <<().
  2. q->rep() inside the member function rep().
  3. OrQuery::rep() which is inherited from BinaryQuery .
  4. Query::rep() for lhs and rhs :
    for rhs which is a WordQuery : WordQuery::rep() where query_word("wind") is returned.For lhs which is an AndQuery .
  5. AndQuery::rep() which is inherited from BinaryQuery .
  6. BinaryQuer::rep() : for rhs: WordQuery::rep() where query_word("fiery") is returned. For lhs: WordQuery::rep() where query_word("bird" ) is returned.
  • c：
  1. q.eval()
  2. q->rep() : where q is a pointer to OrQuary .
  3. QueryResult eval(const TextQuery& )const override : is called but this one has not been defined yet.
# Exercise 15.35
实现 Query 类和 Query_base 类，其中需要定义 rep 而无须定义 eval 。
解：
Query :
#ifndef QUERY_H
#define QUERY_H
#include <iostream>
#include <string>
#include <memory>
#include "query_base.h"
#include "queryresult.h"
#include "textquery.h"
#include "wordquery.h"
/**
* @brief interface class to manage the Query_base inheritance hierachy
*/
class Query
{
	friend Query operator~(const Query&);
	friend Query operator|(const Query&, const Query&);
	friend Query operator&(const Query&, const Query&);
public:
	// build a new WordQuery
	Query(const std::string& s) : q(new WordQuery(s))
	{
		std::cout << "Query::Query(const std::string& s) where s=" + s + "\n";
	}
	// interface functions: call the corresponding Query_base operatopns
	QueryResult eval(const TextQuery& t) const
	{
		return q->eval(t);
	}
	std::string rep() const
	{
		std::cout << "Query::rep() \n";
		return q->rep();
	}
private:
	// constructor only for friends
	Query(std::shared_ptr<Query_base> query) :
		q(query)
	{
		std::cout << "Query::Query(std::shared_ptr<Query_base> query)\n";
	}
	std::shared_ptr<Query_base> q;
};
inline std::ostream&
operator << (std::ostream& os, const Query& query)
{
	// make a virtual call through its Query_base pointer to rep();
	return os << query.rep();
}
#endif // QUERY_H
Query_base :
#ifndef QUERY_BASE_H
#define QUERY_BASE_H
#include "textquery.h"
#include "queryresult.h"
/**
* @brief abstract class acts as a base class for all concrete query types
*        all members are private.
*/
class Query_base
{
	friend class Query;
protected:
	using line_no = TextQuery::line_no; //  used in the eval function
	virtual ~Query_base() = default;
private:
	// returns QueryResult that matches this query
	virtual QueryResult eval(const TextQuery&) const = 0;
	// a string representation of this query
	virtual std::string rep() const = 0;
};
#endif // QUERY_BASE_H
# Exercise 15.36
在构造函数和 rep 成员中添加打印语句，运行你的代码以检验你对本节第一个练习中 (a)、(b) 两小题的回答是否正确。
解：
Query q = Query("fiery") & Query("bird") | Query("wind");
WordQuery::WordQuery(wind)
Query::Query(const std::string& s) where s=wind
WordQuery::WordQuery(bird)
Query::Query(const std::string& s) where s=bird
WordQuery::WordQuery(fiery)
Query::Query(const std::string& s) where s=fiery
BinaryQuery::BinaryQuery()  where s=&
AndQuery::AndQuery()
Query::Query(std::shared_ptr<Query_base> query)
BinaryQuery::BinaryQuery()  where s=|
OrQuery::OrQuery
Query::Query(std::shared_ptr<Query_base> query)
Press <RETURN> to close this window...
std::cout << q <<std::endl;
Query::rep()
BinaryQuery::rep()
Query::rep()
WodQuery::rep()
Query::rep()
BinaryQuery::rep()
Query::rep()
WodQuery::rep()
Query::rep()
WodQuery::rep()
((fiery & bird) | wind)
Press <RETURN> to close this window...
# Exercise 15.37
如果在派生类中含有 shared_ptr<Query_base> 类型的成员而非 Query 类型的成员，则你的类需要做出怎样的改变？
解：
参考 15.35。
# Exercise 15.38
下面的声明合法吗？如果不合法，请解释原因；如果合法，请指出该声明的含义。
BinaryQuery a = Query("fiery") & Query("bird");
AndQuery b = Query("fiery") & Query("bird");
OrQuery c = Query("fiery") & Query("bird");
解：
  1. 不合法。因为 BinaryQuery 是抽象类。
  2. 不合法。 & 操作返回的是一个 Query 对象。
  3. 不合法。 & 操作返回的是一个 Query 对象。
# Exercise 15.39
实现 Query 类和　 Query_base 类，求图 15.3 中表达式的值并打印相关信息，验证你的程序是否正确。
# Exercise 15.40
在 OrQuery 的 eval 函数中，如果 rhs 成员返回的是空集将发生什么？
解：
不会发生什么。代码如下：
std::shared_ptr<std::set<line_no>> ret_lines =
       std::make_shared<std::set<line_no>>(left.begin(), left.end());
如果 rhs 成员返回的是空集，在 set 当中不会添加什么。
# Exercise 15.41
重新实现你的类，这次使用指向 Query_base 的内置指针而非 shared_ptr 。请注意，做出上述改动后你的类将不能再使用合成的拷贝控制成员。
解：
略
# Exercise 15.42
从下面的几种改进中选择一种，设计并实现它:
(a) 按句子查询并打印单词，而不再是按行打印。
(b) 引入一个历史系统，用户可以按编号查阅之前的某个查询，并可以在其中添加内容或者将其余其他查询组合。
(c) 允许用户对结果做出限制，比如从给定范围的行中跳出匹配的进行显示。
解：
略
# Chapter Summary
🍓：）