成员函数指针与高性能的C++委托

RichardHe — Mon, 08 Dec 2008 03:50:00 GMT

摘要: 引子标准C++中没有真正的面向对象的函数指针。这一点对C++来说是不�q�的�Q�因为面向对象的指针�Q�也叫做“闭包�Q�closure�Q?#8221;�?#8220;委托�Q�delegate�Q?#8221;�Q�在一些语�a�中已�l�证明了它宝�늚�价倹{��在Delphi (Object Pascal)中，面向对象的函数指针是Borland可视化组建库�Q�VCL�Q�Visual Component Library... 阅读全文

RichardHe 2008-12-08 11:50 发表评论

RichardHe — Wed, 06 Aug 2008 08:36:00 GMT

��http://www.shnenglu.com/Fox/archive/2008/08/06/58154.html

0. Introduction

接触设计模式有两�q�时间了�Q�但一直没有系�l�整理过�Q��ؓ了不至于让自��q��思维被繁琐的工作一点点��锢�Q�还是决定�ȝ��一下，��Z��能够真正做到有所收获�Q�整个系列会按照GoF的Design Patterns: Elements of Reusable Object-Oriented Software的行文思�\�Q�但不会照本宣科��是了，Wikipedia上关�?3�U�设计模式的介绍非常全面�Q�CSDN上也可以下蝲�?英文电子档，因此很多套话、类图一概省厅R�?/p>

最早接触设计模式的时候，隑օ�被各�U�模式的联系和区别所困扰�Q�从教科书的分析可以得到模式之间形式上的不同。但�q�样对于领会设计模式意义不大�Q�因为我们掌握模式的目的是�ؓ了融会诏通，灉|��q�用�Q�以对开发有所帮助�?/p>

�E�微成规模的OO�E�序�Q�会有大量对象，其中很多实体对象之间存在着父子、兄�?/strong>关系�Q�对象的创徏提升��Z��U�模式。其好处在于设计模式本��n所宣称�?strong>reusable�Q�这��像堆积木盖房子一��P��堆的好的情况下，换一换门�H�便是另一番风景�?/p>

关于实现�Q�我不会��Z��厘清模式间的区别而刻意��用相��g��码实玎ͼ�相反�Q�我会根据模式本�w�的适用情况举例�Q�而且大量代码��Z��SourceMaking�?/p>

_______________________________

1. Creational Design Patterns(DP)

创徏型DP抽象了类和对象的创徏�q�程�Q?a title="Gang of four" target="_blank">GoF�l�出�?�U?strong>创徏型DP�Q?strong>Abstract Factory�?strong>Builder�?strong>Factory Method�?strong>Builder�?strong>Prototype�?strong>Singleton�?/p>

2. Abstract Factory

意图�Q�提供一个创��Z��p�d��相关或相互依赖对象的接口�Q�而无需指定它们具体的类�?/strong>

1) 只提供了一个创建接口，其返回��gؓ具体产品�Q�如AbstractProduct *Client::CreateProduct(AbstractFactory &factory);

2) 接口的参数是一�?strong>工厂对象�Q?code>AbstractFactory &factory�Q�的引用�Q�参数类型（AbstractFactory�Q��ؓ抽象基类�Q�调用时�Ҏ��需要传入具体工厂对象即可；

3) 接口内部实现�?strong>一�p�d��相关或相互依赖对�?/strong>�Q�抽象��品）的创建：当传入具体工厂时�Q�接口实现的��是一�p�d��具体产品的创建；

4) 创徏的��?strong>立即�q�回�Q?code>CreateProduct�Q��?/p>

参与者：

• AbstractFactory
�?声明一个创建抽象��品对象的操作接口�?/p>

• ConcreteFactory
�?实现创徏具体产品对象的操作�?/p>

• AbstractProduct
�?��Z��c�M�品对象声明一个接口�?/p>

