BOOL CMyWnd::PreTranslateMessage(MSG* pMsg)
{
 m_toolTip.RelayEvent(pMsg);  
 return CGameWnd::PreTranslateMessage(pMsg);
}

但是由于CMyWnd是在DLL中，所以重载PreTranslateMessage无效，
具体原因我忘记了，反正网上都可以搜索到。不过解决方案都给的
不是很明确，在这里我把我的解决方法记录下来，省得以后忘掉了。
主要是在创建CMyWnd实例的时候把窗口指针存下来，然后使用全局
消息钩子执行CMyWnd::PreTranslateMessage，代码如下

1.定义全局变量
 HHOOK g_hHook = 0;
 CMyWnd* g_pMyWnd = NULL;

2.安装全局钩子，要在DLL中安装
 g_hHook = ::SetWindowsHookEx(WH_GETMESSAGE, HookProc, 0, ::GetCurrentThreadId());

3.创建窗体的时候保留指针
 m_pMyWnd = new CMyWnd();
 g_pMyWnd = m_pMyWnd;

4.钩子函数
LRESULT CALLBACK HookProc(int nCode, WPARAM wParam, LPARAM lParam)
{
 MSG* pMsg = (MSG*)lParam;
 if(g_pMyWnd && (pMsg->hwnd == g_pMyWnd->m_hWnd))
 {
  g_pMyWnd->PreTranslateMessage(pMsg);
 }
 return CallNextHookEx(g_hHook, nCode, wParam, lParam);
}

5.退出的时候别忘了卸载钩子
 if(g_hHook) 
  UnhookWindowsHookEx(g_hHook);

程序中需要注意的地方，释放树结点的时候，要使用后续遍历，先释放子结点后才释放根结点。

/**//* -------------------------------------------------------------------------
// 文件名  ： binarytree.h
// 创建者  ：  dj
// 创建时间 ： 2008-1-1
// 功能描述 ： 二叉排序树
// -----------------------------------------------------------------------*/
#ifndef __BINARYTREE_H__
#define __BINARYTREE_H__

#define SAFE_DELETE(p) {if(p) { delete [] (p); (p) = NULL;}}

struct TreeNode
{
    TreeNode(const char* s):
    counter(1), left(NULL), right(NULL)
    {
        name = new char[strlen(s)+1];
        strcpy(name, s);
    }
    ~TreeNode()
    {
        SAFE_DELETE(name);
    }
    char* name;
    int counter;
    TreeNode* left;
    TreeNode* right;
};

class BinaryTree
{

public:
    BinaryTree():m_pRoot(NULL)
    {}
    ~BinaryTree()
    {
        FreeTree(m_pRoot);
    }
    void Lookup(const char* sName)
    {
        TreeNode** p = &m_pRoot;
        while(*p)
        {
            int cmp = strcmp(sName, (*p)->name);
            if (cmp<0)
                p = &((*p)->left);
            else if (cmp>0)
                p = &((*p)->right);
            else                        //found the word
            {
                ((*p)->counter)++;        //increase the counter
                return;
            }
        }
        // not found,  then add the word node.
        TreeNode* pNode = new TreeNode(sName);
        *p = pNode;
    }
    void Dump(const char* sFile)
    {
        ofstream f(sFile);
        Travel(m_pRoot, f);
        f.close();
    }
private:
    void Travel(TreeNode* pNode, ofstream& f)
    {
        if (!pNode)
            return;
        Travel(pNode->left, f);
        f<<pNode->name<<"  "<<pNode->counter<<endl;
        Travel(pNode->right, f);
    }
    void FreeTree(TreeNode* pNode)
    {
        if(!pNode)
            return;
        FreeTree(pNode->left);
        FreeTree(pNode->right);
        delete pNode;        
    }
private:
    TreeNode* m_pRoot;
};

#endif //__BINARYTREE_H__

int main(int argc, char* argv[])
{
    BinaryTree tree;
    ifstream f("c:\\ip.txt");
    string s;
    while(f>>s)
    {
        tree.Lookup(s.c_str());
    }
    tree.Dump("c:\\stat.txt");
    return 0;
}

其中寻找支点元素pivot有多种方法，不同的方法会导致快速排序的不同性能。根据分治法平衡子问题的思想，希望支点元素可以使p[m..n]尽量平均地分为两部分，但实际上很难做到。下面给出几种寻找pivot的方法。

