《C++ Primer》学习笔记（十五）：面向对象编程

今天药忘吃喽~ 2023-02-12 05:26 23阅读 0赞

### 《C++ Primer》学习笔记（十五）：面向对象编程 ###

*  抽象基类
 *  访问控制与继承
 *  构造函数与拷贝控制
 *  文本查询程序再探
 *  练习

面向对象编程的核心思想是**数据抽象、继承和动态绑定**。

在C++语言中，当我们使用基类的引用（或指针）调用一个虚函数时将发生**动态绑定**。

**派生类经常（但不总是）覆盖它继承的虚函数**。如果派生类没有覆盖基类中的某个虚函数，则该虚函数的行为类似于其他的普通成员，派生类会直接继承其在基类中的版本。

派生类可以在它覆盖的函数前使用`virtual`关键字，但不是一定要这么做。也可以在函数的形参列表后面添加一个关键字`override`关键字来说明。如果我们使用`override`标记了某个函数，但该函数并没有覆盖已存在的虚函数，此时编译器将报错。

如果我们将某个函数指定为`final`，则之后任何尝试覆盖该函数的操作都将引发错误。

尽管派生类对象中含有从基类继承而来的成员，但派生类并不能直接初始化这些成员，而要通过在构造函数的初始化列表来将实参传递给基类构造函数的。**首先初始化基类的部分，然后按照声明的顺序依次初始化派生类自己的成员**。

**如果基类定义了一个静态成员，则在整个继承体系中只存在该成员的唯一定义**。不论从基类中派生出来多少个派生类，对于每个静态成员来说都只存在唯一的实例。

**如果我们不希望其他类继承某个类**，可以在这个类的后面跟一个关键字`final`。

class NoDerived final {
         /* */ }; //NoDerived不能作为基类

之所以存在派生类向基类的类型转换是因为每个派生类对象都包含一个基类部分，而基类的引用或指针可以绑定到该基类部分上。派生类向基类的自动类型转换**只对指针或引用类型有效**，在派生类类型和基类类型之间则不存在这样的转换。

基类的虚函数在派生类中隐含地也是一个虚函数。当派生类覆盖了某个虚函数时，该函数在基类中的形参必须与派生类中的形参严格匹配。

虚函数也可以拥有默认实参。如果我们通过基类的引用或指针调用函数，则使用基类中定义的默认实参。即使实际运行的是派生类中的函数版本也是如此。此时，传入派生类函数的将是基类函数定义的默认实参。如果派生类函数依赖不同的实参，则程序结果将与我们的预期不符。**因此如果虚函数使用默认实参，则基类和派生类中定义的默认实参最好一致**。

可以通过**作用域运算符**来回避虚函数机制，强迫执行虚函数的某个特定版本。通常当一个派生类的虚函数调用它覆盖的基类的虚函数时需要用到这一点，因为如果一个派生类虚函数需要调用它的基类版本，但是没有使用作用域运算符，则在运行时该调用将被解析为对派生类版本自身的调用，从而导致无限递归。

//强行调用基类中定义的函数版本而不管baseP的动态类型到底是什么
    double undiscounted = baseP->Quote::net_price(42);

# 抽象基类 #

含有纯虚函数（函数声明后面以`=0`表示）的类是**抽象基类**。抽象基类负责定义接口，而后续的其他类可以覆盖该接口。不能直接创建一个抽象基类的对象。

# 访问控制与继承 #

一个类使用`protected`关键字来声明那些它希望与派生类分享但是不想被其他公共访问使用的成员。

*  和私有成员类似，受保护的成员对于类的用户来说是不可访问的。
 *  和公有成员类似，受保护的成员对于派生类的成员和友元来说是可访问的。
 *  派生类的成员或友元只能通过派生类对象来访问基类的受保护成员。派生类对于一个基类对象中的受保护成员没有任何访问特权。

class Base{
        