• ConcreteProduct
�?定义一个将被相应的具体工厂创徏的��品对象�?br>�?实现AbstractProduct接口�?/p>

• Client
�?仅��用由AbstractFactory和AbstractProduct�c�d��明的接口�?/p>

代码�Q?/strong>

class AbstractFactory
{
public:
    virtual AbstractProduct *MakePartA() = 0;
    virtual AbstractProduct *MakePartB() = 0;
    virtual AbstractProduct *MakePartC() = 0;
    virtual AbstractProduct *AddPart(const AbstractProduct *pPart) = 0;
};

AbstractProduct *Client::CreateProduct(AbstractFactory &factory)
{
    AbstractProduct *pProduct = factory.CreateProduct();
    AbstractProduct *pPartA = factory.MakePartA();
    AbstractProduct *pPartB = factory.MakePartB();
    AbstractProduct *pPartC = factory.MakePartC();
    factory.AddPart(pPartA);
    factory.AddPart(pPartB);
    factory.AddPart(pPartC);
    return pProduct;
}

int main(void)
{
    Client client;
    ConcreteFactory factory;
    client.CreateProduct(factory);
    return 0;
}

3. Builder

意图�Q�将一个复杂对象的构徏与它的表�C�分��，使得同样的构��E�可以创��Z��同的表示�?/strong>

1) director提供抽象产品创徏接口�Q�如void Director::Construct();

2) 不同产品使用同一创徏�q�程�Q�由director指定特定builder以生产不同��品；

3) 接口内部实现�?strong>一个复杂对�?/strong>�Q�抽象��品）的创建：当传入具体工厂时�Q�接口实现的�?strong>一个复杂的具体产品的创建；

4) 创徏的��?strong>�q�不立即�q�回�Q?strong>创徏完毕后返回，�?strong>使用接口�Q?code>GetProduct�Q�提取结果�?/p>

参与者：

• Builder
�?为创��Z��个Product对象的各个部件指定抽象接口�?/p>

• ConcreteBuilder
�?实现Builder的接口以构造和装配该��品的各个部�g�?br>�?定义�q�明��它所创徏的表�C��?br>�?提供一个检索��品的接口�?/p>

• Director
�?构造一个��用Builder接口的对象�?/p>

• Product
�?表示被构造的复杂对象。ConcreteBuilder创徏该��品的内部表示�q�定义它的装配过�E��?br>�?包含定义�l�成部�g的类�Q�包括将�q�些部�g装配成最�l��品的接口�?/p>

代码�Q?/strong>

class Builder
{
public:
    virtual void MakePartA() = 0;
    virtual void MakePartB() = 0;
    virtual void MakePartC() = 0;

    Product *GetProduct()    { return _product; }

protected:
    Product *_product;
};

class Director
{
public:
    void setBuilder(Builder *b)    { _builder = b; }
    void Construct();

private:
    Builder *_builder;
};

void Director::Construct()
{
    _builder.MakePartA();
    _builder.MakePartB();
    _builder.MakePartC();
}

int main(void) {
    ConcreteBuilderA concreteBuilderA;
    ConcreteBuilderB concreteBuilderB;
    Director director;
    Product *pProduct;

    director.SetBuilder(&concreteBuilderA);
    director.Construct();
    pProduct = concreteBuilderA.GetProduct();
    pProduct->Show();

    director.SetBuilder(&concreteBuilderB);
    director.Construct();
    pProduct = concreteBuilderB.GetProduct();
    pProduct->Show();

    return 0;
}

4. Factory Method

意图�Q�定义一个用于创建对象的接口�Q�让子类军_��实例化哪一个类。Factory Method使一个类的实例化延迟到其子类�?/strong>

1) 看得��模式其实��是C++的多态特�?/strong>�Q��?strong>�l�承实现。因此，其别名�ؓ虚构造器�Q?Virtual Constructor�Q?/strong>�Q?/p>
2) 作�ؓ模式与C++多态特性不同的是，Creator可以定义工厂�Ҏ��的缺省实�?/strong>�Q�完成缺省操作，MFC大量使用了这一思想�?/p>
参与者：

