99精品国产99久久久久久97,欧美大战日韩91综合一区婷婷久久青草,国产精品久久久久久久久

GDI�~�程需要注意的地方

Sun, 03 Feb 2008 03:05:00 GMT

写GDI的时候，我们�l�常会由于粗心大意，忘记释放GDI资源�Q�导致GDI句柄泄露。再加上如果单元��试做的不好�Q�就会在产品发布以后发生问题�?/p>

众所周知�Q�Windows上对于一个进�E�允许的最大GDI句柄数量�?999�Q�如果程序有大量的GDI句柄没有被及时回�Ӟ��那么�E�序��׃��表现的不正常。如果这�U�问题发生在以前的WINDOWS 98�q�代�Q�甚至会造成�pȝ��崩溃�?/p>

所以，�q�里我将陆箋记录一些GDI�~�程需要注意的地方�Q�作��Z��后单元测试中的一部分来进行：

1、Create()必须Delete()�Q�包括CreateCompatibleDC

2、SelectObject()必须是成对出�?/p>

3�?H"打头的一些GDI句柄�Q�在使用完后要及旉��放。如::DeleteObject(HBITMAP)�Q?:DeleteDC(HDC)�{?/p>

4、记住一个原则：自己创徏的东西要自己释放�Q�如GetDC �?ReleaseDC

5、MFC的GDI有很多问题，使用的时候要非常��心。徏议最好直接用SDK写。��用WTL中的GDI也是一个不错的选择。WTL中有些GDI对象在声明的时候就可以军_��是由析构函数来帮你释放，�q�是�׃��自己释放�Q�非常方�ѝ�?/p>

��p��色系�l?/a> 2008-02-03 11:05 发表评论

(转蝲)观察�?(Subject/Observer) 模式实现

Tue, 29 Jan 2008 08:17:00 GMT

原文链接�Q?a title=http://www.shnenglu.com/eXile/archive/2007/09/16/32297.html href="http://www.shnenglu.com/eXile/archive/2007/09/16/32297.html">http://www.shnenglu.com/eXile/archive/2007/09/16/32297.html

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

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 ,则变成了以下情况�Q?

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

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

　　代码分�ؓ两个文�g�Q�IObserver.h �?Observer.h�Q�就贴在下面吧：
IObserver.h 　�Q?接口定义

#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 　�Q?具体实现

#pragma once

#include
#include

#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::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::iterator
            it = m_observers.begin(),
            e = m_observers.end();
while (it != e)
        {
            (*it++)->update(arg); // observer can be disconnected in update()
        }
    }

private:
    std::set 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::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   m_subjects;
};

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

template
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*);
};

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

��p��色系�l?/a> 2008-01-29 16:17 发表评论

(转蝲)vector的有序化操作

Tue, 29 Jan 2008 08:15:00 GMT

原文链接�Q?a title=http://www.shnenglu.com/eXile/archive/2008/01/29/42104.html href="http://www.shnenglu.com/eXile/archive/2008/01/29/42104.html">http://www.shnenglu.com/eXile/archive/2008/01/29/42104.html

　　在有些情况下�Q�需要用��C��个有序的vector。它的有序操作有三种�Q�查找，插入�Q�删除�?br>　　插入实现�Q?
template
inline void ordered_insert(Container& c, typename Container::value_type const& t)
{
    c.insert(std::upper_bound(c.begin(), c.end(), t), t);
}

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

　　删除实现�Q?
template
inline void erase_range(Container& c, std::pair const& r)
{
    c.erase(r.first, r.second);
}

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

template
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实现。如果要实现�c�M��map的关键字搜烦�Q�有一个技巧，��是用比较函数进行重载，比如学生要按学号查找�Q�则用以下定义：
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;
        }
    };
};

查找学号�?的学生：
std::vector students;

bool exist = std::binary_search(students.begin(), students.end(), 5, Student::LessThan());
删除学号�?的学生：
ordered_erase(students, 5, Student::LessThan());

��p��色系�l?/a> 2008-01-29 16:15 发表评论