程序截图：

下载地址：可执行文件，源代码

Google： 第一条就是。

Live Search:  找了半天没找到

首先我找了一个比较简单的Window API程序，试着把他转换成面向对象的形式。程序尽管简单，但刚上来一个棘手的问题就出现了。。消息机制的封装。

我们都知道，Windows中比如点击按钮，移动窗口等等的交互操作都是由消息机制来完成的。每做一个动作，例如点击一个按钮，Windows便会产生一个相应的消息，在这里就是BN_CLICKED，假设点击按钮后会弹出一个窗口，里面显示若干文字，而这些点击按钮后产生的效果就需要由我们程序员来编写。体现在Windows API中便是“消息处理函数”，如下：

LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     switch (message)
     {
     case BN_CLICKED:

          //相关代码
          return 0 ;

     case WM_DESTROY:
          PostQuitMessage (0) ;
          return 0 ;
     }
     return DefWindowProc (hwnd, message, wParam, lParam) ;
}

每次都要写这么多case的确是挺麻烦的，于是我想用面向对象的方法解决他。

class MessageMap
{
public:
     int count;  // 消息映射的数目
      Message* message[10];  // 可以存放10对消息映射
      template <typename T>
     void Add(MessageType 消息名称, T* 对应的处理函数);  // 增加一对消息映射
};

template <typename T>
class Message
{
public:
     MessageType 消息名称;
     T* 对应的处理函数;
     void Run()
     {
          对应的处理函数();
     }
};

enum MessageType{}

这样做其实是有问题的，请看这一段：

class MessageMap
{
public:
     
      Message* message[10];  // 由于Message是模板类，这里应该提供模板参数。这样就失去了模板的作用。
                                // 我们使用模板就是为了能让他存储不同的函数指针。
      
};

想一想，如何用一个统一的接口来调用不同的函数？对了，那就是多态。

我们可以增加一个抽象的接口类来提供调用接口，而具体实现的类则由他派生。

class MessageInterface
{
public:
    MessageType type;
    virtual ~MessageInterface() {}
    virtual void Run() = 0;
};

template <typename T>
class Message : public MessageInterface
{
public:
    T* classPtr;
    void (T::* funcPtr)();
    Message(MessageType _type, T* _classPtr, void (T::* _funcPtr)()) : classPtr(_classPtr), funcPtr(_funcPtr)
    {
        type = _type;
    }
    virtual void Run()
    {
        if (classPtr)
        {
            (classPtr->*funcPtr)();        // 注意调用函数指针时括号的用法
        }
    }    
};

class MessageMap
{
public:
    int count;
    MessageMap()
    {
        count = 0;
        Add(DESTROY, this, &MessageMap::OnDestroy); 
    }
    MessageInterface* message[10];
    void OnDestroy()
    {
        PostQuitMessage(0);
    }
    template <typename T>
    void Add(MessageType type, T* classPtr, void (T::* funcPtr)())
    {
        message[count++] = new Message<T>(type, classPtr, funcPtr);
    }
};

问题解决了！哈哈，测试成功！

具体的代码在这里，结构什么的还很不完善，仅仅是处理了消息机制而已，当作演示吧。

Add a property: FormatString, when the text box lost focus, the content will be replace with string.Format(FormatString, actualContent)，我在做第二个：“当textbox失去焦点时自动格式化文本”的地方遇到了问题。。。

简单起见，简化成“当textbox失去焦点时改变文本内容”。

一种方法是：

重写OnLeave()方法，如下：

另一种是给Leave事件增加一个订阅者：

经测试，均可运行。

现在，把两段代码和在一起，并注释掉第一种方法：

运行程序，测试，显示NewReceiver。

接下来再把base.OnLeave(e)注释掉：

运行，发现文本框失去焦点后不会改变内容，仍未空。由此，第二种方法失效了。为何？我们来看一下base.OnLeave()的内容：

