当前位置:天才代写 > tutorial > C语言/C++ 教程 > C++箴言:审慎利用多担任

C++箴言:审慎利用多担任

2017-11-06 08:00 星期一 所属: C语言/C++ 教程 浏览:570

副标题#e#

触及 multiple inheritance (MI)(多担任)的时候,C++ 社区就会光鲜地破裂为两个根基的阵营。一个阵营认为假如 single inheritance (SI)(单担任)是有长处的,multiple inheritance(多担任)必然更有长处。另一个阵营认为 single inheritance(单担任)有长处,可是多担任引起的贫苦使它得不偿失。在本文中,我们的主要目标是领略在 MI 问题上的这两种观点。

首要的工作之一是要认可当将 MI 引入设计规模时,就有大概从多于一个的 base class(基类)中担任沟通的名字(譬喻,函数,typedef,等等)。这就为歧义性提供了新的机缘。譬喻:

class BorrowableItem { // something a library lets you borrow
public:
 void checkOut(); // check the item out from the library
 ..
};
class ElectronicGadget {
private:
 bool checkOut() const; // perform self-test, return whether
 ... // test succeeds
};
class MP3Player: // note MI here
public BorrowableItem, // (some libraries loan MP3 players)
public ElectronicGadget
{ ... }; // class definition is unimportant
MP3Player mp;
mp.checkOut(); // ambiguous! which checkOut?

留意这个例子,纵然两个函数中只有一个是可会见的,对 checkOut 的挪用也是有歧义的。(checkOut 在 BorrowableItem 中是 public(公有)的,但在 ElectronicGadget 中是 private(私有)的。)这与 C++ 理会 overloaded functions(重载函数)挪用的法则是一致的:在看到一个函数的是否可会见之前,C++ 首先确定与挪用匹配最好的谁人函数。只有在确定了 best-match function(最佳匹配函数)之后,才查抄可会见性。这今朝的环境下,两个 checkOuts 具有沟通的匹配水平,所以就不存在最佳匹配。因此永远也不会查抄到 ElectronicGadget::checkOut 的可会见性。


#p#副标题#e#

为了消除歧义性,你必需指定哪一个 base class(基类)的函数被挪用:

mp.BorrowableItem::checkOut(); // ah, that checkOut...

虽然,你也可以实验显式挪用 ElectronicGadget::checkOut,但这样做会有一个 "you’re trying to call a private member function"(你试图挪用一个私有成员函数)错误取代歧义性错误。

multiple inheritance(多担任)仅仅意味着从多于一个的 base class(基类)担任,可是在尚有 higher-level base classes(更高条理基类)的 hierarchies(担任体系)中呈现 MI 也并不稀有。这会导致有时被称为 "deadly MI diamond"(致命的多担任菱形)的效果。

class File { ... };
class InputFile: public File { ... };
class OutputFile: public File { ... };
class IOFile: public InputFile,
public OutputFile
{ ... };
 

在一个“在一个 base class(基类)和一个 derived class(派生类)之间有多于一条路径的 inheritance hierarchy(担任体系)”(就像上面在 File 和 IOFile 之间,有通过 InputFile 和 OutputFile 的两条路径)的任何时候,你都必需面临是否需要为每一条路径复制 base class(基类)中的 data members(数据成员)的问题。譬喻,假设 File class 有一个 data members(数据成员)fileName。IOFile 中应该有这个 field(字段)的几多个拷贝呢?一方面,它从它的每一个 base classes(基类)担任一个拷贝,这就体现 IOFile 应该有两个 fileName data members(数据成员)。另一方面,简朴的逻辑汇报我们一个 IOFile object(工具)应该仅有一个 file name(文件名),所以通过它的两个 base classes(基类)担任来的 fileName field(字段)不该该被复制。

#p#副标题#e#

C++ 在这个争议上没有本身的态度。它恰内地支持两种选项,固然它的缺省方法是执行复制。假如那不是你想要的,你必需让这个 class(类)带有一个 virtual base class(虚拟基类)的数据(也就是 File)。为了做到这一点,你要让从它直接担任的所有的 classes(类)利用 virtual inheritance(虚拟担任):

class File { ... };
class InputFile: virtual public File { ... };
class OutputFile: virtual public File { ... };
class IOFile: public InputFile,
public OutputFile
{ ... };

尺度 C++ 库包括一个和此雷同的 MI hierarchy(担任体系),只是谁人 classes(类)是 class templates(类模板),名字是 basic_ios,basic_istream,basic_ostream 和 basic_iostream,而不是 File,InputFile,OutputFile 和 IOFile。

