strategy的两种实现

// strategy.cpp

#include <stdio.h>

#ifdef _X_RELEASE_
    #define TRACE(str)
#else
    #define TRACE(str) printf("%s/n", str)
#endif

// 策略抽象类
class CStrategy   
{
protected:
    CStrategy()
    {
        TRACE("CStrategy");
    }

public:
    virtual ~CStrategy()
    {
        TRACE("~CStrategy");
    }
   
public:     
    virtual int AlgorithmInterface(int a, int b) = 0; // 算法接口
};   
  
// 策略具体类A
class CConcreteStrategyA : public CStrategy   
{   
public:   
    CConcreteStrategyA()
    {
        TRACE("CConcreteStrategyA");
    }

    ~CConcreteStrategyA()
    {
        TRACE("~CConcreteStrategyA");
    }
   
    virtual int AlgorithmInterface(int a, int b)
    {
        TRACE("CConcreteStrategyA::AlgorithmInterface");
        return a + b;
    }
};

// 策略具体类B
class CConcreteStrategyB : public CStrategy   
{   
public:   
    CConcreteStrategyB()
    {
        TRACE("CConcreteStrategyB");
    }

    ~CConcreteStrategyB()
    {
        TRACE("~CConcreteStrategyB");
    }
   
    virtual int AlgorithmInterface(int a, int b)
    {
        TRACE("CConcreteStrategyB::AlgorithmInterface");
        return a * b;
    }
};

// 使用策略的上下文类
class CContext   
{   
private:
    CStrategy* m_pStrategy;
   
public:   
    CContext(CStrategy* pStrategy)   
    {
        TRACE("CContext");
        m_pStrategy = pStrategy;
    }

    ~CContext()   
    {
        TRACE("~CContext");

        if (m_pStrategy)
        {
            delete m_pStrategy;
            m_pStrategy = 0;
        }
    }

    // 在ContextInterface中调用AlgorithmInterface，AlgorithmInterface需要的参数
    // 由ContextInterface传递，作为参数或在ContextInterface内部构造
    int ContextInterface(int a, int b)   
    {
        TRACE("ContextInterface");

        int iRes = m_pStrategy->AlgorithmInterface(a, b);
        return iRes;
    }   
};   
 
int main()   
{
    CContext* pContextA = new CContext(new CConcreteStrategyA()); // 指定使用的策略
    if (!pContextA)
    {
        TRACE("error 1");
        return 1;
    }

    int iResA = pContextA->ContextInterface(2, 3);
    printf("%d/n", iResA);

    CContext* pContextB = new CContext(new CConcreteStrategyB()); // 指定使用的策略
    if (!pContextB)
    {
        TRACE("error 1");
        return 1;
    }

    int iResB = pContextB->ContextInterface(2, 3);
    printf("%d/n", iResB);
   
    delete pContextA;
    pContextA = 0;

    delete pContextB;
    pContextB = 0;

    return 0;
}  

/*
root@ubuntu:/home/hgc/test# g++ strategy.cpp -o strategy.cpp -g -Wall
root@ubuntu:/home/hgc/test# ./strategy.cpp
CStrategy
CConcreteStrategyA
CContext
ContextInterface
CConcreteStrategyA::AlgorithmInterface
5
CStrategy
CConcreteStrategyB
CContext
ContextInterface
CConcreteStrategyB::AlgorithmInterface
6
~CContext
~CConcreteStrategyA
~CStrategy
~CContext
~CConcreteStrategyB
~CStrategy
root@ubuntu:/home/hgc/test#
*/

// strategy_template.cpp

#include <stdio.h>

#ifdef _X_RELEASE_
    #define TRACE(str)
#else
    #define TRACE(str) printf("%s/n", str)
#endif

// 策略抽象类
class CStrategy   
{
protected:
    CStrategy()
    {
        TRACE("CStrategy");
    }

public:
    virtual ~CStrategy()
    {
        TRACE("~CStrategy");
    }
   
public:     
    virtual int AlgorithmInterface(int a, int b) = 0; // 算法接口
};   
  
// 策略具体类A
class CConcreteStrategyA : public CStrategy   
{   
public:   
    CConcreteStrategyA()
    {
        TRACE("CConcreteStrategyA");
    }

    ~CConcreteStrategyA()
    {
        TRACE("~CConcreteStrategyA");
    }
   
    virtual int AlgorithmInterface(int a, int b)
    {
        TRACE("CConcreteStrategyA::AlgorithmInterface");
        return a + b;
    }
};

// 策略具体类B
class CConcreteStrategyB : public CStrategy   
{   
public:   
    CConcreteStrategyB()
    {
        TRACE("CConcreteStrategyB");
    }

    ~CConcreteStrategyB()
    {
        TRACE("~CConcreteStrategyB");
    }
   
    virtual int AlgorithmInterface(int a, int b)
    {
        TRACE("CConcreteStrategyB::AlgorithmInterface");
        return a * b;
    }
};

// 使用策略的上下文类模板
template <typename TStrategy>
class CContext   
{   
private:
    TStrategy m_Strategy;
   
public:   
    CContext()   
    {
        TRACE("CContext");
    }

    ~CContext()   
    {
        TRACE("~CContext");
    }

    // 在ContextInterface中调用AlgorithmInterface，AlgorithmInterface需要的参数
    // 由ContextInterface传递，作为参数或在ContextInterface内部构造
    int ContextInterface(int a, int b)   
    {
        TRACE("ContextInterface");

        int iRes = m_Strategy.AlgorithmInterface(a, b);
        return iRes;
    }   
};   
 
int main()   
{
    CContext<CConcreteStrategyA> ContextA; // 指定使用的策略
    int iResA = ContextA.ContextInterface(2, 3);
    printf("%d/n", iResA);

    CContext<CConcreteStrategyB> ContextB; // 指定使用的策略
    int iResB = ContextB.ContextInterface(2, 3);
    printf("%d/n", iResB);

    return 0;
}  

/*
root@ubuntu:/home/hgc/test# g++ strategy_template.cpp -o strategy_template -g -Wall
root@ubuntu:/home/hgc/test# ./strategy_template
CStrategy
CConcreteStrategyA
CContext
ContextInterface
CConcreteStrategyA::AlgorithmInterface
5
CStrategy
CConcreteStrategyB
CContext
ContextInterface
CConcreteStrategyB::AlgorithmInterface
6
~CContext
~CConcreteStrategyB
~CStrategy
~CContext
~CConcreteStrategyA
~CStrategy
root@ubuntu:/home/hgc/test#
*/