1.选择p[m..n]的第一个元素p[m]的值作为pivot；
2.选择p[m..n]的最后一个元素p[n]的值作为pivot；
3.选择p[m..n]中间位置的元素p[k]的值作为pivot；
4.选择p[m..n]的某一个随机位置上的值p[random(n-m)+m]的值作为pivot；
　　按照第4种方法随机选择pivot的快速排序法又称随机化版本的快速排序法，在实际应用中该方法的性能也是最好的。本程序使用第4种方法。要求节点类型支持比较运算符。

template<typename T>
void quicksort(T* v, int n)
{
    if (n<=1)
        return;
    int last = 0;
    int pivot = rand()%n;
    swap(v, 0, pivot);
    for (int i = 1; i < n; i++)
    {
        if (v[i]<v[0])
            swap(v, ++last, i);
    }
    swap(v, last, 0);
    quicksort(v, last);
    quicksort(v+last+1, n-last-1);
}

template<typename T>
void swap(T* v, int i, int j)
{
    T tmp = v[i];
    v[i] = v[j];
    v[j] = tmp;    
}

struct str
{
    str(const char* a)
    {
        assert(a);
        v = new char[strlen(a)+1];
        strcpy(v, a);
    }
    str(const str& a)
    {
        assert(a.v);
        v = new char[strlen(a.v)+1];
        strcpy(v, a.v);
    }
    ~str()
    {
        delete [] v;
    }
    void operator = (const str& a)
    {
        if (this == &a)
            return;
        assert(a.v);
        delete [] v;
        v = new char[strlen(a.v)+1];
        strcpy(v, a.v);
    }
    bool operator == (const str& a) const
    {
        return (strcmp(v, a.v)==0);
    }
    bool operator > (const str& a) const 
    {
        return (strcmp(v, a.v)>0);
    }
    bool operator < (const str& a) const
    {
        return (strcmp(v, a.v)<0);
    }
    char* v;
};


int main(int argc, char* argv[])
{
    int* array = new int [10];
    for(int i = 0; i < 10; i++)
        array[i] = rand();
    quicksort(array, 10);
    for(i = 0; i < 10; i++)
    {
        cout<<array[i]<<endl;
    }

    str s[] = {"bd", "e", "ba", "a"};
    quicksort(s, 4);
    for(i = 0; i < 4; i++)
    {
        cout<<s[i].v<<endl;
    }
    return 0;
}

2：不改变成员变量值的函数，例如empty()，要声明为const,这点很重要，不然当一个const mystack&类型的对象调用empty()的时候，会编不过。

3：拷贝构造函数最好要先判断是否是拷贝自身，不然有时候就出错。

4：拷贝构造函数也别忘了成员变量初始化列表。 

template<typename T>
class mystack
{
public:
    mystack();
    mystack(const mystack& src);
    ~mystack();
    bool push(const T& data);
    T pop();
    bool empty() const;
    void clear();
    mystack& operator = (const mystack& src);
private:
    void copystack(mystack& dst, const mystack& src);
    struct stacknode
    {
        T data;
        stacknode* pnext;
    };
    stacknode* phead;
};

template<typename T>
mystack<T>::mystack():phead(NULL)
{}

template<typename T>
mystack<T>::mystack(const mystack<T>& src):
phead(NULL)
{
    copystack(*this, src);
}

template<typename T>
mystack<T>::~mystack()
{
    clear();
}

template<typename T>
void mystack<T>::clear()
{
    while(!empty())
    {
        pop();
    }
}

template<typename T>
void mystack<T>::copystack(mystack& dst, const mystack& src)
{
    stacknode* p = src.phead;
    mystack<T> tmp;
    while(p)
    {
        tmp.push(p->data);
        p = p->pnext;
    }
    while(!tmp.empty())
    {
        dst.push(tmp.pop());
    }
}

template<typename T>
mystack<T>& mystack<T>::operator=(const mystack& src)
{
    if (this == &src)
        return *this;
    clear();
    copystack(*this, src);
    return *this;
}

template<typename T>
bool mystack<T>::empty() const 
{
    return(phead == NULL);
}

template<typename T>
bool mystack<T>::push(const T& data)
{
    stacknode* p = new stacknode;
    if (!p) return false;
    p->data = data;
    p->pnext = phead;
    phead = p;
    return true;
}

template<typename T>
T mystack<T>::pop()
{
    assert(!empty());
    T data;
    data = phead->data;
    stacknode* tmp = phead;
    phead = phead->pnext;
    delete tmp;
    return data;
}

int main(int argc, char* argv[])
{
    mystack<int> s;    
    for (int i = 0; i < 1000; i++)
        s.push(rand());
    mystack<int> s2(s);
    while(!s2.empty())
    {
        cout<<s2.pop()<<endl;
    }
    return 0;
}