    protected:
    	int prot_mem; 
    };
    
    class Sneaky:public Base{
        
    	friend void clobber(Sneaky&); //能访问Sneaky::prot_mem
    	friend void clobber(Base&); //不能访问Base::prot_mem
    	int j; //j是默认Private
    }
    
    //正确：clobber能访问Sneaky对象的private和Protected成员
    void clobber(Sneaky&s) {
        s.j = s.prot_mem = 0;}
    
    //错误：clobber不能访问Base的protected成员
    void clobber(Base &b) {
         b.prot_mem = 0;}

不能继承友元关系，每个类负责控制各自成员的访问权限。

如果我们想要改变派生类继承的某个名字的访问级别，可以通过使用`using`声明来完成。`using`声明语句中名字的访问权限由该`using`声明语句之前的访问说明符来决定。派生类只能为那些它可以访问的名字提供`using`声明。

class Base{
        
    public:
    	std::size_t size() const {
         return n;}
    protected:
    	std::size_t n;
    }
    
    class Derived:private Base{
         //注意：private继承
    public:
    	using Base::size;
    protected:
    	using Base::n;
    }

若没有显式声明，则`struct`默认是`public`继承，而`class`默认是`private`继承。

class Base{
        
    public:
    	virtual int fcn() {
        cout << "Base::fcn" << endl;}
    };
    
    class D1: public Base{
        
    public:
    	//隐藏基类的fcn，这个fcn不是虚函数
    	//D1继承了Base::fcn()的定义
    	int fcn(int) {
        cout << "D1::fcn(int)" << endl;}   //形参列表与Base中的fcn不一致
    	virtual void f2() {
        cout << "D1::f2()" << endl;} //一个新的虚函数，在Base中不存在
    };
    
    class D2 : public D1{
        
    public:
    	int fcn(int)  {
        cout << "D2::fcn(int)" << endl;}  //是一个非虚函数，隐藏了D1::fcn(int)
    	int fcn() {
        cout << "D2::fcn()" << endl;} //覆盖了Base的虚函数fcn
    	void f2() {
        cout << "D2::f2()" << endl;} //覆盖了D1的虚函数f2
    };
     
    int main()
    {
        
    	Base bobj; D1 d1obj; D2 d2obj;
    	Base *bp1 = &bobj, *bp2 = &d1obj, *bp3 = &d2obj;
    
    	bp1->fcn(); //Base::fcn()
    	bp2->fcn(); //Base::fcn()
    	bp3->fcn(); //D2::fcn()
    
    	D1 *d1p = &d1obj;  D2 *d2p = &d2obj;
    	//bp2->f2(); //错误：Base没有名为f2的成员
    	d1p->f2(); //D1::f2()
    	d2p->f2(); //D2::f2()
    	
    	system("pause");
    	return 0;  
    }

![在这里插入图片描述][20200525111846312.png]

# 构造函数与拷贝控制 #

如果基类的析构函数不是虚函数，则`delete`一个指向派生类对象的基类指针将产生未定义的行为。

派生类的构造函数在其初始化阶段中不但要初始化派生类自己的成员，还负责初始化派生类对象的基类部分。因此，派生类的拷贝和移动构造函数在拷贝和移动自有成员的同时，也要拷贝和移动基类部分的成员。类似的，派生类的赋值运算符也必须为其基类部分的成员赋值。

class Base {
        /* ... */};
    class D : public Base{
        
    	//默认情况下，基类的默认构造函数初始化对象的基类部分
    	//要想使用拷贝或移动构造函数，我们必须在构造函数的初始值列表中
    	//显式的调用该构造函数
    	D(const D& d) : Base(d) //拷贝基类成员
    					{
        /* ... */}
    
    	D(D && d) : Base(std::move(d)) //移动基类成员
    					{
        /* ... */}
    
    	D& operator=(const D &rhs);
    }
    
    D &D::operator=(const D &rhs)
    {
        
    	Base::operator=(rhs); //为基类部分赋值
    	//按照过去的方式为派生类的的成员赋值
    	//酌情处理自赋值及释放已有资源等情况
    	return *this;
    }

派生类的析构函数只负责销毁由派生类自己分配的资源。对象销毁的顺序正好与其创建的顺序相反。派生类析构函数首先执行，然后是基类的析构函数，以此类推，沿着继承体系的反方向直至最后。

