C++学习总结

一、static类成员

1、static类成员是与类相关联的，类定义时就存在，它独立于类的任何对象而存在。因此可以通过类、类的对象、类的对象指针、类的对象的引用来访问，同时也说明了他没有this指针。

2、static相当于一个全局变量。但是它可以是私有的（可以实施封装）。

3、static成员不是通过类构造函数进行初始化，而是应该在定义时进行初始化。

4、static 成员函数不能被声明为 const（注意，是成员函数，不是成员变量，成员变量可以为static const类型）。毕竟，将成员函数声明为const 就是承诺不会修改该函数所属的对象。

5、static 成员函数也不能被声明为虚函数。

二、纯虚函数

1、在函数形参表后面写上 = 0 以指定纯虚函数：

     class Disc_item : public Item_base {
     public:
         double net_price(std::size_t) const = 0;
     };

2、定义了纯虚函数后，包含该纯虚函数的类将无法实例化，只能被其他类继承（抽象基类）。

3、派生类如果继承了抽象基类，而在该派生类中没有对此纯虚函数进行定义   则该派生类扔为抽象类 不能用它实体定义对象 

三、容器与继承

1、句柄的引入

如果定义 multiset 保存基类类型的对象：

     multiset<Item_base> basket;
     Item_base base;
     Bulk_item bulk;
     basket.insert(base);  // ok: add copy of base to basket
     basket.insert(bulk);  // ok: but bulk sliced down to its base part

一旦对象放入了 multiset，它就不再是派生类对象了。容器中加入派生类型的对象时，只将对象的基类部分保存在容器中。记住，将派生类对象复制到基类对象时，派生类对象将被切掉

2、定义句柄类

句柄类将有两个数据成员，都是指针：一个指针将指向 基类 对象，而另一个将指向使用计数。句柄类 指针可以指向 基类对象也可以指向基类的 派生类型的对象。通过指向使用计数，多个 句柄类 对象可以共享同一计数器。（类似于智能指针）

3、句柄类与容器

#include <iostream>  
#include <string>  
#include <set>
using namespace std;  

class Item_base
{  
public: 
    Item_base(const string &book = "", double sales_price = 0.0):isbn(book), price(sales_price){};//构造函数
	Item_base(const Item_base &other)
	{
		isbn = other.isbn;
		price = other.price;
	}
	virtual Item_base* clone() const//为了使句柄类能够复制未知类型而定义
    { 
		return new Item_base(*this); 
	};

	string book() const
	{
		return isbn;
	};

	virtual double net_price(size_t n) const//打折后的价格
	{
		return n*price;
	}; 

	virtual ~Item_base();
private:  
    string isbn;
protected:
    double price;  
};  

class Disc_item : public Item_base  //Disc_item为虚基类
{
public:
	Disc_item(const string & book = "", double sales_price = 0.0, size_t qty = 0, double disc_rate = 0.0):
		Item_base(book, sales_price), quantity(qty), discount(disc_rate){};
	~Disc_item();
protected:
	size_t quantity; // purchase size for discount to apply
    double discount;      // fractional discount to apply
	//纯虚函数，该类无法实例化，只能被其他类继承
	double net_price(size_t) const = 0;//discount
};

class Bulk_item : public Disc_item
{
//1、派生类的构造函数：
//派生类构造函数只能初始化自己的直接基类，在 Bulk_item 类的构造函数初始化列表中指定 Item_base 是一个错误。
public:
	Bulk_item(const string& book = "", double sales_price = 0.0, size_t qty = 0, double disc_rate = 0.0):
		Disc_item(book, sales_price, qty, disc_rate) { };
	~Bulk_item();
	
	Bulk_item* clone() const//为了使句柄类能够复制未知类型而定义
	{ 
		return new Bulk_item(*this); 
	}

//2、关于派生类的复制构造函数：
//只包含类类型或内置类型数据成员、不含指针的类一般可以使用合成操作，复制、赋值或撤销这样的成员不需要特殊控制。
//具有指针成员的类一般需要定义自己的复制控制来管理这些成员
protected:
	double net_price(size_t n) const
	{
		return n*price;
	};
private:
};

class Sales_item  //句柄类 use counted handle class for the Item_base hierarchy
{
public:
	// default constructor: unbound handle
	Sales_item(): p(0), use(new size_t(1)) { };
	
	// 句柄的复制构造函数，attaches a handle to a copy of the Item_base object
	//为了句柄类，需要从基类开始，在继承层次的每个类型中增加 clone，基类必须将该函数定义为虚函数
	Sales_item(const Item_base &item):p(item.clone()), use(new size_t(1)) { };

	// 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 &rhs) // use-counted assignment operator; use is a pointer to a shared use count
	{
		++*rhs.use;
		decr_use();
		p = rhs.p;
		use = rhs.use;
		return *this;
	};

	// 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"); 
	}
	// 比较函数，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();
	}

private:
	Item_base *p;        // pointer to shared item
	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; 
		} 
	}
};

class Basket//跟踪销售并计算购买价格 
{
	typedef bool (*Comp)(const Sales_item&, const Sales_item&);//这个语句将 Comp 定义为函数类型指针的同义词，该函数类型与我们希望用来比较 Sales_item 对象的比较函数相匹配。
public:
	// make it easier to type the type of our set
	typedef 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; // 返回购物篮中所有物品的价格
	{
		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;
	}
private:
	multiset<Sales_item, Comp> items;
};

int main()
{
	Item_base base("0-201-82470-1", 20);
//  Disc_item无法实例化
//	Disc_item Disc("0-201-82470-1", 20, 19, 19);
	
	Bulk_item bulk("0-201-82470-1", 20, 19, 19);
	multiset <Sales_item> basket;//购物车
	basket.insert(base);
	basket.insert(bulk);
	cout<<base.book();
	return 0;
}