c++ - 设计模式(GoF patterns)在c++中的实现

Question

什么是优雅的设计模式(GoF模式)在c++中的实现？

谁能给我一些基于模板(可以重用)的设计模式实现的例子？

示例(基于模板的单例):-

template<typename T>
class Singleton : public boost::noncopyable
{
public:
    static Singleton& GetInstance()
    {
        boost::call_once(&CreateInstance, m_onceFlg);
        return *m_pInstance;
    }
    virtual ~Singleton()
    {
    }
protected:
    Singleton ()
    {
    }
    static void CreateInstance()
    {
        m_pInstance.reset(new T());
    }
private:
    static boost::once_flag m_onceFlg;
    static boost::scoped_ptr<T> m_pInstance;
};

Answer 1

根据我的经验，确实没有好的设计模式模板库。如果没有警告或对试图将自己插入其中的类施加难以实现的限制，设计模式很难作为具体模板正确捕获。

让我们把你的Singleton例子。好吧，我实际上要重写它，这样我就不必使用 Boost 了:

template <typename T>
class Singleton {
    Singleton (const Singleton<T> &) = delete;
    Singleton & operator = (const Singleton<T> &) = delete;
    static Singleton<T> & GetInstanceInternal () {
        static T instance;
        return instance;
    }
protected:
    Singleton () {}
    ~Singleton () {}
public:
    static T & GetInstance () {
        return static_cast<T &>(GetInstanceInternal());
    }
};

虽然这使得 Singleton<T>一个单例，真正想要的是制作 T一个单例。好吧，你可能会说，这没问题，因为用法是 T应该继承自 Singleton<T> (由 Singleton::GetInstanceInternal() 强制执行):

class Foo : public Singleton<Foo> {
public:
    void foo () { /*...*/ }
};

一个天真的程序员会认为“工作完成了!”，因为自Foo继承自 Singleton<Foo> ，这使得 Foo一个单例。但它不会，因为它不会阻止这种情况:

Foo x;

要解决此问题，构造函数应设为私有(private)(因此，Singleton<Foo> 需要成为好友)。为了防止直接调用析构函数，它也应该设为私有(private)。

class Foo : public Singleton<Foo> {
    friend class Singleton<Foo>;
    Foo () {}
    ~Foo () {}
public:
    void foo () { /*...*/ }
};

所以，除了继承Singleton<Foo>还有一些额外的要求，单靠继承是无法正确执行的。所有这些要求都可以记录下来，但可以说使用模板变得没那么有用了，而且它几乎与将单例功能放入 Foo 中一样多。直接。