如果构造函数或析构函数调用了某个虚函数，则我们应该执行与构造函数或析构函数所属类型相对应的虚函数版本。

# 文本查询程序再探 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx_size_16_color_FFFFFF_t_70]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx_size_16_color_FFFFFF_t_70 1]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx_size_16_color_FFFFFF_t_70 3]

class QueryResult {
        
    friend std::ostream& print(std::ostream&, const QueryResult&);
    public:
    	typedef std::vector<std::string>::size_type line_no;
    	typedef std::set<line_no>::const_iterator line_it;
    	QueryResult(std::string s, 
    	            std::shared_ptr<std::set<line_no>> p, 
    	            std::shared_ptr<std::vector<std::string>> f):
    		sought(s), lines(p), file(f) {
         }
    	std::set<line_no>::size_type size() const  {
         return lines->size(); }
    	line_it begin() const {
         return lines->cbegin(); }
    	line_it end() const   {
         return lines->cend(); }
    	std::shared_ptr<std::vector<std::string>> get_file() {
         return file; }
    private:
    	std::string sought;  // word this query represents
    	std::shared_ptr<std::set<line_no>> lines; // lines it's on
    	std::shared_ptr<std::vector<std::string>> file;  //input file
    };

class QueryResult; // declaration needed for return type in the query function
    class TextQuery {
        
    public:
    #ifdef TYPE_ALIAS_DECLS
    	using line_no = std::vector<std::string>::size_type;
    #else
    	typedef std::vector<std::string>::size_type line_no;
    #endif
    	TextQuery(std::ifstream&);
        QueryResult query(const std::string&) const; 
        void display_map();        // debugging aid: print the map
    private:
        std::shared_ptr<std::vector<std::string>> file; // input file
        // maps each word to the set of the lines in which that word appears
        std::map<std::string, 
    	         std::shared_ptr<std::set<line_no>>> wm;  
    
    	// canonicalizes text: removes punctuation and makes everything lower case
        static std::string cleanup_str(const std::string&);
    };

// read the input file and build the map of lines to line numbers
    TextQuery::TextQuery(ifstream &is): file(new vector<string>)
    {
        
        string text;
        while (getline(is, text)) {
               // for each line in the file
    		file->push_back(text);        // remember this line of text
    		int n = file->size() - 1;     // the current line number
    		istringstream line(text);     // separate the line into words
    		string word;               
    		while (line >> word) {
                // for each word in that line
                word = cleanup_str(word);
                // if word isn't already in wm, subscripting adds a new entry
                auto &lines = wm[word]; // lines is a shared_ptr 
                if (!lines) // that pointer is null the first time we see word
                    lines.reset(new set<line_no>); // allocate a new set
                lines->insert(n);      // insert this line number
    		}
    	}
    }
    
    // not covered in the book -- cleanup_str removes
    // punctuation and converts all text to lowercase so that
    // the queries operate in a case insensitive manner
    string TextQuery::cleanup_str(const string &word)
    {
        
        string ret;
        for (auto it = word.begin(); it != word.end(); ++it) {
        
            if (!ispunct(*it))
                ret += tolower(*it);
        }
        return ret;
    }
    
    QueryResult
    TextQuery::query(const string &sought) const
    {
        
    	// we'll return a pointer to this set if we don't find sought
    	static shared_ptr<set<line_no>> nodata(new set<line_no>); 
    
        // use find and not a subscript to avoid adding words to wm!
        auto loc = wm.find(cleanup_str(sought));
    
    	if (loc == wm.end()) 
    		return QueryResult(sought, nodata, file);  // not found
    	else 
    		return QueryResult(sought, loc->second, file);
    }
    
    ostream &print(ostream & os, const QueryResult &qr)
    {
        
        // if the word was found, print the count and all occurrences
        os << qr.sought << " occurs " << qr.lines->size() << " "
           << make_plural(qr.lines->size(), "time", "s") << endl;
    
        // print each line in which the word appeared
    	for (auto num : *qr.lines) // for every element in the set 
    		// don't confound the user with text lines starting at 0
            os << "\t(line " << num + 1 << ") " 
    		   << *(qr.file->begin() + num) << endl;
    
    	return os;
    }
    
    // debugging routine, not covered in the book
    void TextQuery::display_map()
    {
        
        auto iter = wm.cbegin(), iter_end = wm.cend();
    
        // for each word in the map
        for ( ; iter != iter_end; ++iter) {
        
            cout << "word: " << iter->first << " {";
    
            // fetch location vector as a const reference to avoid copying it
            auto text_locs = iter->second;
            auto loc_iter = text_locs->cbegin(),
                            loc_iter_end = text_locs->cend();
    
            // print all line numbers for this word
            while (loc_iter != loc_iter_end)
            {
        
                cout << *loc_iter;
    
                if (++loc_iter != loc_iter_end)
                     cout << ", ";
    
             }
    
             cout << "}\n";  // end list of output this word
        }
        cout << endl;  // finished printing entire map
    }