从正确行为的概念看,public inheritance(公有担任)应该老是 virtual(虚拟)的。假如这是独一的概念,法则就变得简朴了:你利用 public inheritance(公有担任)的任何时候,都利用 virtual public inheritance(虚拟公有担任)。唉,正确性不是独一的视角。制止 inherited fields(担任来的字段)复制需要在编译器的一部门做一些 behind-the-scenes legerdemain(幕后的戏法),而功效是从利用 virtual inheritance(虚拟担任)的 classes(类)建设的 objects(工具)凡是比不利用 virtual inheritance(虚拟担任)的要大。会见 virtual base classes(虚拟基类)中的 data members(数据成员)也比那些 non-virtual base classes(非虚拟基类)中的要慢。编译器与编译器之间有一些细节差异,但根基的要点很清楚:virtual inheritance costs(虚拟担任要支付本钱)。

#p#副标题#e# // factory function to create a Person object from a unique database ID;
// see Item 18 for why the return type isn't a raw pointer
std::tr1::shared_ptr<IPerson> makePerson(DatabaseID personIdentifier);
// function to get a database ID from the user
DatabaseID askUserForDatabaseID();
DatabaseID id(askUserForDatabaseID());
std::tr1::shared_ptr<IPerson> pp(makePerson(id)); // create an object
// supporting the
// IPerson interface
... // manipulate *pp via
// IPerson's member
// functions

#p#分页标题#e#

可是 makePerson 奈何建设它返回的 pointers(指针)所指向的 objects(工具)呢?显然,必需有一些 makePerson 可以实例化的从 IPerson 派生的 concrete class(详细类)。

假设这个 class(类)叫做 CPerson。作为一个 concrete class(详细类),CPerson 必需提供它从 IPerson 担任来的 pure virtual functions(纯虚拟函数)的 implementations(实现)。它可以从新开始写,但操作包括大大都或全部必须品的现有组件更好一些。譬喻,假设一个老式的 database-specific class(老式的数据库专用类)PersonInfo 提供了 CPerson 所需要的根基要素:

class PersonInfo {
public:
 explicit PersonInfo(DatabaseID pid);
 virtual ~PersonInfo();
 virtual const char * theName() const;
 virtual const char * theBirthDate() const;
 ...
private:
 virtual const char * valueDelimOpen() const; // see
 virtual const char * valueDelimClose() const; // below
 ...
};

你可以看出这是一个老式的 class(类),因为 member functions(成员函数)返回 const char*s 而不是 string objects(工具)。尽量如此,假如鞋子符合,为什么不穿呢?这个 class(类)的 member functions(成员函数)的名字体现功效很大概会很是符合。

#p#副标题#e#

你溘然发明 PersonInfo 是设计用来辅佐以差异的名目打印 database fields(数据库字段)的,每一个字段的值的开始和末了通过指定的字符串定界。缺省环境下,字段值开始和末了定界符是方括号,所以字段值 "Ring-tailed Lemur" 很大概被布置成这种名目:

[Ring-tailed Lemur]

按照方括号并非满意 PersonInfo 的全体客户的期望的事实,virtual functions(虚拟函数)valueDelimOpen 和 valueDelimClose 答允 derived classes(派生类)指定它们本身的开始和末了定界字符串。PersonInfo 的 member functions(成员函数)的 implementations(实现)挪用这些 virtual functions(虚拟函数)在它们返回的值上加上适当的定界符。作为一个例子利用 PersonInfo::theName,代码如下:

const char * PersonInfo::valueDelimOpen() const
{
 return "["; // default opening delimiter
}
const char * PersonInfo::valueDelimClose() const
{
 return "]"; // default closing delimiter
}
const char * PersonInfo::theName() const
{
 // reserve buffer for return value; because this is
 // static, it's automatically initialized to all zeros
 static char value[Max_Formatted_Field_Value_Length];
 // write opening delimiter
 std::strcpy(value, valueDelimOpen());
 append to the string in value this object's name field (being careful to avoid buffer overruns!)
 // write closing delimiter
 std::strcat(value, valueDelimClose());
 return value;
}

有人大概会质疑 PersonInfo::theName 的陈旧的设计(出格是一个 fixed-size static buffer(牢靠巨细静态缓冲区)的利用,这样的对象产生 overrun(越界)和 threading(线程)问题是较量普遍的——拜见《C++箴言:必需返回工具时别返回引用》),可是请把这样的问题放到一边而留意这里:theName 挪用 valueDelimOpen 生成它要返回的 string(字符串)的开始定界符,然后它生成名字值自己,然后它挪用 valueDelimClose。

#p#副标题#e#

