当前位置:天才代写 > tutorial > C语言/C++ 教程 > 乌托邦式接口和实现疏散技能

乌托邦式接口和实现疏散技能

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

副标题#e#

《Imperfect C++》中展示了一种叫“螺栓”的技能,然而,这本书中的接头并不敷够深入。虽然,我也相信Matthew是存心的,从而让我们这些“三道街市”(Matthew自称是二道街市)也可以或许得到一点点成绩感。

思量这样一个接口设计:

struct IRefCount;
struct IReader : public IRefCount;

在Reader中实现接口:

<!–[if !supportEmptyParas]–> class Reader : public IReader;

在上述的担任布局中,IRefCount是一个布局性的类,用来实现引用计数,实际上它和规模逻辑部门IReader没有什么干系。我们规划在IRefCount的基本上,成立了一套东西来打点工具生命周期和辅佐实现异常安详的代码 (譬喻,smart pointer) 。此刻来思量Reader的实现,Reader除了需要实现IReader的接口,还必需实现IRefCount的接口。这一切看起来好像顺理成章,让我们继承看下面的设计<!–[if !supportEmptyParas]–>:

struct IWriter : public IRefCount;
<!--[if !supportEmptyParas]--> class Writer : public IWriter;

此刻来思量Writer的实现,和Reader一样,Writer除了要实现IWriter的接口外,同时还需要实现IRefCount的接口。此刻,我们来看看IRefCount是如何界说的:

struct IRefCount {
virtual void add() = 0;
virtual void release() = 0;
virtual int count() const = 0;
virtual void dispose() = 0;
virtual ~IRefCount(){}
};

在Reader中的IRefCount的实现:

virtual void add() { ++m_ref_count;}
virtual void release() {--m_ref_count;}
virtual int count() const{return m_ref_count;}
virtual void dispose() { delete this;}
…
int m_ref_count;

同样,在Writer的实现中,也包括了一模一样的代码,这违背了DRY原则(Don’t Repeat Yourself)。何况,跟着系统中的类增加,各人都意识到,需要将这部门代码复用。一个可以或许事情的做法是把IRefCount的实现代码直接放到IRefCount中去实现,通过担任,派生类就不必再次实现IRefCount了。我们来看一下dispose的实现:

virtual void dispose() { delete this;}

这里,回收了delete来销毁工具,这就意味着Reader必需在堆上分派,才大概透过IRefCount正确打点工具的生命周期,不要紧,我们还可以override dispose要领,在Reader如下实现dispose:

virtual void dispose() { }

可是,这样又带来一个问题,Reader不能被分派在堆上了!假如你够狠,虽然,你也可以这么办理问题:

class HeapReader : IReader;
class StackReader : HeapReader{ virtual void dispose() { } };

问题是,StackReader 是一个HeapReader吗?为了代码复用,我们完全不管什么观念了。虽然,假如你和我一样,垂青维护观念,那么这么实现吧:

class HeapReader : IReader;
class StackReader : IReader;

这样一来,IReader的实现将被反复,又违背了DRY原则,等着被未来维护的工程师谩骂吧!或者,谁人维护工程师就是3个月后的你本身。假如这样真的可以或许办理问题,那么也照旧可以接管的,很快,我们有了一个新的接口:

struct IRWiter : IReader, IWriter;
class RWiter : public IRWiter;

思量一下IRefCount的语义:它用来记录对地址工具的引用计数。很显然,我从IReader和IWriter中的任意一个分支得到的IRefCount应该都是得到一样的引用计数结果。可是此刻,这个担任树存在两个IRefCount的实例,我们不得不在RWiter傍边从头重载一遍。这样,从IReader和IWriter担任来的两个实例就作废了,并且,我们大概还挥霍了8个字节。为了办理这个问题,我们还可以在另一条危险的阶梯上继承前进,那就是虚拟担任:

struct IReader : virtual public IRefCount;
struct IWriter : virtual public IRefCount;