原来，注释掉这段以后，handler(this, e)无法得到执行，也就没法激发事件，文本框内容当然也就没法改变了。

由此，我猜测，C#的事件触发过程大致是这样的：

文本框失去焦点 --> 触发Leave事件 --> 调用OnLeave()函数（这里是因为什么机制调用的？） --> 调用base.OnLeave() --> 再次触发Leave事件 --> 调用NewReceiver() --> 返回，执行this.text = "Override OnLeave"。

红色字，大家谁知道的，帮我解个惑吧～～

要这么想：有什么东西是天生就会的呢！

class String
{
public:
    String( const char *str = "" );
    ~String();
    String( const String &another )
    {
        const char *str = another.m_data;  // 可以正常访问
        /**//*省略*/
private:
    char *m_data;
};

c＋＋里，类的访问权限是class level，不是object level的。
访问权限只在编译时对编译器有效，在运行时，不存在访问权限这道栅栏。  

以下转自网上：

/**  
    *   请大家看看下面这段程序，它是能够正常编译连接运行的。但是为什么  
    *   assign成员函数没有错呢？谁能告诉我c++中关于这种情况的内幕？谢谢!  
    */  
   
  #include   <stdio.h>  
   
  class   Test    
  {  
  private:  
          int   a;  
  public:  
          Test(int);  
          void   assign(Test   const*   source);  
  };    
   
  void   Test::assign(Test   *source)  
  {  
          a   =   source->a;  
  }  
   
  int   main()  
  {  
          Test   t1(1),   t2(2);  
          t2.assign(&t1);  
  }  
   
  1:   关于ACCESS-CONTROL的定义  
   
      <<C++98   std/chapter   11>>:  
      1   A   member   of   a   class   can   be  
   
      --private;   that   is,   its   name   can   be   used     only     by      
          member     functions,   static     data     members,     and      
          friends     of     the     class     in   which   it   is   declared.  
   
      --protected;   that   is,   its   name   can   be   used   only   by  
          member     functions,   static     data     members,     and    
          friends     of     the     class     in   which   it   is   declared    
          and   by   member   functions,   static   data   members,      
          and     friends   of   classes   derived   from   this   class.  
   
      --public;     that     is,     its     name     can     be     used    
          anywhere   without   access   restriction.  
   
