C++25设计模式之策略模式

图片引用于百度

简介：指对象有某个行为，但是在不同的场景中，该行为有不同的实现算法

优点：新增一个算法逻辑仅需要继承一个处理类即可，不会改动原有的代码，符合开闭原则

缺点：算法类会累计的越来越多，并且要全部开放给外部

例子背景：现有一个数组需要排序，而排序算法样式多。使用策略模式实现它

策略模式代码：

• 抽象算法类：

#pragma once

class StrategySort
{
public:
        StrategySort() = default;
        virtual ~StrategySort() = default;
        virtual void Sort(int arr[], int length) = 0;
};

• 具体算法类：

#pragma once
#include "Strategy.h"
#include <memory>
#include <algorithm>
using namespace std;

class BubbleSort : public StrategySort
{
public:
        BubbleSort() {}
public:
        virtual void Sort(int arr[], int length)
        {
                if(length <= 0) return;
                for (int i = 0; i < length - 1; ++i)
                {
                        for (int j = i + 1; j < length; ++j)
                        {
                                if (arr[i] < arr[j])
                                {
                                        int tmp = arr[i];
                                        arr[i] = arr[j];
                                        arr[j] = tmp;
                                }
                        }
                }
        }
};

class C11Sort : public StrategySort
{
public:
        C11Sort() {}
public:
        virtual void Sort(int arr[], int length)
        {
                std::sort(arr, arr+length, [](int& a, int& b)
                {
                        return a > b;
                });
        }
};

class SelectSort : public StrategySort
{
public:
        SelectSort() {}
public:
        virtual void Sort(int arr[], int length)
        {
                int min;
                for (int i = 0; i < length - 1; i++)
                {
                        min = i;
                        for (int j = i + 1; j < length; j++) 
                        {
                                if (arr[j] < arr[min])
                                        min = j;
                        }
                        if (min != i)
                                swap(arr[i], arr[min]);
                }
        }
};

• 策略类：

#pragma once
#include "ConcreteStrategy.h"

class ContextSort
{
public:
        ContextSort(StrategySort* that) : m_strategySort(that){}
        void SetContext(StrategySort* that)
        {
                m_strategySort = that;
        }
        void Sort(int arr[], int length)
        {
                m_strategySort->Sort(arr, length);
        }
private:
        StrategySort* m_strategySort = nullptr;
};

• 引用：

#include "ConcreteStrategy.h"
#include "Context.h"
#include <iostream>

void PrintArray(int arr[], int len)
{
        for(int i = 0; i < len; ++i) cout << arr[i];
        cout << endl;
}

#define ARR_LENGTH 10
int main()
{
        int arr[] = { 5, 3, 8, 4, 9, 7, 2, 0, 1, 6 };
        shared_ptr<BubbleSort> bs(new BubbleSort);
        shared_ptr<C11Sort> cs(new C11Sort);
        shared_ptr<SelectSort> ss(new SelectSort);
        shared_ptr<ContextSort> context(new ContextSort(bs.get()));

        context->Sort(arr, ARR_LENGTH);
        context->SetContext(cs.get());
        context->SetContext(ss.get());
        PrintArray(arr, ARR_LENGTH);

        getchar();
        return 0;
}

总结：
策略模式(Strategy)：可以使得某种算法更加的多样性，能够避免多重条件判断，简化了操作，降低错误率，并且可以很方便的扩展算法

作者：丶梦爱
博客：https://blog.csdn.net/u014732297（转载请说明出处）