还记得大家们给以的忠告吗–“不要在虚基类中存放数据成员”。“这样有什么问题吗,我们不必对大家盲目崇敬”,你必然也听过这样的发起。假如大家们不能说服这些人,那么我也不能。于是,我们进一步在所有的接口中提供默认实现,包罗IReader和IWriter.


#p#副标题#e#

此刻的问题是:

struct IRWiter : IReader, IWriter;

照旧

struct IRWiter : virtual IReader, virtual IWriter ?

假如你没有选择virtual,那么IRWiter被派生后,那么派生类的担任树中大概存在多个IReader实现,假如这个派生类要求只能提供一份IReader的语义怎么办?除了从头实现接口还能奈何?反过来,假如我们选择了virtual担任,那么派生类需要多个实现怎么办?真是个贫苦事。“这是典范的太过设计,我们为什么要思量这么多?”你可以这么说,但事实上,纵然是一个数百文件的小型系统,也完全大概迫使你作出选择。固然,我们仍然有步伐作出挽救法子,可是也只是苟延残喘罢了。正如我前面所说,这是一个危险的阶梯,智慧如你,是断然不会让本身陷入这样的泥潭的。

#p#分页标题#e#

让我们分开虚拟担任,先回到反复代码的问题上来。有没有更好的办理步伐呢?还好,在C++的世界里,我们有神奇的template,让我们来消除反复的代码:

template<typename Base>
class ImpReader : public Base{
constraint(is_base_derive(IReader, Base))
Implementation IReader
<!--[if !supportEmptyParas]--> };
class HeapReader : ImpReader<IReader>{};
class StackReader : ImpReader <IReader>{
virtual void dispose() {};
<!--[if !supportEmptyParas]--> };

请留意,我们照旧假设IRefCount已经提供了一个默认实现。此刻,环境好了许多,所有的代码都只有一份,并且,观念也没有被粉碎。假设,Writer也同样需要雷同的本领,那么,我们又多了StackWriter和HeapWriter.事实上,真的有人用到了StackWriter吗?我不知道,只是,提供了StackReader,没有来由不提供StackWriter啊。让我们继承。

此刻,我们发明,需要改造内存分派的机能问题,于是,我们但愿通过内存池来分派工具,相应的dispose也需要修改:

virtual void dispose(){ distory(this);}

于是,我们又多出两个类,PoolReader和PoolWriter。这真是糟糕,组合爆炸可不是什么好兆头。

从我们前述的变革来看,都是IRefCount在变革,为什么不把这种变革疏散出来呢?不必为IRefCount提供默认实现,警惕ImpReader的手法:

template<typename Base>
class ImpHeapRefCount : public Base{
constraint(is_base_derive(IRefCount, Base));
..};

雷同的:

template<typename Base> class ImpStackRefCount : public Base;
<!--[if !supportEmptyParas]--> template<typename Base> class ImpPoolRefCount : public Base; <!--[endif]-->

再看看,我们如何实现所有的Reader.

typedef ImpReader< ImpHeapRefCount<IReader> > HeapReader;
typedef ImpReader< ImpStackRefCount<IReader> > StackReader;
typedef ImpReader< ImpPoolRefCount<IReader> > PoolReader;

以HeapReader为例,实际的担任干系是这样的:

ImpReaderàImpHeapRefCountàIReaderàIRefCount;

对付Writer,我们完全可以采纳同样的手法来实现。对付上述的typedef可以预先界说,也完全可以不界说,交给最终用户去组装吧。此刻,类的设计者再也不必为选择实现而疾苦了,你只要提供差异的砖头,客户措施员可以垂手可得的成立起大厦。尚有比这更让一个设计师幸福的吗?

#p#副标题#e#

继承深入,考查ImpHeapRefCount和ImpStackRefCount的实现,我们提到,dispose要领的实现是纷歧样的,可是,其他部门:add,releasee和count的实现完全可以沟通。然而我们此刻又别离实现了一遍,为了不违背DRY原则,我们如下处理惩罚:

template<typename Base>
class ImpPartialRefCount : public Base{
//实现add, release和count.
};
template<typename Base>
class ImpHeapRefCount : public Base{
virtual void dispose() { delete this;}
};
template<typename Base>
class ImpStackRefCount : public Base{
virtual void dispose() { }
};

然后,我们可以这样界说Reader:

typedef ImpReader<ImpHeapRefCount<ImpPartialRefCount<Ireader> > > HeapReader;

请留意,我们在这里展示了一种本领,不必在一个实现傍边完整的实现整个接口,可以把一个接口的实现分拆到多个实现傍边。这个本领是不凡的,借助于此,我们可以提供更小粒度的实现单元,给最终用户来组装。详细拆分到什么样的水平完全取决于代码复用的需求,以及观念维护的需要。

我们提供了高度的复用本领,同时制止了担任带来的强耦合,以及对推迟设计决定的支持,这些本领对付软件设计师而言,正如Matthew在《Imperfect C++》中所说的,这的确就是现实中的乌托邦!

此刻我们把这种手法首先针对单担任做一个小结。对付任意的接口IInterface,我们提供如下的实现:

template<typename Base>
class ImpInterface : public Base{
constraint(is_base_derive(IInterface, Base));
};

请留意,一个接口可以有任意多个实现,而且可以是任意的部门实现。<!–[if !supportEmptyParas]–> <!–[endif]–>

假设我们有如下接口担任树:

InterfaceN àInterfaceN_1àInterfaceN_2à…àInterface0

而且提供了实现类ImpInterface0 ~ ImpInterfaceN.

那么,InterfaceN的实例范例就是:

typedef ImpInterfaceN<
ImpInterfaceN_1<
ImpInterfaceN_2<
…
ImpInterface0<InterfaceN> …> > > ConcreteClassN;

#p#分页标题#e#

我们留意到,界说ConcreteClassN的时候,我们的ImpInterface是凭据顺序来的,我认为这是符合的做法。虽然了,最后组装的权力已经交给客户了,客户爱怎么组装就怎么组装吧。然而我们照旧有一些需要留意的问题。

1.假定,我需要在ImpInterfaceI中引用基类的要领,记着,不要利用这样的手法:

ImpInterfaceI_K::SomeMethod();

这样挪用不具有多态性,而应该这样:

this-> SomeMethod();

2.不要在本身的ImpInterfaceI实现中包围基类接口的其他已经实现的要领,假如你必然要这么做,那么务必在文档中说明,因为在组装的时候,顺序将是极其要害的了。

#p#副标题#e#

3.这个要领和设计模式中的Template Pattern目标是纷歧样的。Template Pattern是在基类中界说了一个算法,让派生类定制算法的某些步调。这里的要领针对的是接口模子的观念,提供接口和实现疏散的技能。

关于第二条,应该只管制止产生。这里说的包围是指基类实现已经实现了该要领,尔后继实现又包围该要领。基类实现可以是一个部门实现,对付没有实现的那些要领,在派生接口的实现类中实现则是常见的。一方面,我们只管公道解析条理之间的成果,另一个方面,可以通过定制实现模板类,来担保顺序。尽大概的让语言自己来担保正确性,而不是依赖文档。我们可以像这样预先装配一些对象:

template<typename Base>
class SomeComponent : public ImpPartA < ImpPartB <Base> >{};

惋惜,C++临时还不支持模板的不完全typedef,不然,我们还可以如下定以:

template<typename Base>
typedef ImpPartA< ImpPartB<Base> > SomeComponent;

不外,C0x很大概会支持雷同的语法。这样,我们利用SomeComponent来作为一个预成品,来担保一些安详性,而不必完全依赖文档了。 <!–[endif]–>

看看ConcreteClassN的界说,也许你和我一样,并不喜欢这种嵌套的、递归的界说方法,太丢脸了。让世界稍微优美一点吧!于是我们提供一个帮助类:

<!--[if !supportEmptyParas]--> template<typename T>struct Empty{};
template<typename I, typename template<class> class B>
struct Merge{ <!--[if !supportEmptyParas]-->typedef B<I> type;};
template<typename I >
struct Merge<I, Empty >{
typedef I type;
<!--[if !supportEmptyParas]--> }; <!--[endif]-->
template
<
typename I,
typename template<class> class B1,
typename template<class> class B2 = Empty,
…
typename template<class> class Bn = Empty,
>
struct Reform{
typedef typename Merge<
typename Merge<
typename Merge<I, B1>::type
, B2>::type , …,Bn>::type type;
};

此刻,我们可以这样界说ConcreteClassN了:

Typedef Reform<InterfaceN, ImpInterface0, ImpInterface1,
…ImpInterfaceN>::type ConcreteClassN;

是不是清爽了许多?

在继承下面内容以前,请回味一下这个不是问题的问题:

假设IReader有3种实现,IRefCount有3种实现,我们将如何大度地办理掉他们。 <!–[endif]–>

现实世界老是要巨大得多,让我们进入真实的世界。回首这个接口:

struct IRWiter : IReader, IWriter;

假设我们确实需要IReader, IWriter,可是并不需要IRWrite,可不行以让一个工具同时支持这两个接口呢,就像COM一样?虽然可以,我们借助于这样一个帮助模版:

template<typename B1, typename B2>
struct Combine : B1, B2{
typedef B1 type1;
typedef B1 type2;
<!--[if !supportEmptyParas]--> }; <!--[endif]-->
typedef Reform< Combine<IReader, IWriter>, ImpRefCount, ImpWriter, ImpReader >::type ConcreteRWiter

为了现实需要,我们可以提供Combine的多个特化版本以支持任意数量的接口组合。假如仅仅是为了去掉一个IRWiter就引入一个Combine,虽有长处,可是意义也不大。那么,思量这样一个例子。

struct IHttpReader : IReader;
struct IFileReader : IReader;

我们需要一个工具,同时支持从网络和从文件读取的本领。先看不引入Combine的做法:

struct IFileHttpReader : IFileReader , IHttpReader;
typedef Reform<IFileHttpReader, ImpRefCount, ImpHttpReader,
ImpFileReader>::type ConcreteRWiter;

#p#副标题#e#

以为有什么问题吗?ImpReader同时实现了IFileReader分支和IHttpReader分支中的IReader,可是,和IRefCount差异的是,我们完全有来由相信,这两个分支其实需要差异的IReader的实现。纵然IReader确实可以是同样的实现,另一个严重的问题是,ImpReader是一个不完整的实现,ImpFileReader和ImpHttpReader都别离重载了IReader中的一部门要领,譬喻,两者都实现了如下要领:

virtual bool open(const char* url);

如何办理这个问题?让我们回首一下IFileHttpReader,首先这个接口就是个问题产品:

#p#分页标题#e#

open到底open什么?文件,照旧HTTP毗连,照旧两个都打开?也就是说,从观念上来讲,IFileHttpReader就存在抵牾,这样的观念很显然是难以维护的。其次,我们完全没有步伐为两个分支提供差异的实现,虽然,其来源是IFileHttpReader的错误设计导致的,不回收我们这里提到的技能,问题依然存在。此刻引入一个结论:假如某个接口的基类树中多次呈现同一个接口,我们的技能无法为这些接口别离提供差异的实现。这里的办理方案是丢弃IFileHttpReader,引入Combine, 我们可以这样办理问题:

typedef Reform<
Combine< ImpFileReader <IFileReader>, ImpHttpReader <IHttpReader> >,
ImpRefCount, ImpReader
>::type ConcreteFileHttpReader;

假设,ImpReader不能同时满意两个分支的要求,我们可以这么做:

typedef Reform <
Combine< ImpFileReader < ImpReaderA<IFileReader> >,
ImpHttpReader < ImpReaderB <IHttpReader> >
>,
ImpRefCount
>::type ConcreteFileHttpReader;

