2.策略模式

1.策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互交换。策略模式让算法独立于使用它的客户而独立变换。

　例：高速缓存交换算法

//交换算法抽象类
class ReplaceAlgorithm {
public:
    virtual void Replace() = 0;
};

//具体算法
class LRU_ReplaceAlgorithm : public ReplaceAlgorithm {
public:
    virtual void Replace() {
        std::cout << "Least Recently Used replace algorithm" << std::endl;
    }
};

class FIFO_ReplaceAlgorithm : public ReplaceAlgorithm {
public:
    virtual void Replace() {
        std::cout << "First in First out replace algorithm" << std::endl;
    }
};

class Random_ReplaceAlgorithm : public ReplaceAlgorithm {
public:
    virtual void Replace() {
        std::cout << "Random replace algorithm" << std::endl;
    }
};

　　给出Cache的定义，直接影响了客户的使用方式，关键在于如何指定算法

　　（1）直接通过参数指定，传入一个特定算法指针，如果使用这种方式，用户就要知道算法的定义　　

class Cache {
public:
    Cache(ReplaceAlgorithm* ra) : m_ra(ra) {}
    ~Cache() { delete m_ra; }
    void Replace() { m_ra->Replace(); }
private:
    ReplaceAlgorithm* m_ra;
};

int main() {
    Cache cache(new LRU_ReplaceAlgorithm);
    cache.Replace();
    return 0;
}

　　（2）直接通过参数指定，但是不是传入指针，而是传入一个标签

　　　　算法的定义使用策略模式，Cache的定义使用了简单工厂模式　　

enum RA {LRU, FIFO, RANDOM};
class Cache {
public:
    Cache(enum RA ra) {
        if (LRU == ra) { 
            m_ra =  new LRU_ReplaceAlgorithm; 
        }
        if (FIFO == ra) { 
            m_ra =  new FIFO_ReplaceAlgorithm; 
        }
        if (RANDOM == ra) {
            m_ra = new Random_ReplaceAlgorithm;
        }
        m_ra = nullptr;
    }
    ~Cache() { delete m_ra; }
    void Replace() {
        m_ra->Replace();
    }
private:
    ReplaceAlgorithm* m_ra;
};

int main() {
    Cache cache(LRU);
    cache.Replace();
    return 0;
}

　　（3）用模板实现　　

template <typename T> class Cache {
public:
    Cache() { }
    ~Cache() { }
    void Replace() {
        m_ra.Replace();
    }
private:
    T m_ra;
};

int main() {
    Cache<Random_ReplaceAlgorithm> cache;
    cache.Replace();
    return 0;
}