C++ Primer 学习笔记_72_面向对象编程 -句柄类与继承[续]

面向对象编程

--句柄类与继承[续]

三、句柄的使用

使用Sales_item对象可以更容易地编写书店应用程序。代码将不必管理Item_base对象的指针,但仍然可以获得通过Sales_item对象进行的调用的虚行为。

1、比较两个Sales_item对象

在编写函数计算销售总数之前,需要定义比较Sales_item对象的方法。要用Sales_item作为关联容器的关键字,必须能够比较它们。关联容器默认使用关键字类型的小于操作符,但是如果给Sales_item定义小于操作符，将使其含义不明；

幸好，关联容器使我们能够指定一个函数[或函数对象]用作比较函数。而且，在定义容器对象时必须提供比较函数。

定义一个函数用于比较Sales_item对象：

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

该函数使用Sales_item的->操作符，该操作符返回Item_base对象的指针，哪个指针用于获取并运行成员的book操作，该成员返回ISBN。

2、使用带比较器的关联容器

对于比较函数，它必须作为容器的一部分而存储，任何在容器中增加或查找元素的操作都要使用比较函数。

要有效地工作,关联容器需要对每个操作使用同一比较函数。然而,期望用户每次记住比较函数是不合理的,尤其是,没有办法检查每个调用使用同一比较函数。因此,容器记住比较函数是有意义的。通过将比较器存储在容器对象中,可以保证比较元素的每个操作将一致地进行。

为了存储比较器,它需要知道比较器类型。形参类型也不需要与 key_type完全匹配,应该允许可以转换为key_type的任意形参类型。

所以,要使用Sales_item的比较函数,在定义multiset时必须指定比较器类型。在我们的例子中,比较器类型是接受两个constSales_item 引用并返回bool值的函数。

typedef bool (*Comp)(const Sales_item &,const Sales_item &);

将Comp定义为函数类型指针的同义词,该函数类型与我们希望用来比较 Sales_item对象的比较函数相匹配。

接着需要定义multiset,保存Sales_item类型的对象并在它的比较函数中使用这个Comp类型。关联容器的每个构造函数使我们能够提供比较函数的名字。

可以这样定义使用compare函数的空multiset:

std::multiset<Sales_item,Comp> items(compare);

这个定义是说,items是一个multiset,它保存Sales_item对象并使用Comp类型的对象比较它们。multiset是空的——
我们没有提供任何元素,但我们的确提供了一个名为compare的比较函数。当在items中增加或查找元素时,将用compare函数对multiset进行排序。

3、容器与句柄类

我们定义一个Basket类，用以跟踪销售并计算购买价格：

class Basket
{
typedef bool (*Comp)(const Sales_item &,const Sales_item &);
public:
typedef multiset<Sales_item,Comp> set_type;
typedef set_type::size_type size_type;
typedef set_type::const_iterator const_iter;

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:
multiset<Sales_item,Comp> items;
};

该类定义了一个构造函数，即Basket默认构造函数。该类需要自己的默认构造函数，以便将compare传递给建立items成员的multiset构造函数。

4、使用句柄执行虚函数

Basket类中的total函数用于返回购物篮中所有物品的价格：

double Basket::total() const
{
double sum = 0.0;

for (set_type::iterator iter = items.begin();
iter != items.end();
iter = items.upper_bound(*iter))
{
sum += (*iter) -> net_price(items.count(*iter));
}

return sum;
}

  for循环中的“增量”表达式很有意思。与读每个元素的一般循环不同,我们推进iter指向下一个键。调用upper_bound函数以跳过与当前键匹配的所有元素,upper_bound函数的调用返回一个迭代器,该迭代器指向与iter键相同的最后一个元素的下一元素,即,该迭代器指向集合的末尾或下一本书。测试iter的新值,如果与items.end()相等,则跳出for循环,否则,就处理下一本书。

 
 我们使用multiset的 count成员确定multiset中的多少成员具有相同的键(即,相同的isbn),并且使用该数目作为实参调用net_price函数。

for循环的循环体调用net_price函数,阅读这个调用需要一点技巧:

sum += (*iter) -> net_price(items.count(*iter));

对iter解引用获得基础Sales_item对象,对该对象应用Sales_item类重载的箭头操作符,该操作符返回句柄所关联的基础Item_base对象的指针,用该Item_base对象指针调用net_price函数,传递具有相同isbn的图书的count作为实参。net_price是虚函数,所以调用的定价函数的版本取决于基础Item_base对象的类型。

//P511 习题15.35
//1 in item.h
#ifndef ITEM_H_INCLUDED
#define ITEM_H_INCLUDED

#include <string>
#include <utility>

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(std::size_t n) const
{
return price * n;
}

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,
std::size_t qty = 0,
double disc_rate = 0.0):
Item_base(book,sales_price),quantity(qty),discount(disc_rate) {}

virtual double net_price(std::size_t ) const = 0;

std::pair<std::size_t,double> discount_policy() const
{
return std::make_pair(quantity,discount);
}

protected:
std::size_t quantity;
double discount;
};

class Bulk_item : public Disc_item
{
public:
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) {}

virtual double net_price(std::size_t n) const
{
if (n >= quantity)
{
return n * (1 - discount) * price;
}
else
{
return n * 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,
std::size_t qty = 0,
double disc_rate = 0.0):
Disc_item(book,sales_price,qty,disc_rate) {}

virtual double net_price(std::size_t n) const
{
if (n <= quantity)
{
return n * (1 - discount) * price;
}
else
{
return n * price - quantity * discount * price;
}
}

virtual Lds_item *clone() const
{
return new Lds_item(*this);
}
};

#endif // ITEM_H_INCLUDED

//2 in sales_item.h
#ifndef SALES_ITEM_H_INCLUDED
#define SALES_ITEM_H_INCLUDED

#include "item.h"
#include <stdexcept>

class Sales_item
{
public:
Sales_item():p(0),use(new std::size_t(1)) {}
Sales_item(const Item_base &rhs):
p(rhs.clone()),use(new std::size_t(1)) {}

Sales_item(const Sales_item &rhs):p(rhs.p),use(rhs.use)
{
++ *use;
}

~Sales_item()
{
decr_use();
}

Sales_item &operator=(const Sales_item &rhs);

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;
std::size_t *use;

void decr_use()
{
if (-- *use)
{
delete p;
delete use;
}
}
};

#endif // SALES_ITEM_H_INCLUDED

//3 in sales_item.cpp
#include "sales_item.h"

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

p = rhs.p;
use = rhs.use;

return *this;
}

//4 in basket.h
#ifndef BASKET_H_INCLUDED
#define BASKET_H_INCLUDED

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

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

class Basket
{
typedef bool (*Comp)(const Sales_item &,const Sales_item &);
public:
typedef std::multiset<Sales_item,Comp> set_type;
typedef set_type::size_type size_type;
typedef set_type::const_iterator const_iter;

Basket():items(compare){}

void add_item(const Sales_item &item)
{
items.insert(item);
}

size_type size(const Sales_item &item) const
{
return items.count(item);
}

double total() const;

private:
std::multiset<Sales_item,Comp> items;

};

#endif // BASKET_H_INCLUDED

//5 in basket.cpp
#include "basket.h"

double Basket::total() const
{
double sum = 0.0;

for (set_type::iterator iter = items.begin();
iter != items.end();
iter = items.upper_bound(*iter))
{
sum += (*iter) -> net_price(items.count(*iter));
}

return sum;
}

//6 in main.cpp
#include <iostream>
#include "item.h"
#include "basket.h"

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-7",39));
Sales_item item3(Lds_item("7-115-14554-7",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;
}