• Product
�?定义工厂�Ҏ��所创徏的对象的接口�?/p>
• ConcreteProduct
�?实现Product接口�?/p>
• Creator
�?声明工厂�Ҏ��Q�该�Ҏ��q�回一个Product�c�d��的对象。Creator也可以定义一个工厂方法的�~�省实现�Q�它�q�回一个缺省的ConcreteProduct对象�?br>�?可以调用工厂�Ҏ��以创��Z��个Product对象�?/p>
• ConcreteCreator
�?重定义工厂方法以�q�回一个ConcreteProduct实例�?/p>
代码�Q?/strong>

ConcreteProduct *ConcreteCreator::FactoryMethod() {     ConcreteProduct *pProduct = new ConcreteProduct;     return pProduct; }

Product *Creator::FactoryMethod() {     Product *pProduct = new Product;     return pProduct; }

int main(void) {
    Creator creator;
    ConcreteProduct *pProduct;

    pProduct = creator.FactoryMethod();
    pProduct->Show();

    return 0;
}

5. Prototype

意图�Q�用原型实例指定创徏对象的种�c�，�q�且通过拯��q�些原型创徏新的对象�?/strong>

1) 创徏不再通过工厂新类�l�承�Q�inheritance�Q?/strong>�Q�而是通过委托�Q�delegation�Q?/strong>�Q?/p>
2) 栚w�?strong>拯��原型实例创徏新对象�?/p>
参与者：

• ProtoType
�?声明一个克隆自�w�的接口�?/p>
• ConcreteProtoType
�?实现一个克隆自�w�的操作�?/p>
• Client
�?让一个原型克隆自�w�从而创��Z��个新的对象�?/p>
代码�Q?/strong>

class ProtoType
{
public:
    virtual void Draw();
    virtual ProtoType *Clone() = 0;
    virtual void Initialize();
};

class ProtoTypeA: public ProtoType
{
public:
    virtual ProtoType *Clone()
    {
        return new ProtoTypeA;
    }
};

class ProtoTypeB: public ProtoType
{
public:
    virtual ProtoType *Clone()
    {
        return new ProtoTypeB;
    }
};

class Client
{
public:
    static ProtoType *Clone( int choice );

private:
    static ProtoType *s_prototypes[3];
};

ProtoType* Client::s_prototypes[] = { 0, new ProtoTypeA, new ProtoTypeB };

ProtoType *Client::Clone(int choice)
{
    return s_prototypes[choice]->Clone();
}

6. Singleton

意图�Q�保证一个类仅有一个实例，�q�提供一个访问它的全局讉K��炏V�?/strong>

1) �?strong>静态成员函�?/strong>保证上述意图�?/p>
参与者：

• Singleton
�?定义一个Instance操作�Q�允许客戯��问它的唯一实例。Instance是一个类操作�Q�即C++中的一个静态成员函敎ͼ��?br>�?可能负责创徏它自��q��唯一实例�?/p>
代码�Q?/strong>

class Singleton
{
public:
    static Singleton *GetInstance()
    {
        if (!s_instance)
            s_instance = new Singleton;
        return s_instance;
    }

    void Run()    {}

private:
    static Singleton *s_instance;
    Singleton()    {}                // Singleton cannot be created outside.
};

Singleton *GetSingleton(void)
{
    return Singleton::GetInstance();
}

int main(void)
{
    GetSingleton()->Run();

    return 0;
}

______________________________________________

代码写的都比较简单，基本可以��各�U�模式之间的不同体现出来了�?/p>

RichardHe 2008-08-06 16:36 发表评论

2021最新久久久视精品爱,久久国产欧美日韩精品,久久国产精品无码HDAV

成员函数指针与高性能的C++委托