// abstract class acts as a base class for concrete query types; all members are private
    class Query_base {
        
        friend class Query;  
    protected:
    #ifdef TYPE_ALIAS_DECLS
        using line_no = TextQuery::line_no; // used in the eval functions
    #else
        typedef TextQuery::line_no line_no; // used in the eval functions
    #endif
    
    #ifdef DEFAULT_FCNS
        virtual ~Query_base() = default;
    #else
    	virtual ~Query_base() {
         }
    #endif
    private:
        // eval returns the QueryResult that matches this Query
        virtual QueryResult eval(const TextQuery&) const = 0; 
        // rep is a string representation of the query
    	virtual std::string rep() const = 0;
    };
    
    // interface class to manage the Query_base inheritance hierarchy
    class Query {
        
        // these operators need access to the shared_ptr constructor
        friend Query operator~(const Query &);
        friend Query operator|(const Query&, const Query&);
        friend Query operator&(const Query&, const Query&);
    public:
        Query(const std::string&);  // builds a new WordQuery
    
        // interface functions: call the corresponding Query_base operations
        QueryResult eval(const TextQuery &t) const 
                                {
         return q->eval(t); }
    	std::string rep() const {
         return q->rep(); }
    private:
        Query(std::shared_ptr<Query_base> query): q(query) {
         }
        std::shared_ptr<Query_base> q;
    };
    
    inline 
    std::ostream &
    operator<<(std::ostream &os, const Query &query) 
    {
        
    	// Query::rep makes a virtual call through its Query_base pointer to rep() 
    	return os << query.rep(); 
    }
    
    class WordQuery: public Query_base {
        
        friend class Query; // Query uses the WordQuery constructor
        WordQuery(const std::string &s): query_word(s) {
         }
    
        // concrete class: WordQuery defines all inherited pure virtual functions
        QueryResult eval(const TextQuery &t) const
                         {
         return t.query(query_word); }
    	std::string rep() const {
         return query_word; }
        std::string query_word;   // word for which to search 
    };
    
    inline
    Query::Query(const std::string &s): q(new WordQuery(s)) {
         }
    
    class NotQuery: public Query_base {
        
        friend Query operator~(const Query &);
        NotQuery(const Query &q): query(q) {
         }
    
        // concrete class: NotQuery defines all inherited pure virtual functions
    	std::string rep() const {
        return "~(" + query.rep() + ")";}
        QueryResult eval(const TextQuery&) const;
        Query query;
    };
    
    //BinaryQuery未实现纯虚函数eval，因此仍是一个抽象基类，不能直接用于创建对象
    class BinaryQuery: public Query_base {
        
    protected:
        BinaryQuery(const Query &l, const Query &r, std::string s): 
              lhs(l), rhs(r), opSym(s) {
         }
    
        // abstract class: BinaryQuery doesn't define eval 
    	std::string rep() const {
         return "(" + lhs.rep() + " " 
    	                                     + opSym + " " 
    		                                 + rhs.rep() + ")"; }
    
        Query lhs, rhs;    // right- and left-hand operands
        std::string opSym; // name of the operator
    };
    
    class AndQuery: public BinaryQuery {
        
        friend Query operator&(const Query&, const Query&);
        AndQuery(const Query &left, const Query &right): 
                            BinaryQuery(left, right, "&") {
         }
    
        // concrete class: AndQuery inherits rep and defines the remaining pure virtual
        QueryResult eval(const TextQuery&) const;
    };
    
    class OrQuery: public BinaryQuery {
        
        friend Query operator|(const Query&, const Query&);
        OrQuery(const Query &left, const Query &right): 
                    BinaryQuery(left, right, "|") {
         }
    
        QueryResult eval(const TextQuery&) const;
    };
    
    inline Query operator&(const Query &lhs, const Query &rhs)
    {
        
        return std::shared_ptr<Query_base>(new AndQuery(lhs, rhs));
    }
    
    inline Query operator|(const Query &lhs, const Query &rhs)
    {
        
        return std::shared_ptr<Query_base>(new OrQuery(lhs, rhs));
    }
    
    inline Query operator~(const Query &operand)
    {
        
        return std::shared_ptr<Query_base>(new NotQuery(operand));
    }
    
    std::ifstream& open_file(std::ifstream&, const std::string&);
    TextQuery get_file(int, char**);
    bool get_word(std::string&);
    bool get_words(std::string&, std::string&);
    std::ostream &print(std::ostream&, const QueryResult&);

