众所周知，Windows上对于一个进程允许的最大GDI句柄数量为9999，如果程序有大量的GDI句柄没有被及时回收，那么程序就会表现的不正常。如果这种问题发生在以前的WINDOWS 98年代，甚至会造成系统崩溃。

所以，这里我将陆续记录一些GDI编程需要注意的地方，作为今后单元测试中的一部分来进行：

1、Create()必须Delete()，包括CreateCompatibleDC

2、SelectObject()必须是成对出现

3、"H"打头的一些GDI句柄，在使用完后要及时释放。如::DeleteObject(HBITMAP)，::DeleteDC(HDC)等

4、记住一个原则：自己创建的东西要自己释放，如GetDC 要 ReleaseDC

5、MFC的GDI有很多问题，使用的时候要非常小心。建议最好直接用SDK写。使用WTL中的GDI也是一个不错的选择。WTL中有些GDI对象在声明的时候就可以决定是由析构函数来帮你释放，还是由你自己释放，非常方便。

　　以前我曾经实现过观察者模式（signal / slot )。有位朋友不以为然，也把他的实现发给我。这是用纯ＯＯ的方式实现的，没有使用模板，不依赖于其它库。应该是仿Java或C#接口。设计得不错，具有以下特点：
　　１）当Subject或Observer 销毁时，连接自动断开（注册自动取消），当然，这也是实现该模式的重点。
　　２）考虑了以下因素：一个Subject是否允许多个Observer观察？一个Observer是否允许同时观察多个Subject? 由此可分为一对一，一对多，多对多，一般的GUI库中都是后两种情况，但自己写的程序中却第一种情况居多。所以他出于效率，设计了SimpleSubject和SimpleObserver。
　　不足之处如下：
　　１）Observer::update()只能带无类型的参数（好象也没有更好的办法）。
　　２）由于C++中没有匿名类，所以使用起来并没有Java中方便。于是我又添加了一个ObserverAdapter。
　　使用举例：

class A : public Subject
{
        int value;
public:
   void setValue(int v)
   {
       value = v;
       notify(&value);
   }      
};

class B : public Observer
{
public:
   void update(void* arg)
   {
       printf("A changed:%d", *(int*)arg);
   }      
};

void f(A* a, B* b)
{
    a->connect(b);
    a->setValue(1);
}

使用ObserverAdapter ,则变成了以下情况：

class B
{
   ObserverAdapter<B> observerOfA;
public:
   B(A* a) : observerOfA(this, &B::valueChanged)
   {
       a->connect(&observerOfA);
   }

   void valueChanged(void* arg)
   {
       printf("A changed:%d", *(int*)arg);
   }      
};

　　代码分为两个文件：IObserver.h 和 Observer.h，就贴在下面吧：
IObserver.h 　： 接口定义

#pragma once

class ISubject;

class IObserver
{
public:
    IObserver()  {}
    virtual ~IObserver() {};

    virtual void update(void*) = 0;

protected:
    virtual void addSubject(ISubject* ) = 0;
    virtual void removeSubject(ISubject* ) = 0;

    friend class ISubject;

private:
    IObserver(IObserver const&);
    IObserver& operator= (IObserver const&);
};

class ISubject
{
public:
    ISubject() {}
    virtual ~ISubject() {};

    virtual void connect(IObserver*) = 0;
    virtual void disconnect(IObserver*) = 0;
    virtual bool isConnected(IObserver*) const= 0;
    virtual void notify(void*) = 0;

protected:
    void addObserver(IObserver* observer);
    void removeObserver(IObserver* observer);

private:
    ISubject(ISubject const&);
    ISubject& operator= (ISubject const&);
};

Observer.h 　： 具体实现

#pragma once

#include <cassert>
#include <set>

#include "IObserver.h"

//-------------------------------------------------------------------

inline void ISubject::addObserver(IObserver* observer)
{
    observer->addSubject(this);
}

inline void ISubject::removeObserver(IObserver* observer)
{
    observer->removeSubject(this);
}

//-------------------------------------------------------------------

class SimpleSubject : public ISubject
{
public:
    SimpleSubject() : m_observer(0)
    {
    }

    ~SimpleSubject()
    {
if (m_observer) removeObserver(m_observer);
    }

    virtual void connect(IObserver* observer)
    {
        assert(observer);
if (m_observer)
            removeObserver(m_observer);
        addObserver(observer);
        m_observer = observer;
    }

    virtual void disconnect(IObserver* observer)
    {
        assert(observer && observer == m_observer);
        removeObserver(m_observer);
        m_observer = 0;
    }

    virtual bool isConnected(IObserver* observer) const
    {
        return observer == m_observer;
    }

