多态绑定

#include <iostream>
#include <string>

using namespace std;

class Item_base
{
public:
	//int x;
	Item_base(const string &book = "", double sales_price = 0.0) : isbn(book),price(sales_price){}
	string book() const  // 这里是为了显示isbn，
	{
		return isbn;
	}
	virtual double net_price(size_t n) const // 这里是定义成一个虚函数”virtual“，
	{
		return n * price;
	}

private:
	string isbn;
protected:  //  这是受保护的成员，专门用于继承的，
	double price; // 
};

class Bulk_item : public Item_base  // 可以继承Item_base的公有部分以及专门用于继承的，
{
public:
	Bulk_item(const string &book = "",double sales_price = 0.0,size_t qty = 0, double disc_rate = 0.0)
		: Item_base(book,sales_price),min_qty(qty),discount(disc_rate) {}

    double net_price(size_t cnt) const  // 这里是继承了一个函数，被集成的函数必须是虚函数，
	{
		if(cnt > min_qty)
			return cnt * (1 - 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() << "\tnumber sold:" << n << "\ttoal price:" << item->net_price(n) << endl; // 这里的net_price是一个多态的，根据指针来确定指向的是那一个，
}

int main()
{
	Item_base* a = new Item_base("1-2222-01",11.0);  // 引用或指针既可以指向基类对象，也可以指向派生类对象，
	// 只有通过引用或指针调用虚函数才会发生动态的绑定，
	Bulk_item* b = new Bulk_item("1-2222-02",22.0,2,0.15);  

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

    Item_base* books[5];
	books[0] = new Item_base("0-123-0",10.0);
	books[1] = new Bulk_item("0-123-1",10.0,5,0.06);
	books[2] = new Item_base("0-123-2",30.0);
	books[3] = new Bulk_item("0-123-3",40.0,4,0.16);
	books[4] = new Bulk_item("0-123-4",50.0,3,0.26);
	

	int num[5];
	num[0] = 2;
	num[1] = 10;
	num[2] = 5;
	num[3] = 3;
	num[4] = 8;

	for(int i = 0; i < 5; i++)
	{
		print_total(cout, books[i], num[i]);
	}

	return 0;
}