// returns the lines not in its operand's result set
    QueryResult
    NotQuery::eval(const TextQuery& text) const
    {
        
        // virtual call to eval through the Query operand 
        auto result = query.eval(text);
    
    	// start out with an empty result set
        auto ret_lines = make_shared<set<line_no>>();
    
    	// we have to iterate through the lines on which our operand appears
    	auto beg = result.begin(), end = result.end();
    
        // for each line in the input file, if that line is not in result,
        // add that line number to ret_lines
    	auto sz = result.get_file()->size();
        for (size_t n = 0; n != sz; ++n) {
        
    		// if we haven't processed all the lines in result
    		// check whether this line is present
    		if (beg == end || *beg != n) 
    			ret_lines->insert(n);  // if not in result, add this line 
    		else if (beg != end) 
    			++beg; // otherwise get the next line number in result if there is one
    	}
    	return QueryResult(rep(), ret_lines, result.get_file());
    }
    
    // returns the intersection of its operands' result sets
    QueryResult
    AndQuery::eval(const TextQuery& text) const
    {
        
        // virtual calls through the Query operands to get result sets for the operands
        auto left = lhs.eval(text), right = rhs.eval(text);
    
    	// set to hold the intersection of left and right
        auto ret_lines = make_shared<set<line_no>>();  
    
        // writes the intersection of two ranges to a destination iterator
        // destination iterator in this call adds elements to ret
        set_intersection(left.begin(), left.end(), 
                       right.begin(), right.end(),
                       inserter(*ret_lines, ret_lines->begin()));
        return QueryResult(rep(), ret_lines, left.get_file());
    }
    
    // returns the union of its operands' result sets
    QueryResult
    OrQuery::eval(const TextQuery& text) const
    {
        
        // virtual calls through the Query members, lhs and rhs 
    	// the calls to eval return the QueryResult for each operand
        auto right = rhs.eval(text), left = lhs.eval(text);  
    
    	// copy the line numbers from the left-hand operand into the result set
    	auto ret_lines = 
    	     make_shared<set<line_no>>(left.begin(), left.end());
    
    	// insert lines from the right-hand operand
    	ret_lines->insert(right.begin(), right.end());
    	// return the new QueryResult representing the union of lhs and rhs
        return QueryResult(rep(), ret_lines, left.get_file());
    }

# 练习 #

1.  **给定下面的类，解释每个`print`函数的机理：**

class base
    {
        
    public:
    	base(string s = "abc"):basename(s) {
        }
    
    	string name() {
        return basename;}
    	virtual void print(ostream &os) {
        os << basename;}
    
    private:
    	string basename;	
    };
    
    class derived:public base{
        
    public:
    	derived(int num=10, string s = "def"):base(s), i(num) {
        }
    
    	void print(ostream &os) override {
        print(os); os << " " << i;}
    private:
    	int i;
    };

