#ifndef BASKET_H
#define BASKET_H

#include <iostream>
#include <string>
#include <set>
#include <map>
#include <utility>
#include <cstddef>

// Item sold at an undiscounted price
// derived classes will define various discount strategies
class Item_base {
	friend std::istream& operator>>(std::istream&, Item_base&);
	friend std::ostream& operator<<(std::ostream&, const Item_base&);
public:
	virtual Item_base* clone() const 
	{
		return new Item_base(*this); 
	}
public:
	Item_base(const std::string &book = "", double sales_price = 0.0):
	          isbn(book), price(sales_price) { }

	std::string book() const { return isbn; }

	// returns total sales price for a specified number of items
	// derived classes will override and apply different discount algorithms
	virtual double net_price(std::size_t n) const 
	{ 
		return n * price; 
	}

	// no work, but virtual destructor needed 
	// if base pointer that points to a derived object is ever deleted
	virtual ~Item_base() { } 
private:
	std::string isbn;   // identifier for the item
protected:
	double price;       // normal, undiscounted price
};

// class to hold discount rate and quantity 
// derived classes will implement pricing strategies using these data
class Disc_item : public Item_base
{
public:
	std::pair<size_t, double> discount_policy() const
	{ 
		return std::make_pair(quantity, discount); 
	}
	// other members as before
	double net_price(std::size_t) const = 0; //声明为纯虚函数
	Disc_item(const std::string& book = "", double sales_price = 0.0, std::size_t qty = 0, double disc_rate = 0.0):
					Item_base(book, sales_price), quantity(qty), discount(disc_rate) { }
protected:
	std::size_t quantity;  // purchase size for discount to apply
	double discount;       // fractional discount to apply
};

// discount kicks in when a specified number of copies of same book are sold
// the discount is expressed as a fraction to use to reduce the normal price
class Bulk_item : public Disc_item {
public:
	std::pair<size_t, double> discount_policy() const
	{ 
		return std::make_pair(quantity, discount); 
	}
	// other members as before
	Bulk_item* clone() const 
	{ 
		return new Bulk_item(*this); 
	}
	Bulk_item(const std::string& book = "", double sales_price = 0.0, std::size_t qty = 0, double disc_rate = 0.0):
				Disc_item(book, sales_price, qty, disc_rate) { }

	// redefines base version so as to implement bulk purchase discount policy
	double net_price(std::size_t) const;
};

// discount (a fraction off list) for only a specified number of copies, 
// additional copies sold at standard price
class Lim_item : public Disc_item {
public:
	Lim_item(const std::string& book = "", double sales_price = 0.0, std::size_t qty = 0, double disc_rate = 0.0):
	Disc_item(book, sales_price, qty, disc_rate) { }

	// redefines base version so as to implement limited discount policy
	double net_price(std::size_t) const;
	Lim_item* clone() const 
	{ 
		return new Lim_item(*this); 
	}
	std::pair<size_t, double> discount_policy() const
	{ 
		return std::make_pair(quantity, discount); 
	}
};

// use counted handle class for the Item_base hierarchy，句柄类
class Sales_item {
	// let compare use the Item_base pointer to use Item_base compare function

	// this friend is needed for the hidden call to print_total, 
	friend class Basket;   
public:
	// default constructor: unbound handle
	Sales_item(): p(0), use(new std::size_t(1)) { }
	// attaches a handle to a copy of the Item_base object
	Sales_item(const Item_base&); 

	// copy control members to manage the use count and pointers
	Sales_item(const Sales_item &i): p(i.p), use(i.use) 
	{
		++*use; 
	}
	~Sales_item()
	{ 
		decr_use(); 
	}
	Sales_item& operator=(const Sales_item&);

	// member access operators
	const Item_base *operator->() const 
	{ 
		return p; 
	}
	const Item_base &operator*() const 
	{ 
		return *p; 
	}
private:
	Item_base *p;         // pointer to shared item
	std::size_t *use;     // pointer to shared use count

