class Quote
{
public:
    Quote()=default;
    Quote(const string &book, double sales_price):bookNo(book), price(sales_price)
     {cout<<"Quote gouzhao function"<<endl;}
    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;       //不打折的价格

};

//继承，如何继承？
class Bulk_quote : public Quote
{
public:
    Bulk_quote()=default;
    Bulk_quote(const string & book, double p, size_t qty, double disc)
    : Quote(book, p), min_qty(qty), discount(disc)
    {cout<<"Bulk_quote construct function"<<endl;}
    //重写虚函数
    double net_price(size_t n) const override {cout<<"double net_price(size_t)"<<endl; return n*price;}
    //再次说明，请声明函数后一定要记得定义它，不然我这是出了各种莫名其妙的错误！
//    ~Bulk_quote2(){cout<<"~Bulk_quote2()"<<endl;}
private:
    size_t min_qty=0;
    double discount=0.0;
};

There Is No Implicit Conversion from Base to Derived ...

void fun1()
{
    Quote base;
//    Bulk_quote* bulkP=&base;    错误不能把基类转换成派生类
//    Bulk_quote& bulkRef=base;    同上
    Bulk_quote bulk;
    Quote *itemP=&bulk;     //派生类转换成基类
//    Bulk_quote *bulkP=itemP;    error:基类到派生类
}

...and No Conversion between Objects

void fun2()
{
    Bulk_quote bulk;    //派生类
    Quote item(bulk);   //调用基类Quote的赋值构造函数
    item=bulk;          // calls Quote::operator=(const Quote&)拷贝赋值运算符
}

这里当我们的参数对象是基类的时候，转换的时候只有基类部分会被拷贝，而派生的那部分
会直接被忽略

double print_total(ostream &os, const Quote &item, size_t n)
{
    //根据不同的对象来绑定到这个参数的类型
    //这里引用Quote::net_price 或 Bulk_quote::net_price
    double ret=item.net_price(n);
    os<<"ISBN: "<<item.isbn()   //调用 Quote::isbn
      <<" # sold: "<<n<<" total due: "<<ret<<endl;

    return ret;     //这里上面的Quote参数是可以接受Quote或者Bulk_quote类型的
}

Calls to Virtual Functions May Be Resolved at Run Time
调用的虚函数可以在运行时确定

void fun3()
{
    Quote base("0-201-82470-1", 50);
    print_total(cout, base, 10);    //调用Quote的net_price
    Bulk_quote derived("0-201-82470-1", 50, 5, 0.19);
    print_total(cout, derived, 10); //调用Bulk_quote的net_price
    base=derived;   //吧quote类型的部分拷贝到base
    base.net_price(20);
}

Virtual Functions in a Derived Class(【派生类中的虚函数)

struct B
{
    virtual void f1(int) const;
    virtual void f2();
    void         f3();
};

struct D1 : B   //这是什么继承？
{
    void    f1(int) const   override;   //ok可以覆盖
//    void    f2(int) override;   error没有f2(int)这个虚函数
//    void    f3()    override;      //error:f3()不是虚函数
//    void    f4()    override;       error:没有f4()这个虚函数
};

final这个关键字

struct D2 : B
{
    //从B继承f2,f3之后我们override f1
    void f1(int) const final;   //之后派生类无法覆盖f1
};

struct D3 : D2
{
    void f2();
//    void f1(int) const; //注意：这个函数是被final修饰的函数
};

Virtual Functions and Default Arguments(虚函数和默认参数)

void fun4()
{
    cout<<"there is fun4"<<endl;
    Quote *baseP;

    double undiscounted = baseP->Quote::net_price(42);
}

Ordinarily, only code inside member functions (or friends) should need to use
the scope operator to circumvent the virtual mechanism
通常只有类里面的成员函数（友元函数）需要使用作用域操作符来规避虚拟机制

class Disc_quote : public Quote
{
public:
    Disc_quote()=default;
    Disc_quote(const string & book, double price, size_t qty, double disc):
        Quote(book, price), quantity(qty), discount(disc) {cout<<"Disc_quote构造函数"<<endl;}
    double net_price(size_t) const = 0; //纯虚函数
protected:
    size_t quantity=0;
    double discount=0.0;
};

纯虚函数不能直接在类里面进行定义，要定义就要在外面
virtual void Move(int nx, int ny) = 0;
void BaseEllipse::Move(int nx, int ny) {x = nx; y = ny;}
这样是允许的

void fun5()
{
    cout<<"there is fun5"<<endl;
//    Disc_quote discount;    //error:Disc_quote是一个抽象类，含有纯虚函数没法实例化
    Bulk_quote bulk;        //ok,这个里面没有纯虚函数，不是抽象类
}

A Derived Class Constructor Initializes Its Direct Base Class Only
就是派生类参数列表可以直接初始化基类

class Bulk_quote2 : public Disc_quote
{
public:
    Bulk_quote2()=default;
    //直接初始化
    Bulk_quote2(const string& book, double price, size_t qty, double disc):
        Disc_quote(book, price, qty, disc) {}
    double net_price(size_t) const override;    //覆盖纯虚函数
};