应该尽量避免在类的成员函数的函数体中避免虚函数的问题，因为这会导致函数的自我调用，导致无限循环，此处派生类的`print()`函数中使用的`print()`函数会自动被解析为对自身的调用。所以应加上作用域限定符：

base::print(os);

修改后测试代码如下：

#include <iostream>
    #include <algorithm>
    #include <string>
     
    using namespace std;
    
    class base
    {
        
    public:
    	base(string s = "abc"):basename(s) {
        }
    
    	string name() {
        return basename;}
    	virtual void print(ostream &os) {
        os << basename;}
    
    private:
    	string basename;	
    };
    
    class derived:public base{
        
    public:
    	derived(int num=10, string s = "def"):base(s), i(num) {
        }
    
    	void print(ostream &os) override {
        base::print(os); os << " " << i;}
    private:
    	int i;
    };
    
     
    int main()
    {
        
    	base b;
    	derived d;
    
    	base *p1 = &b, *p2 = &d;
    
    	cout << "b.print(): "<< endl;
    	b.print(cout);  //输出abc
    	cout << endl;
    
    	cout << "d.print(): "<< endl;
    	d.print(cout); //输出def 10
    	cout << endl;
    
    	cout << "p1->print(): "<< endl;
    	p1->print(cout); //输出abc
    	cout << endl;
    
    	cout << "p2->print(): "<< endl;
    	p2->print(cout); //输出def 10
    	cout << endl;
    	
    	system("pause");
    	return 0;  
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx_size_16_color_FFFFFF_t_70 4]

1.  **假设定义了类定义如下，判断下面的赋值语句是否合法**

class Base
    {
        
    public:
    	void pub_mem(); //public成员
    
    protected:
    	int prot_mem; //protected成员
    
    private:
    	char priv_mem; //private成员
    	
    };
    
    struct Pub_Derv : public Base{
        
    	//正确：派生类能访问protected成员
    	int f() const {
         return prot_mem;}
    };
    
    struct Priv_Derv : private Base{
        
    	//private不影响本派生类对直接基类的访问权限
    	int f1() const {
        return prot_mem;}
    };
    
    struct Prot_Derv : protected Base{
        
    	int f2() const {
        return prot_mem;}
    };
    
    struct Derived_from_public : public Pub_Derv{
        
    	//正确:Base::prot_mem在Pub_Derv中仍然是protected的
    	int use_base() {
        return prot_mem;}
    };
    
    struct Derived_from_Private : public Priv_Derv{
        
    	//错误：Base::prot_mem在Priv_Derv中是private的
    	int use_base() {
        return prot_mem;}
    };
    
    struct Derived_from_Protected : public Prot_Derv{
        
    	//正确：Base::prot_mem在Priv_Derv中是protected的
    	int use_base() {
        return prot_mem;}
    };
    
    Pub_Derv d1;
    Priv_Derv d2;
    Prot_Derv d3;
    Derived_from_public dd1;
    Derived_from_Private dd2;
    Derived_from_Protected dd3;

Base *p = &d1;  //合法
    p = &d2; //不合法
    p = &d3; //不合法
    
    p = &dd1; //合法
    p = &dd2; //不合法
    p = &dd3; //不合法

*  假定B继承自A(无论B以什么方式继承A)，B的**成员函数和友元**都能使用派生类到基类的转换。
 *  B继承A的方式是**公有或者保护**，则B的**派生类的成员或友元**可以使用B到A的转换，若是私有继承则不行。
 *  只有当B继承A的方式是**公有**的时，**用户的代码**才能使用B到A的（派生类到基类）的转换，保护或者私有方式则不行

1.  **同第二题一样的类定义，若为每个子类都添加如下形式的成员函数，判断是否合法**

void memfcn(Base &b) {
         b = *this;}

`Derived_from_Private`不可以，因为当B继承A的方式是**公有或者保护**时，则B的**派生类的成员或友元**可以使用B到A的转换，若是私有继承则不行。

1.  **定义`Quote`和`Bulk_quote`的拷贝控制成员，令其与合成的版本行为一致。**