    virtual void notify(void* arg)
    {
if (m_observer) m_observer->update(arg);
    }

private:
    IObserver*  m_observer;

};

//-------------------------------------------------------------------

class Subject : public ISubject
{
public:
    Subject() : m_observers()
    {
    }

    ~Subject()
    {
        std::set<IObserver*>::iterator
            it = m_observers.begin(),
            e  = m_observers.end();
for (; it != e; ++it)
        {
            removeObserver(*it);
        }
    }

    virtual void connect(IObserver* observer)
    {
        assert(observer);
        addObserver(observer);
        m_observers.insert(observer);
    }

    virtual void disconnect(IObserver* observer)
    {
        assert(observer);
        removeObserver(observer);
        m_observers.erase(observer);
    }

    virtual bool isConnected(IObserver* observer) const
    {
        return m_observers.find(observer) != m_observers.end();
    }

    virtual void notify(void* arg)
    {
        std::set<IObserver*>::iterator
            it = m_observers.begin(),
            e  = m_observers.end();
while (it != e)
        {
            (*it++)->update(arg); // observer can be disconnected in update()
        }
    }

private:
    std::set<IObserver*>  m_observers;

};

//-------------------------------------------------------------------

class SimpleObserver  : public IObserver
{
public:
    SimpleObserver() : m_subject(0)
    {
    }

    ~SimpleObserver()
    {
if (m_subject) m_subject->disconnect(this);
    }

    ISubject* getSubject() const
    {
        return m_subject;
    }

private:
    virtual void addSubject(ISubject* subject)
    {
if (m_subject) m_subject->disconnect(this);
        m_subject = subject;
    }

    virtual void removeSubject(ISubject* subject)
    {
        assert(subject == m_subject);
        m_subject = 0;
    }

private:
    ISubject*   m_subject;
};


//-------------------------------------------------------------------

class Observer : public IObserver
{
public:
    Observer() : m_subjects()
    {
    }

    ~Observer()
    {
        std::set<ISubject*>::iterator
            it = m_subjects.begin(),
            e  = m_subjects.end();
while (it != e)
        {
            (*it++)->disconnect(this);
        }
    }

private:
    virtual void addSubject(ISubject* subject)
    {
        assert(subject);
        m_subjects.insert(subject);
    }

    virtual void removeSubject(ISubject* subject)
    {
        assert(subject);
        m_subjects.erase(subject);
    }

private:
    std::set<ISubject*>   m_subjects;
};

//-------------------------------------------------------------------

template <class T, class Base = SimpleObserver>
class ObserverAdapter  : public Base
{
public:
    ObserverAdapter(T* t, void (T::*f)(void*))
     : m_obj(t), m_func(f)
    {
    }

    virtual void update(void* arg)
    {
        (m_obj->*m_func)(arg);
    }

private:
    T*  m_obj;
    void (T::*m_func)(void*);
};

//-------------------------------------------------------------------

　　在有些情况下，需要用到一个有序的vector。它的有序操作有三种：查找，插入，删除。
　　插入实现：

template <typename Container>
inline void ordered_insert(Container& c,  typename Container::value_type const& t)
{
    c.insert(std::upper_bound(c.begin(), c.end(), t), t);
}

template <typename Container, typename Cmp>
inline void ordered_insert(Container& c,　typename Container::value_type const& t,　Cmp cmp)
{
    c.insert(std::upper_bound(c.begin(), c.end(), t, cmp), t);
}

　　删除实现：

template <typename Container, typename It>
inline void erase_range(Container& c, std::pair<It, It> const& r)
{
    c.erase(r.first, r.second);
}

template <typename Container>
inline void ordered_erase(Container& c,  typename Container::value_type const& t)
{
    erase_range(c, std::equal_range(c.begin(), c.end(), t));
}

template <typename Container, typename T, typename Cmp>
inline void ordered_erase(Container& c, T const& t, Cmp cmp)
{
    erase_range(c, std::equal_range(c.begin(), c.end(), t, cmp));
}

　　查找可通过binary_search, lower_bound, upper_bound, 或者equal_range实现。如果要实现类似map的关键字搜索，有一个技巧，就是用比较函数进行重载，比如学生要按学号查找，则用以下定义：

struct Student
{
int            id;
    std::string name;

    struct LessThan
    {
        bool operator() (Student const& x, Student const& y)
        {
            return x.id < y.id;
        }

        bool operator() (Student const& x, int id)
        {
            return x.id < id;
        }

        bool operator() (int id, Student const& y)
        {
            return id < y.id;
        }
    };
};

查找学号为5的学生：

std::vector<Student> students;

bool exist = std::binary_search(students.begin(), students.end(), 5, Student::LessThan());

删除学号为5的学生：

ordered_erase(students, 5, Student::LessThan());