操作Combine,我们可以充实发挥多重担任的组合本领,我们既享受了接口设计和实现疏散的长处—更容易维护观念了,也充实享有代码复用的本领。而且,将设计决定充实推迟:甚至客户措施员完全可以定制本身的接话柄现从而和现有系统团结,这是一个完美的Open-Close的设计手段。

<!–[if !supportLists]–><!–[if !supportLists]–><!–[if !supportLists]–><!–[if !supportLists]–> 此刻,总结一下在多重担任中的留意事项。

1.接口只管是单担任的。

2.多重担任的接口必需意识到,所有担任树的沟通接口只能共享同一份实现。

3.严苛地去维护接口的观念,不要为了实现问题界说中间的接口(就象谁人IFileHttpReader)

4.公道地操作多重担任的组合本领。<!–[if !supportEmptyParas]–>

关于最后一条,您可以做一些有趣的摸索。给出一个空基类:

struct Over{};

虽然,也可以是其它非模板类。把所有的类都实现成模版形式:ImpClassA<T>, ImpClassB<T>,借助于Combine,我们大概给出这样的界说:

typedef Combine<ImpClassA< Combine<ImpClassB< Over >, ImpClassC< Over > > >,Combine<ImpClassF<Over>, ImpClassB<ImpClassD< Over > >>,ImpClassE<Over>>::type ConcreteSomeClass;

#p#副标题#e#

我们注重于将这些ImpClasses拆成尽大概小的正交模块。那么借助组合技能,大概得到很高的复用性。可是,有句老话,不要为了复用而复用,横竖,这里的摸索我也是浅尝辄止,出了什么工作和我无关。出格提醒一下,上面代码中Combine内里呈现了一个type,你可以实验在上面施加你喜欢的TMP手法嘛。

把那些有趣的摸索先放在一边。此刻,我已经把这种技能完整地泛起出来了。然而,没有一项技能是完美的,这里也不破例。这个技能有两个小小的缺陷。

第一个缺陷则是结构函数的问题。回首Combine的实现,我们无法为Combine特别提供符合的结构函数。不外,这个问题并不是出格严重,我们完全可以定制本身的Combine。而且,这些差异的Combine可以殽杂利用。别的,在组装的时候需要小心的维护结构函数的挪用链,这大概伤害到复用性。Assignment中也存在雷同的问题。运算符重载也大概导致杂乱,不外,我一直认为,在值语义之外的类傍边重载运算符但是要很是审慎的,很显然,我们这里展示的技能并不适合值语义的范例设计。

另一个缺陷是工程上的。因为上述的实现都是模板类,所以,我们凡是需要将实此刻头文件内里提供,这个大概是有些人不肯意的。我将揭示一种办理的要领,这就是另一个利器:Pimpl习用法。

以IReader为例,假设如下接口:

struct IReader : IRefCount
{
virtual bool open(const char* url) = 0;
virtual void read(Buffer& buf, size_t size) = 0;
};

此刻,我们只实现read要领:

class ConcreteImpReader;//前置申明
template<typename Base>
class ImpPartialReader : public Base
{
Pimpl<ConcreteImpReader> m_reader;
public:
ImpPartialReader() : m_reader(this), Base(){}
virtual void read(Buffer& buf, size_t size) { m_reader->read(buf, size);}
};

#p#分页标题#e#

此刻,给出一个原始的Pimpl实现:

template<typename T>
struct Pimpl
{
T* imp;
template<typename Host>
explicit Pimpl(Host* host) : imp(new T(host)){}
T* operator->() const{return imp;}
~Pimpl(){delete imp;}
…
};

在单独的文件中实现:

class ConcreteImpReader
{
ConcreteImpReader(IReader * host) : m_host(host){}
void read(Buffer& buf, size_t size) { …}
…
};

ConcreteImpReader中可以引用地址的host工具的其他要领,可是本身实现的要领除外。假如我们愿意,也可以把接口的实现分拆到多个详细的实现类傍边,只是我们无法得到象多重担任那样强大的组合本领。

 

    关键字:

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