句柄类与继承

/**
 * C++ 面向对象编程的一个颇具讽刺意味的地方是：不能使用对象支持面向对象编程，
 *相反，必须使用指针或引用，例如：
 */
void get_prices(Item_base object, const Item_base *pointer, const Item_base &reference)
{
    //下边的两个调用在运行时进行动态绑定
    cout << pointer->net_price(1) << endl;
    cout << reference.net_price(1) << endl;
    
    //下边的调用无论是基类还是子类都调用基类的成员函数
    cout << object.net_price(1) << endl;
}

 

指针型句柄练习：

//Basket.h
#ifndef BASKET_H
#define BASKET_H

#include "Sales_item.h"
#include <set>

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

class Basket
{
    //用于multiset元素排序的比较函数的类型---Comp是函数指针，指向的函数带有两个Sales_item类型的参数
    typedef bool (*Comp)(const Sales_item&, const Sales_item&);
public:
    //multiset成员的类型
    typedef std::multiset<Sales_item, Comp> set_type;
    //类型别名
    typedef set_type::size_type size_type;
    typedef set_type::const_iterator const_itor;
    
    Basket() : items(compare) {} //初始化比较器
    
    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;  // 返回购物篮中所有物品的总价格
private:
    std::multiset<Sales_item, Comp> items;
};

#endif

//定义compare函数和Basket类的实现文件如下：
//Basket.cpp

#include "Basket.h"

double Basket::total() const
{
    double sum = 0.0;    // holds the running total
    
    // 找到具有相同 ISBN 的每一组物品，根据其总数计算价格，itor指向 ISBN 相同的每一组中的第一个元素
    //    upper_bound 指向具有不同 ISBN 的下一个元素
    for(const_itor itor = items.begin(); itor != items.end(); itor = items.upper_bound(*itor))
    {
        sum += (*itor)->net_price(items.count(*itor));
    }
    return sum;
}

// 使用 Basket 类管理销售
#include "Basket.h"
#include "Sales_item.h"
#include <iostream>
using namespace std;

int main()
{
    Basket basket;
    Sales_item item1(Bulk_item("7-115-14554-7", 99, 20, 0.2));
    Sales_item item2(Item_base("7-115-14554-8", 39));
    Sales_item item3(Lds_item("7-115-14554-9", 50, 200, 0.2));
    Sales_item item4(Bulk_item("7-115-14554-7", 99, 20, 0.2));
    
    basket.add_item(item1);
    basket.add_item(item2);
    basket.add_item(item3);
    basket.add_item(item4);
    
    cout << basket.total() << endl;
    
    return 0;
}

// Item.h
//  定义Item_base类层次的头文件

#ifndef ITEM_H
#define ITEM_H
#include <string>

using namespace std;

// 不使用折扣策略的基类
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;
    }
    // 返回特定购书量的总价格---派生类将重载该函数以应用不同的折扣策略
    virtual double net_price(size_t n) const
    {
        return n * price;
    }
    
    virtual Item_base* clone() const
    {
        return new Item_base(*this);
    }
    
    virtual ~Item_base() {}
private:
    std::string isbn;
protected:
    double price;
};

//保存折扣率和可实行折扣策略的数量---派生类将使用这些数据实行定价策略
class Disc_item : public Item_base
{
public:
    Disc_item(const std::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) {}
                   
    double net_price(size_t) const = 0; //纯虚函数---该函数为后代类型提供了可以覆盖的接口，
                //但是这个类中的版本决不会调用，重要的是，用户将不能创建Disc_item类型的对象
    
    std::pair<size_t, double> discount_policy() const
    {
        return std::make_pair(quantity, discount);
    }
protected:
    size_t quantity;  //可实行折扣策略的购买量
    double discount;  // 折扣率
};

// 批量购买折扣类
class Bulk_item : public Disc_item
{
public:
    Bulk_item(const std::string& book = "", double sales_price = 0.0,
              size_t qty = 0, double disc_rate = 0.0) :
                    Disc_item(book, sales_price, qty, disc_rate) {}
                    
    // 重定义基类版本以实行批量购买折扣策略：若购书量高于下限，则使用折扣价格
    double net_price(size_t cnt) const
    {
        if(cnt >= quantity)
            return cnt * (1-discount) * price;
        else
            return cnt * price;
    }
    
    virtual Bulk_item* clone() const
    {
        return new Bulk_item(*this);
    }
};

//有限折扣类
class Lds_item : public Disc_item
{
public:
    // 构造函数
    Lds_item(const std::string& book = "", double sales_price = 0.0,
              size_t qty = 0, double disc_rate = 0.0) :
                    Disc_item(book, sales_price, qty, disc_rate) {}
                    
    // 重定义基类版本以实现有限折扣策略---对低于上限的购书量使用折扣价格
    double net_price(size_t cnt) const
    {
        if(cnt <= quantity)
            return cnt * (1 - discount) * price;
        else
            return cnt * price - quantity * discount * price;
    }
    
    virtual Lds_item* clone() const
    {
        return new Lds_item(*this);
    }
};

#endif

// Sales_item.h---Sales_item 类的头文件

#ifndef SALESITEM_H
#define SALESITEM_H
#include "Item.h"

// 用于Item_base 层次的使用计数式句柄类
class Sales_item
{
public:
    // 默认构造函数：创建未绑定的句柄
    Sales_item() : p(0), use(new std::size_t(1)) { }
    
    // 将创建绑定到Item_base对象副本的句柄
    Sales_item(const Item_base& item) : p(item.clone()), use(new std::size_t(1)) { }
    
    // 复制控制成员管理使用计数和指针
    Sales_item(const Sales_item &i) : p(i.p), use(i.use) { ++*use; };
    ~Sales_item() { decr_use(); }
    Sales_item& operator = (const Sales_item);
    
    //成员访问操作符
    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;    //指向共享Item_base对象的指针
    std::size_t *use;  //指向共享使用计数的指针
    
    // 为析构函数和赋值操作符所用的辅助函数
    void decr_use()
    {
        if(--*use == 0)
        {
            delete p;
            delete use;
        }
    }
};
#endif

// Sales_item.cpp---Sales_item 类的实现文件（源文件）
#include "Sales_item.h"

Sales_item& Sales_item::operator = (const Sales_item &rhs)
{
    ++*use;
    decr_use();
    p = rhs.p;
    use = rhs.use;
    return *this;
}