C++11 设计模式之template模式，strategy模式

本文主要用于记录C++11 shared_ptr在设计模式中的使用。

1. template.h：

#pragma once
#include <memory>

class AbstractClass
{
public:
    virtual ~AbstractClass() = default;
    void TemplateMethod();

protected:
    AbstractClass() = default;
    virtual void PrimiOp1() = 0;
    virtual void PrimiOp2() = 0;
};

class ConcreteClass1 : public AbstractClass
{
public:
    ConcreteClass1() = default;
    virtual ~ConcreteClass1() = default;

protected:
    void PrimiOp1();
    void PrimiOp2();
};

class ConcreteClass2 : public AbstractClass
{
public:
    ConcreteClass2() = default;
    virtual ~ConcreteClass2() = default;

protected:
    void PrimiOp1();
    void PrimiOp2();
};

2. strategy.h:

#pragma once

class Strategy
{
public:
    Strategy() = default;
    virtual ~Strategy() = default;

    virtual void AlgrithmInterface() = 0;
protected:
private:

};

class ConcreteStrategyA : public Strategy
{
public:
    ConcreteStrategyA() = default;
    virtual ~ConcreteStrategyA() = default;

    void AlgrithmInterface();

};

class ConcreteStrategyB : public Strategy
{
public:
    ConcreteStrategyB() = default;
    virtual ~ConcreteStrategyB() = default;

    void AlgrithmInterface();
};

3. context.h:

#pragma once
#include <memory>
#include "strategy.h"

class Context
{
public:
    Context(std::shared_ptr<Strategy>& stg);

    virtual ~Context() = default;

    void DoAction();

protected:
private:
    std::shared_ptr<Strategy> m_stg{};
};

strategy模式中使用组合，

 

 

template.cpp:

#include <iostream>
#include <memory>
#include <vector>
#include "template.h"

using namespace std;

void AbstractClass::TemplateMethod()
{
    this->PrimiOp1();
    this->PrimiOp2();
}

void ConcreteClass1::PrimiOp1()
{
    std::cout << "primiop1 " << std::endl;
}

void ConcreteClass1::PrimiOp2()
{
    cout << "primiop2" << endl;
}

void ConcreteClass2::PrimiOp1()
{
    std::cout << "2 primiop1 " << std::endl;
}

void ConcreteClass2::PrimiOp2()
{
    cout << "2 primiop2" << endl;
}

 

Strategy.cpp:

#include <iostream>
#include "strategy.h"

using namespace std;

void Strategy::AlgrithmInterface()
{

}

void ConcreteStrategyA::AlgrithmInterface()
{
    cout << "A algrithminterface" << endl;
}

void ConcreteStrategyB::AlgrithmInterface()
{
    cout << "B algrithminterface" << endl;
}

 

context.cpp:

#include "context.h"

Context::Context(std::shared_ptr<Strategy>& stg)
{
    m_stg = stg;
}

void Context::DoAction()
{
    m_stg->AlgrithmInterface();
}

 

简单例子这两种模式的使用：

main.cpp:

#include <iostream>
#include <vector>
#include "template.h"
#include <memory>
#include <map>

#include "context.h"

using namespace std;

int main(int argc, char ** argv)
{
    std::shared_ptr<AbstractClass> abs = std::make_shared<ConcreteClass1>();

    std::shared_ptr<AbstractClass> abs2 = std::make_shared<ConcreteClass2>();

    abs->TemplateMethod();
    abs2->TemplateMethod();

    std::shared_ptr<Strategy> pStra = std::make_shared<ConcreteStrategyA>();
    std::shared_ptr<Context> pCon{};

    std::map<std::string, std::shared_ptr<Strategy>> strategys = 
    {
        {"1", std::make_shared<ConcreteStrategyA>()},
        {"2", std::make_shared<ConcreteStrategyB>()}
    };

    for (auto item : strategys)
    {
        pCon = std::make_shared<Context>(item.second);
        pCon->DoAction();
    }

    auto findItem = strategys.find("1");
    if (findItem != strategys.end())
    {
        pCon = std::make_shared<Context>(findItem->second);
        pCon->DoAction();
    }
    return 0;
}