class Quote
    {
        
    	friend double print_total(ostream &, const Quote&, size_t);//定义为友元函数
    public:
    	/*	Quote() = default;//C++11新特性*/
    	Quote();//默认构造函数
    	
    	Quote(const string &book,double sales_price):BookNo(book),price(sales_price){
        };//构造函数
    	
    	Quote(const Quote& rhs) : BookNo(rhs.BookNo),price(rhs.price)//拷贝构造函数
    	{
        
    		cout<<"拷贝构造函数"<<endl;
    	}
    	
    	Quote& operator=(const Quote& rhs)//拷贝赋值运算符
    	{
        
    		if (this != &rhs)//防止自赋值的情况
    		{
        
    			BookNo = rhs.BookNo;
    			price = rhs.price;
    		}	
    		cout<<"拷贝赋值运算符"<<endl;
    		return *this;
    	}
    	
    	Quote(const Quote&& rhs) : BookNo(move(rhs.BookNo)), price(move(rhs.price))//移动构造函数
    	{
        
    		cout<<"移动构造函数"<<endl;
    	}
    	
    	Quote& operator=(const Quote&& rhs) noexcept//移动赋值运算符
    	{
        
    		if (this != &rhs)
    		{
        
    			BookNo = move(rhs.BookNo);
    			price = move(rhs.price);
    		}
    		cout<<"拷贝赋值运算符"<<endl;
    		return *this;
    	}
    	
    	string isbn() const{
        return BookNo;};//保存每本书籍的编号
    	
    	virtual double net_price(size_t n) const//定义为虚函数，让派生类自己定价
    	{
        
    		return n*price;
    	}
    	
    	virtual void debug()
    	{
        
    		cout<<"This is Quote Class"<<endl;
    		cout<<"ISBN: "<<BookNo<<endl;
    		cout<<"Price: "<<price<<endl;
    	}
     
    private:
    	string BookNo;//书籍的ISBN编号
    protected:
    	double price;//普通状态下不打折的价格，C++11不支持非静态变量的类内初始化
     
    };
    
    
    class bulk_quote : public Quote
    {
        
    public:
    	bulk_quote();//默认构造函数
    	
    	bulk_quote(string& book, double p, size_t n, double disc) : Quote(book,p),min_qty(n),discount(disc){
        };//派生类构造函数
     
    	bulk_quote(const bulk_quote& rhs) : Quote(rhs) {
        }//继承拷贝构造函数
    	
    	bulk_quote& operator=(const bulk_quote& rhs)
    	{
        
    		Quote::operator=(rhs);//继承拷贝赋值运算符
    		return *this;
    	}
    	
    	bulk_quote(const bulk_quote&& rhs) : Quote(move(rhs)){
        }//继承移动构造函数
    	
    	bulk_quote& operator=(const bulk_quote&& rhs)
    	{
        
    		Quote::operator=(move(rhs));//继承拷贝赋值运算符
    		return *this;
    	}
    	
    	//virtual double net_price(size_t) const;//重新声明，与下面的方式作用相同
    	double net_price(size_t cnt) const override//允许派生类显示的注明它将使用哪个成员函数改写基类的虚函数
    	{
        
    		if (cnt >= min_qty)
    		{
        
    			return cnt*(1-discount)*price;
    		} 
    		else
    		{
        
    			return cnt*price;
    		}
    	}
    	
    	void debug()
    	{
        
    		cout<<"This is bulk_quote Class"<<endl;
    		cout<<"DISCOUNT: "<<discount<<endl;
    		cout<<"Min_qty: "<<min_qty<<endl;
    		cout<<"Price: "<<price<<endl;
    	}
    	//除了自定义的版本，还可以访问其基类的相应成员
    private:
    	double discount;//折扣额，C++11新标准
    	size_t min_qty ;//适用折扣的最低购买量
    };

[20200525111846312.png]: https://img-blog.csdnimg.cn/20200525111846312.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200526103859502.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200526104017868.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200526104038282.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200525210823265.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200526120826497.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx,size_16,color_FFFFFF,t_70