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();
};

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

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模式中使用组合，

C++11 设计模式之template模式，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;
}