因为 valueDelimOpen 和 valueDelimClose 是 virtual functions(虚拟函数),theName 返回的功效不只依赖于 PersonInfo,也依赖于从 PersonInfo 派生的 classes(类)。

对付 CPerson 的实现者,这是好动静,因为当细读 IPerson documentation(文档)中的 fine print(艰涩的条文)时,你发明 name 和 birthDate 需要返回未经修饰的值,也就是,不答允有定界符。换句话说,假如一小我私家的名字叫 Homer,对那小我私家的 name 函数的一次挪用应该返回 "Homer",而不是 "[Homer]"。

#p#分页标题#e#

CPerson 和 PersonInfo 之间的干系是 PersonInfo 可巧有一些函数使得 CPerson 更容易实现。这就是全部。因而它们的干系就是 is-implemented-in-terms-of,而我们知道有两种要领可以表示这一点:经过 composition(复合)(拜见《C++箴言:通过composition模仿“has-a”》)和经过 private inheritance(私有担任)(拜见《C++箴言:审慎利用私有担任》)。《C++箴言:审慎利用私有担任》指出 composition(复合)是凡是的首选要领,但假如 virtual functions(虚拟函数)要被重界说,inheritance(担任)就是必不行少的。在当前环境下,CPerson 需要重界说 valueDelimOpen 和 valueDelimClose,所以简朴的 composition(复合)做不到。最直截了当的办理方案是让 CPerson 从 PersonInfo privately inherit(私有担任),固然 《C++箴言:审慎利用私有担任》说过只要多做一点事情,则 CPerson 也能用 composition(复合)和 inheritance(担任)的组合有效地重界说 PersonInfo 的 virtuals(虚拟函数)。这里,我们用 private inheritance(私有担任)。

可是 CPerson 还必需实现 IPerson interface(接口),而这被称为 public inheritance(公有担任)。这就引出一个 multiple inheritance(多担任)的公道应用:组合 public inheritance of an interface(一个接口的公有担任)和 private inheritance of an implementation(一个实现的私有担任):

#p#副标题#e# class IPerson { // this class specifies the
public: // interface to be implemented
 virtual ~IPerson();
 virtual std::string name() const = 0;
 virtual std::string birthDate() const = 0;
};
class DatabaseID { ... }; // used below; details are
// unimportant
class PersonInfo { // this class has functions
public: // useful in implementing
 explicit PersonInfo(DatabaseID pid); // the IPerson interface
 virtual ~PersonInfo();
 virtual const char * theName() const;
 virtual const char * theBirthDate() const;
 virtual const char * valueDelimOpen() const;
 virtual const char * valueDelimClose() const;
 ...
};
class CPerson: public IPerson, private PersonInfo { // note use of MI
public:
 explicit CPerson( DatabaseID pid): PersonInfo(pid) {}
 virtual std::string name() const // implementations
 { return PersonInfo::theName(); } // of the required
 // IPerson member
 virtual std::string birthDate() const // functions
 { return PersonInfo::theBirthDate(); }
private: // redefinitions of
 const char * valueDelimOpen() const { return ""; } // inherited virtual
 const char * valueDelimClose() const { return ""; } // delimiter
}; // functions

在 UML 中,这个设计看起来像这样:

C++箴言:隆重操作多接受

这个例子证明 MI 既是有用的,也是可领略的。

时至今天,multiple inheritance(多担任)不外是 object-oriented toolbox(面向工具东西箱)里的又一种东西罢了,典范环境下,它的利用和领略越发巨大,所以假如你获得一个或多或少等同于一个 MI 设计的 SI 设计,则 SI 设计老是越发可取。假如你能拿出来的仅有的设计包括 MI,你应该越发用心地思量一下——总会有一些要领使得 SI 也能做到。但同时,MI 有时是最清晰的,最易于维护的,最公道的完成事情的要领。在这种环境下,绝不害怕地利用它。只是要确保审慎地利用它。

Things to Remember

·multiple inheritance(多担任)比 single inheritance(单担任)更巨大。它能导致新的歧义问题和对 virtual inheritance(虚拟担任)的需要。

·virtual inheritance(虚拟担任)增加了 size(巨细)和 speed(速度)本钱,以及 initialization(初始化)和 assignment(赋值)的巨大度。当 virtual base classes(虚拟基类)没有数据时它是最合用的。

·multiple inheritance(多担任)有公道的用途。一种方案涉及组合从一个 Interface class(接口类)的 public inheritance(公有担任)和从一个有助于实现的 class(类)的 private inheritance(私有担任)。

 

    关键字:

[contact-form-7 id="17097" title="form2"]天才代写-代写联系方式