  2:   一些相关的note:  
        1)   name  
        ACCESS-CONTROL   只应用到name（simple   identifier).  
        按照上面的定义，ACCESS-CONTROL针对且只针对    
        member   of   class.        
        即使是涉及到模板，也只是关心name,    
        而不关心template-argument  
         
        2)   unnamed   object  
        无名对象不考虑access-control:  
        如下：  
        struct   A  
        {  
        private:  
              struct   B    
              {  
                  int   i;  
              };  
              B   m_b;  
        public:  
              B&   f()   {   return   m_b;   }            
        };  
        int   main()  
        {  
            A   a;  
            f()->i;   //   only   names   are   f,   i,    
                            //   f   and   i   is   public,    
                            //   so   it's   legal   even    
                            //   if   B   in   private   A   member  
        }        
        3)   关于protected   member   name有一个例外情况，  
              参见(4:)中例子的new   note  
   
  3:   让人迷惑的代码段的注记  
   
        void   Test::assign(Test   *source)  
        {  
          a   =   source->a;  
          /**  
            1)   这里出现的name是  
                  void,   Test,   assign,   source,   a  
            2)   void,   Test,   source,    
                不是class   member,    
                不做access-control考虑  
            3)   assign是成员函数名,    
                  但我们只是定义它，  
                  不在这里使用，  
                  也不做access-control考虑  
   
            4）a是private   Test   member,    
                  可以在A的成员函数中使用，  
                  现在刚好是在Test的  
                  assign成员函数体内。  
                   
            5)   but   what   about   "source->a":  
                  OK,   a   in   "source->a"   means    
                  a   is   a   member   name   of   source's   class   Test  
                  and   used   in   Test   member   function,    
                  everything   is   fine!!!  
                  (still   confusing,   see   following   example   ...)  
            */  
        }  
   
  4:   更加清楚的例子(我的）注记  
       
        struct   Base  
        {  
        protected:  
            int   m_protected;  
        };  
   
        struct   Son2   :   Base   {};  
   
        struct   Son1   :   Base  
        {  
   
            void   foo(Son1&   s)  
            {  
                s.m_protected;           /**  
                                                  new   note:  
                                                  same   as   3/5)  
                                                  */  
            }  
   
            void   foo(Base&   b)  
            {  
                b.m_protected;    /**  
                                          new   note:  
                                          m_protected   in   "b.m_protected"   means:  
                                              m_protected   is   Base(b's   type)   class    
                                              member,   not   Son1   class   member  
                                          which   means:  
                                              Base's   protected   member   is   used  
                                              in   Son1's   member   function    
                                          By   definition,   it's   legal,   but  
                                          因为C++标准规定一个关于  
                                          proected   member的例外情况，  
                                              When   a   member   function   of   a      
                                              derived     class   references      
                                              a     protected   nonstatic   member  
                                              of   a   base   class,   an   access   check    
                                              applies   in   addition     to     those    
                                              described   earlier   in   this   clause：  
                                                Except   when   forming   a   pointer   to  
                                                member,the   access   must   be   through    
                                                          a   pointer   to,  
                                                          reference   to,      
                                                          <---我们的情况  
                                                          or   object              
                                                          <---下一个成员函数的情况  
                                                      of   the   derived   class   itself    
                                              (or   any   class   derived   from   that   class).  
                                          因为儿子不能管老子，所以结论是  
                                          illegal    
                                          */  
   
            }  
            void   foo(Base   b)  
            {  
                b.m_protected;  /**  
                                        new   note:  
                                        illegal   :   儿子不能管老子  
                                        原因同   void   foo(Base&   c)的分析。  
                                        */  
            }    
      };  

 

/**/////////////////////////////////////////////////////////////
// filename: seqlist.h 类模板的申明
/**/////////////////////////////////////////////////////////////
#ifndef SEQLIST
#define SEQLIST

template<calss T>
class SeqList
{
 
}

/**/////////////////////////////////////////////////////////////
// filename: seqlist.cpp 类模板的定义
/**/////////////////////////////////////////////////////////////
#include"seqlist.h"

template<class T>
SeqList<T>::SeqList()
{
 
}

/**/////////////////////////////////////////////////////////////
// filename: main.cpp 主函数
/**/////////////////////////////////////////////////////////////
#include"seqlist.h"
#include<iostream>
int main()
{
 
}

 

如以上写法，连接时会出错，这个问题属于类模板的分离编译，有三种解决办法：
1. 将类模板申明与类模板定义放到一个文件中。
2. 在主函数中加 #include"seqlist.cpp"。
3. 使用export关键字。

c++primer中讲到"c++的模板编译模式"有两种——"包含编译和分离编译"。详见c++primer 16.8

第一个陷阱：
typedef char * pstr;
int mystrcmp(pstr, pstr);　　
int mystrcmp(const pstr, const pstr); 　　
这是错误的，按照顺序，‘const pstr’被解释为‘char * const’（一个指向 char 的常量指针），而不是‘const char *’（指向常量 char 的指针）。这个问题很容易解决：

typedef const char * cpstr;
int mystrcmp(cpstr, cpstr); // 现在是正确的

第二个陷阱：
typedef register int FAST_COUNTER; // 错误　　
编译通不过。问题出在你不能在声明中有多个存储类关键字。因为符号 typedef 已经占据了存储类关键字的位置，在 typedef 声明中不能用 register（或任何其它存储类关键字）。
 
和#define区别：
#define：编译与处理时
typedef：编译时