c++设计

1、假设设计以下函数

fn(参数随意)
{
        A() //固定
        C() //不定
        B() //固定
}

要求在A与B不变的情况下可以任意改变C()，C()的函数形式不统一，且传入不同的C()时不用额外修改函数

思路：

参数不固定，那就给固定下来，参数和返回值使用结构体封装起来，用void*指针传入，然后用int型flag标识是哪个结构体，C函数根据不同flag执行

不同流程

1、适配器模式

适配器模式将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。它包括类适配器和对象适配器，

本文针对的是对象适配器。举个例子，在STL中就用到了适配器模式。STL实现了一种数据结构，称为双端队列（deque），支持前后两段的插入与删除。STL

实 现栈和队列时，没有从头开始定义它们，而是直接使用双端队列实现的。这里双端队列就扮演了适配器的角色。队列用到了它的后端插入，前端删除。而栈

用到了它的后端插入，后端删除。假设栈和队列都是一种顺序容器，有两种操作：压入和弹出。

//双端队列  
class Deque  
{  
public:  
    void push_back(int x) { cout<<"Deque push_back"<<endl; }  
    void push_front(int x) { cout<<"Deque push_front"<<endl; }  
    void pop_back() { cout<<"Deque pop_back"<<endl; }  
    void pop_front() { cout<<"Deque pop_front"<<endl; }  
};  
//顺序容器  
class Sequence  
{  
public:  
    virtual void push(int x) = 0;  
    virtual void pop() = 0;  
};  
//栈  
class Stack: public Sequence  
{  
public:  
    void push(int x) { deque.push_back(x); }  
    void pop() { deque.pop_back(); }  
private:  
    Deque deque; //双端队列  
};  
//队列  
class Queue: public Sequence  
{  
public:  
    void push(int x) { deque.push_back(x); }  
    void pop() { deque.pop_front(); }  
private:  
    Deque deque; //双端队列  
};  

int main()  
{  
    Sequence *s1 = new Stack();  
    Sequence *s2 = new Queue();  
    s1->push(1); s1->pop();  
    s2->push(1); s2->pop();  
    delete s1; delete s2;  
    return 0;  
}  

出自：http://blog.csdn.net/wuzhekai1985

using namespace std;  
  
// "ITarget"  
class Target  
{  
public:  
    // Methods  
    virtual void Request(){};  
};  
  
// "Adaptee"  
class Adaptee  
{  
public:  
    // Methods  
    void SpecificRequest()  
    {  
        cout<<"Called SpecificRequest()"<<endl;  
    }  
};  
  
// "Adapter"  
class Adapter : public Target  
{  
private:  
    Adaptee *adaptee;  
  
public:  
    Adapter()  
    {  
        adaptee = new Adaptee();  
    }  
  
    // Implements ITarget interface  
    void Request()  
    {  
        // Possibly do some data manipulation  
        // and then call SpecificRequest    
        adaptee->SpecificRequest();  
    }  
};  
  
  
int main()  
{  
    // Create adapter and place a request  
    Target *t = new Adapter();  
    t->Request();  
  
    return 0;  
}  

2、简单工厂模式

所谓简单工厂模式，是一种实例化对象的方式，只要输入需要实例化对象的名字，就可以通过工厂对象的相应工厂函数来制造你需要的对象。

简单工厂模式的核心是，对于一个父类的多个继承子类，工厂对象的工厂函数根据用户输入，自动new出一个子类对象并返回其父类的指针，这样利用父类的指针执行父类的虚函数，就可以动态绑定子类的重写函数，从而实现多态。

对于一个只拥有加减乘除运算的简单计算器，我们设计一个Operation的父类，并构造加减乘除四个类继承父类重写运算函数GetResult。然后定义工厂类中的工厂函数，其根据用户的输入new出相应的对象实例并返回其父类的指针。

enum CTYPE {COREA, COREB};     
class SingleCore    
{    
public:    
    virtual void Show() = 0;  
};    
//单核A    
class SingleCoreA: public SingleCore    
{    
public:    
    void Show() { cout<<"SingleCore A"<<endl; }    
};    
//单核B    
class SingleCoreB: public SingleCore    
{    
public:    
    void Show() { cout<<"SingleCore B"<<endl; }    
};    
//唯一的工厂，可以生产两种型号的处理器核，在内部判断    
class Factory    
{    
public:     
    SingleCore* CreateSingleCore(enum CTYPE ctype)    
    {    
        if(ctype == COREA) //工厂内部判断    
            return new SingleCoreA(); //生产核A    
        else if(ctype == COREB)    
            return new SingleCoreB(); //生产核B    
        else    
            return NULL;    
    }    
};