首页 > 代码库 > C++ Primer 学习笔记_71_面向对象编程 --句柄类与继承
C++ Primer 学习笔记_71_面向对象编程 --句柄类与继承
面向对象编程
--句柄类与继承
引言：
C++中面向对象编程的一个颇具讽刺意味的地方是：不能使用对象支持面向对象编程，相反，必须使用指针或引用。
void get_prices(Item_base object,
Item_base *pointer,
Item_base &reference)
{
//需要根据指针或引用实际所绑定的类型进行调用
cout << pointer -> net_price(1) << endl;
cout << reference.net_price(1) << endl;
//一直调用基类Item_base版本中的 net_price
cout << object.net_price(1) << endl;
}
通过pointer和reference进行的调用在运行时根据它们所绑定对象的动态类型而确定。但是使用指针或引用会加重类用户的负担，像上一节的习题15.29：需要用户显式释放动态申请的内存。
C++解决该问题的一个通用的技术是定义包装类或句柄类。句柄类存储和管理基类指针，指针所指向对象的类型可以变化，它既可以指向基类类型对象又可以指向派生类型对象。用户通过句柄类访问继承层次的操作。因为句柄类使用指针执行操作,虚成员的行为将在运行时根据句柄实际绑定的对象的类型而变化。因此,句柄的用户可以获得动态行为但无须操心指针的管理。
包装了继承层次的句柄有两个重要的设计考虑因素:
1）像对任何保存指针的类一样，必须确定对复制控制做些什么。包装了继承层次的句柄通常表现得像一个智能指针，或者像一个值。
2）句柄类决定句柄接口屏蔽还是不屏蔽继承层次，如果不屏蔽继承层次，用于必须了解和使用基本层次中的对象。
一、指针型句柄
我们将定义一个名为Sales_item的指针型句柄类，表示Item_base层次。Sales_item的用户将像一个指针一样使用它：用户将Sales_item绑定到Item_base类型的对象并使用*和->操作符进行Item_base的操作：
//将一个句柄对象绑定到Bulk_item对象
Sales_item item(Bulk_item("0-201-82480-1",35,3,0.20));
//调用Bulk_item类的net_price函数
item -> net_price();
1、定义句柄
Sales_item类有三个构造函数：默认构造函数、复制构造函数和接受Item_base对象的构造函数。第三个构造函数将复制 Item_base 对象,并保证: 只要 Sales_item 对象存在副本就存在。当复制 Sales_item 对象或给 Sales_item 对象赋值时,将复制指针而不是复制对象。像对其他指针型句柄类一样,将用使用计数来管理副本。
迄今为止,我们已经使用过的使用计数式类,都使用一个伙伴类来存储指针 和相关的使用计数。这个例子将使用不同的设计,如图所示。
Sales_item 类将有两个数据成员,都是指针:一个指针将指向 Item_base 对象,而另一个 将指向使用计数。Item_base 指针可以指向 Item_base 对象也可以指向Item_base 派生类型的对象。通过指向使用计数,多个 Sales_item 对象可以共享同一计数器。
除了管理使用计数之外，Sales_item类还定义解引用操作符和箭头操作符：
class Sales_item
{
public:
Sales_item():p(0),use(new size_t(1)){}
Sales_item(const Item_base &);
Sales_item(const Sales_item &rhs):p(rhs.p),use(rhs.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;
std::size_t *use;
void decr_use()
{
if (-- *use == 0)
{
delete p;
delete use;
}
}
};
2、使用计数式复制控制
复制Sales_item对象包括复制两个指针和将使用计数加1。析构函数将使用计数减1,如果计数减至0就撤销指针。因为赋值操作符需要完成同样的工作,所以在一个名为decr_use的私有实用函数中实现析构函数的行为。
赋值操作符：
Sales_item &Sales_item::operator=(const Sales_item &rhs)
{
++ * rhs.use;
decr_use();
p = rhs.p;
use = rhs.use;
return *this;
}
除了复制控制成员以外,Sales_item定义的其他函数是操作函数operator*和operator->,用户将通过这些操作符访问Item_base成员。因为这两个操作符分别返回指针和引用,所以通过这些操作符调用的函数将进行动态绑定。
我们只定义了这些操作符的const版本,因为基础Item_base层次中的成员都是 const成员。
3、构造函数
出了复制构造函数，我们的句柄有两个构造函数：
1）将Item_base指针设置为0以指出该句柄并未关联任何对象。构造函数在自由存储区申请一个新的计数器并将它初始化为1。
2）我们希望句柄的用户创建自己的对象，并在这些对象上关联句柄。构造函数将分配适当类型的新对象并将形参复制到新分配的对象中，这样,Sales_item类将拥有对象并能够保证在关联到该对象的最后一个Sales_item对象消失之前不会删除对象。
二、复制未知类型
要实现接受Item_base对象的构造函数,必须首先解决一个问题:我们不知道给予构造函数的对象的实际类型。我们不知道它是一个Item_base对象或者是一个Item_base派生类型的对象。句柄类经常需要在不知道对象的确切类型时分配书籍的新副本。
【提示】
解决该问题的通用方法是定义虚操作进行复制，我们将该操作命名为clone。
为了支持句柄类，需要从基类开始，在继承层次的每个类型中增加clone，基类必须将该函数定义为虚函数：
class Item_base
{
public:
virtual Item_base *clone() const
{
return new Item_base(*this);
}
};
每个类必须重定义该虚函数。因为函数的存在是为了生成类对象的新副本，所以定义返回类型为类本身：
class Bulk_item : public Item_base
{
public:
/**如果虚函数的基类实例返回类类型的引用或指针,
*则该虚函数的派生类实例可以返回基类实例返回的类型的派生类
*(或者是类类型的指针或引用)。
*/
virtual Bulk_item *clone() const
{
return new Bulk_item(*this);
}
};
定义句柄构造函数
Sales_item::Sales_item(const Item_base &rhs):
p(rhs.clone()),use(new size_t(1)) {}
它调用形参的clone产生那个对象的（虚）副本：如果实参是Item_base对象，则运行Item_base的clone函数；如果实参是Bulk_item对象，则执行Bulk_item的clone函数。
//P508 习题15.31
class Lds_item : public Item_base
{
public:
virtual Lds_item *clone() const
{
return new Lds_item(*this);
}
//...As before
};
//习题15.32/34
//(a)
class Item_base
{
public:
Item_base(const std::string &book = "",
double sales_price = 0.0):
isbn(book),price(sales_price) {}
virtual void debug(bool ctrl = 1,ostream &os = cout) const
{
if (!ctrl)
return;
os << "ISBN:\t" << isbn << endl
<< "price:\t" << price << endl;
}
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 void debug(bool ctrl = 1,ostream &os = cout) const
{
if (!ctrl)
return ;
Item_base::debug(os);
os << "quantity:\t" << quantity << endl
<< "discount:\t" << discount << endl;
}
protected:
std::size_t quantity; //可实行折扣的数量
double discount; //折扣率
};
//(b)
class Item_base
{
public:
Item_base(const std::string &book = "",
double sales_price = 0.0,
bool dbg = false):
isbn(book),price(sales_price),is_debug(dbg) {}
virtual void debug(ostream &os = cout) const
{
if (!is_debug)
return;
os << "ISBN:\t" << isbn << endl
<< "price:\t" << price << endl;
}
void set_debug(bool dbg)
{
is_debug = dbg;
}
private:
std::string isbn;
protected:
double price;
bool is_debug;
};
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,
bool dbg = false):
Item_base(book,sales_price,dbg),quantity(qty),discount(disc_rate) {}
virtual void debug(ostream &os = cout) const
{
if (!is_debug)
return ;
Item_base::debug(os);
os << "quantity:\t" << quantity << endl
<< "discount:\t" << discount << endl;
}
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,
bool dbg = false):
Disc_item(book,sales_price,qty,disc_rate,dbg) {}
};
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,
bool dbg = false):
Disc_item(book,sales_price,qty,disc_rate,dbg) {}
};