Debug Assertion Failed!求解！

各位好，我的代码在vc上运行时出了这个问题：
Debug Assertion Failed!
Expression: _BLOCK_TYPE_IS_VALID(pHead->nBlockUse)

我知道这么长的代码发到这边很不合适，但我也没办法了，找不到问题，只好请各位帮忙，谢过！
#include "stdafx.h"
#include <vector>
#include <deque>
#include <list>
#include <string>
#include <algorithm>
#include <iterator>
#include <numeric>
#include <time.h>
#include <set>
#include <map>
#include <functional>
using namespace std;
#define LENGTH(s) (sizeof(s)/sizeof(s[0]))

// Item sold at an undiscounted price
// derived classes will define various discount strategies
class Item_base {
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; }
virtual ~Item_base() { }
virtual Item_base* clone() const{return new Item_base(*this);}
private:
std::string isbn; // identifier for the item
protected:
double price; // normal, undiscounted price
};
// discount kicks in when a specified number of copies of same book are sold
// the discount is expressed as a fraction used to reduce the normal price
class Bulk_item : public Item_base {
public:
// redefines base version so as to implement bulk purchase discount policy
double net_price(std::size_t) const;
Bulk_item(const std::string& book,double sales_price,std::size_t qty=0,double disc_rate=0.0):
Item_base(book,sales_price),min_qty(qty),discount(disc_rate){}
virtual Bulk_item* clone() const{return new Bulk_item(*this);}
private:
std::size_t min_qty; // minimum purchase for discount to apply
double discount; // fractional discount to apply
};
double Bulk_item::net_price(size_t cnt) const
{
if (cnt >= min_qty)
return cnt * (1 - discount) * price;
else
return cnt * price;
}


// use counted handle class for the Item_base hierarchy
class Sales_item {
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
{
if (p) return p;
else throw std::logic_error("unbound Sales_item");
}
const Item_base &operator*() const
{
if (p) return *p;
else throw std::logic_error("unbound Sales_item");
}
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; } }
};
Sales_item::Sales_item(/*const*/ Item_base& item):p(/*item.clone()*/&item),use(new std::size_t(1))
{

}
// 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;

}
inline bool
compare(const Sales_item &lhs, const Sales_item &rhs)
{
return lhs->book() < rhs->book();
}

class Basket {
// type of the comparison function used to order the multiset
typedef bool (*Comp)(const Sales_item&, const Sales_item&);
public:
// make it easier to type the type of our set
typedef std::multiset<Sales_item, Comp> set_type;
// typedefs modeled after corresponding container types
typedef set_type::size_type size_type;
typedef set_type::const_iterator const_iter;
Basket(): items(compare) { } // initialze the comparator
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
private:
std::multiset<Sales_item, Comp> items;
};
double Basket::total() const
{
double sum = 0.0; // holds the running total

/* find each set of items with the same isbn and calculate
* the net price for that quantity of items
* iter refers to first copy of each book in the set
* upper_bound refers to next element with a different isbn
*/
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
// virtual call to net_price applies appropriate discounts, if any
sum += (*iter)->net_price(items.count(*iter));
}
return sum;
}

int main()
{
Bulk_item bi("visual c++",58,3,0.5);
Sales_item si(bi);
Basket basket;
basket.add_item(si);
basket.add_item(si);
basket.add_item(si);
//basket.add_item(*(new Sales_item(*(new Item_base("think in java",32)))));
cout<<"cout:"<<basket.size(bi)<<"total:"<< basket.total()<<endl;
}