cc26a_demo-CppPrimer_动态绑定_多态-代码示范

//多态性
    //从派生类到基类的转换
    //引用或者指针既可以指向基类对象，也可以指向派生类对象
    //只有通过引用或者指针调用虚函数才会发生动态绑定。
    //为什么定义虚的函数？可以重新定义。只有虚函数才可以重写，（基类或者派生类里面）

////动态绑定的方法，执行出来的效果，就是多态

 #include <iostream>//txwtech-202001
 #include <string>//多态，动态绑定

 using namespace std;//导入名称空间

 class Animal
 {
     //成员略
 };

 class Dog :public Animal
 {
     //成员略
 };
 class Cat :public Animal
 {

 };
 class Item_base
 {
 public:
     //int x;
     Item_base(const std::string &book = "",
         double sales_price = 0.0) :isbn(book), price(sales_price) {}//构造函数
     std::string book() const
     {
         return isbn;
     }
     virtual double net_price(size_t n) const//为什么定义虚的函数？可以重新定义。只有虚函数才可以重写
     {
         return n * price;
     }

 private://类的内部使用
     std::string isbn;
 protected://专门用来做继承用的
     double price;

 };
 class Bulk_item :public Item_base
 {
 public:
     Bulk_item(const std::string &book = "", double sales_price = 0.0,
         size_t qty = , double disc_rate = 0.0) :
         Item_base(book, sales_price), min_qty(qty), discount(disc_rate) {}
     void test()
     {
         //cout << x << endl;
         cout << price << endl;
         //cout << isbn << endl;
     }
     void test2(const Bulk_item &d, const Item_base &b)
     {
         //cout << d.x << endl;
         cout << d.price << endl;
         //cout << b.x << endl;
         //cout << b.price << endl;
     }
     double net_price(size_t cnt) const//继承函数时，这里可以重定义，继承函数
     {
         if (cnt >= min_qty)
             return cnt * ( - discount)*price;
         else
             return cnt * price;

     }

 private:
     size_t min_qty;
     double discount;

 };
 //做一个函数
 void print_total(ostream &os, Item_base *item, size_t n)
 {
     os << "ISBN: " << item->book() << "\t number sold: " << n << "\ttotal price: " << item->net_price(n) << endl;
     //item->net_price(n)代码就是多态的
 }
 int main()
 {
     //Animal a;
     //Dog d;
     //Cat c;
     //Item_base item("0-12-3456-789", 9.9);
     //cout << item.book() << ": " << item.net_price(10) << endl;
     ////cout << item.x << endl;
     ///*cout << item.isbn << endl;
     //cout << item.price << endl;*/
     ////cout << "hello111" << endl;
     //Bulk_item item2("0-12-3456-789", 9.9, 10, 0.12);
     ////cout << item2.x << endl;
     //cout << item2.book() << ": " << item2.net_price(10) << endl;
     //item2.test();
     //item2.test2(item2, item);

     //多态，动态绑定的实现

     Item_base* a = new Item_base("1-234-567-01",11.0);
     Bulk_item* b = new Bulk_item("1-234-567-02",22.0,,0.05);//指向子类对象的指针

     print_total(cout,a,);
     print_total(cout,b,);

     Item_base* books[];//指针数组，5个指针
     books[] = new Item_base("0-123-456-01",10.0);//new 创建基类对象
     books[] = new Bulk_item("0-123-456-01", 20.0,,0.05);//new 也可以指向派生类对象
     books[] = new Item_base("0-123-456-03", 30.0);//new 创建基类对象
     books[] = new Bulk_item("0-123-456-04", 40.0, , 0.15);//new 也可以指向派生类对象
     books[] = new Bulk_item("0-123-456-05", 50.0, , 0.18);//new 也可以指向派生类对象

     int num[];
     num[] = ;
     num[] = ;
     num[] = ;
     num[] = ;
     num[] = ;

     for (int i = ; i < ; i++)
     {
         print_total(cout,books[i],num[i]);
         //动态绑定的方法，执行出来的效果，就是多态
     //根据指针所指向的对象不同，指向不同的对象，对象去调用不同的虚函数。有可能是基类，有可能是
     //派生类的。
     }
     //分别调用基类的netprice与派生类的Netprice. netprice就是多态，根据对象决定（基类不打折，派生类打折）
     //比如飞机在飞，鸟儿也在非，不同的飞

     getchar();
     return ;

     //多态性
     //从派生类到基类的转换
     //引用或者指针既可以指向基类对象，也可以指向派生类对象
     //只有通过引用或者指针调用虚函数才会发生动态绑定。
     //为什么定义虚的函数？可以重新定义。只有虚函数才可以重写，（基类或者派生类里面）
 }