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

Question

What are the elegant design pattern(GoF patterns) implementation in c++ ?

Can anyone give me some examples of design pattern implementations based on template(which can be reused) ?

Example(Template based Singleton) :-

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

Take a look at Modern C++ Design by Alexandrescu

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

He covers template implementation of several design patterns. In fact, IIRC, one of the forewards is written by one of the GOF.

Answer 2

In my experience, there are really no good design pattern template libraries. A design pattern is difficult to capture correctly as a concrete template without caveats or imposing difficult to enforce restrictions on the classes that try to plug themselves into it.

Let's take your Singleton example. Well, I'm actually going to rewrite it so that I don't have to have Boost to use it:

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

Although this makes Singleton<T> a singleton, what is really wanted is to make the T a singleton. Well, you might say, this is no problem, because the usage is that T should inherit from Singleton<T> (as enforced by Singleton::GetInstanceInternal() ):

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

A naive programmer would think "Job done!", because since Foo inherits from Singleton<Foo> , that makes Foo a singleton. But it doesn't, because it doesn't prevent this:

Foo x;

To fix this, the constructor should be made private (and therefore, Singleton<Foo> needs to be made a friend). To prevent calling the destructor directly, it should be made private as well.

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

So, in addition to inheriting Singleton<Foo> there are additional requirements that inheritance alone cannot properly enforce. All these requirements can be documented, but it can be argued that using the templates become less useful, and it is almost as much work as putting the singleton functionality into Foo directly.