	// called by both destructor and assignment operator to free pointers
	void decr_use() 
	{ 
		if (--*use == 0) 
		   {
			   delete p; 
			   delete use;
		   } 
	}
};

bool compare(const Sales_item &, const Sales_item &);
// holds items being purchased
class Basket {
	// type of the comparison function used to order the multiset
	typedef bool (*Comp)(const Sales_item&, const Sales_item&);
	std::multiset<Sales_item, Comp> items;
public:
	// useful typedefs modeled after corresponding container types
	typedef std::multiset<Sales_item, Comp>::size_type size_type;
	typedef std::multiset<Sales_item, Comp>::const_iterator const_iter;

	// workaround MS compiler bug: must explicitly pass function address
	Basket(): items(&compare) { }  // initialze the comparator
	void display(std::ostream&) const;

	void add_item(const Sales_item &item) 
	{ 
		items.insert(item); 
	}
	size_type size(const Sales_item &i) const
	{ 
		return items.count(i); 
	}
	double total() const;  // sum of net prices for all items in the basket
};

inline
Sales_item::Sales_item(const Item_base &item):p(item.clone()), use(new std::size_t(1)) { }

// compare defines item ordering for the multiset in Basket
inline bool 
compare(const Sales_item &lhs, const Sales_item &rhs) 
{
	return lhs->book() < rhs->book();
} 

#endif

#include <algorithm>
using std::multiset; using std::map; using std::pair; using std::size_t;
using std::string; using std::ostream; using std::endl; using std::min;
using std::cout;

// debugging routine to check contents in a Basket
void Basket::display(ostream &os) const
{
	os << "Basket size: " << items.size() << endl;

	// print each distinct isbn in the Basket along with
	// count of how many copies are ordered and what their price will be
	// upper_bound returns an iterator to the next item in the set
	for (const_iter next_item = items.begin();
		next_item != items.end();
		next_item = items.upper_bound(*next_item))
	{
		// we know there's at least one element with this key in the Basket
		os << (*next_item)->book() << " occurs " 
			<< items.count(*next_item) << " times" 
			<< " for a price of " 
			<< (*next_item)->net_price(items.count(*next_item)) 
			<< endl;
	}
}

void print_total(ostream &, const Item_base&, size_t);

// calculate and print price for given number of copies, applying any discounts 
void print_total(ostream &os, 
				 const Item_base &item, size_t n)
{
	os << "ISBN: " << item.book() // calls Item_base::book
		<< "\tnumber sold: " << n << "\ttotal price: "
		// virtual call: which version of net_price to call is resolved at run time
		<< item.net_price(n) << endl;
}

double Basket::total() const
{
	double sum = 0.0;    // holds the running total 


	for (const_iter iter = items.begin(); 
		iter != items.end();
		iter = items.upper_bound(*iter))
	{
		// we know there's at least one element with this key in the Basket
		print_total(cout, *(iter->p), items.count(*iter));
		// virtual call to net_price applies appropriate discounts, if any
		sum += (*iter)->net_price(items.count(*iter));
	}
	return sum;
}

// use-counted assignment operator; use is a pointer to a shared use count
Sales_item&
Sales_item::operator=(const Sales_item &rhs)
{
	++*rhs.use;
	decr_use();
	p = rhs.p;
	use = rhs.use;
	return *this;
}

// if specified number of items are purchased, use discounted price 
double Bulk_item::net_price(size_t cnt) const
{
	if (cnt >= quantity)
		return cnt * (1 - discount) * price;
	else
		return cnt * price;
}

// use discounted price for up to a specified number of items
// additional items priced at normal, undiscounted price
double Lim_item::net_price(size_t cnt) const
{
	size_t discounted = min(cnt, quantity);
	size_t undiscounted = cnt - discounted;
	return discounted * (1 - discount) * price 
		+ undiscounted * price;
}

int main()
{
	//...
	return 1;
}