Question

c ++中优雅的设计模式（GoF模式）实现是什么？

任何人都可以给我一些基于模板的设计模式实现的例子（可以重复使用）吗？

示例（基于模板的单身人士）： -

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

看看Alexandrescu的Modern C ++ Design

http://www.amazon.com/Modern-Design-Generic-Programming-Patterns/dp/0201704315

他介绍了几种设计模式的模板实现。事实上，IIRC，其中一个前锋是由一个GOF写的。

Answer 2

根据我的经验，实际上没有好的设计模板模板库。设计模式很难作为具体模板正确捕获而没有任何警告，或者难以对试图插入其中的类强制实施限制。

我们来看看你的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;

要解决此问题，应将构造函数设为私有（因此，Singleton<Foo>需要成为朋友）。为了防止直接调用析构函数，它也应该是私有的。

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

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

c ++中的设计模式（GoF模式）实现

2 个答案: