在 B-tree 中搜索键值，结点内可以使用二分查找，若要查找指定范围内数据与查找键值
相比相对要复杂一点。

现给出查找指定范围内第一项和最后一项数据的示例代码：

   无锁环形队列的设计及示例，读写队列最大的应用是：一个线程收到事件或消息后直接
加入到队列，而处理线程读取队列中的事件或消息，并加以处理。在这个模式中，有一个线
程负责写，多个处理线程读自己的队列并处理。虽然看起来象是一写多读，其实不然，针对
某一事件队列而言，只有一个线程是写一个线程是读。

   环形一读一写队列中，不需要担心unsigned long溢出问题，因为溢出后自动回归，相减
值还会保留。

  1 示例一(注：Max_Count 必须为 2 的指数，即：2, 4, 8, 16)：
  2 
  3 // 队列尺寸
  4 #define Max_Count    4096
  5 #define Max_Mask     4095     // = Max_Count - 1
  6 
  7 // 变量
  8 void*          List[Max_Count];
  9 unsigned long  Push_Count;
 10 unsigned long  Pop_Count;
 11 
 12 // 初始化队列
 13 void InitQueue()
 14 {
 15    Push_Count  = 0;
 16    Pop_Count   = 0;
 17    memset(List, 0, sizeof(List));
 18 }
 19 
 20 // 加入
 21 bool Push(void* AData)
 22 {
 23    if (Push_Count - Pop_Count < Max_Count)
 24    {
 25       List[Push_Count & Max_Mask] = AData;
 26       Push_Count++;
 27       return true;
 28    }
 29    else
 30       return false;
 31 }
 32 
 33 // 取出
 34 void* Pop()
 35 {
 36    // 初始化
 37    void* result = NULL;
 38 
 39    // 判断是否为空
 40    if (Push_Count != Pop_Count)
 41    {
 42       result = List[Pop_Count & Max_Mask];
 43       Pop_Count++;
 44    }
 45 
 46    // 返回结果
 47    return result;
 48 }
 49 
 50 示例二(注：Max_Count >= 2)：
 51 
 52 // 队列尺寸
 53 #define Max_Count    4096
 54 #define High_Index   4095     // = Max_Count - 1
 55 
 56 // 变量
 57 void*          List[Max_Count];
 58 unsigned long  Push_Count;
 59 unsigned long  Push_Index;
 60 unsigned long  Pop_Count;
 61 unsigned long  Pop_Index;
 62 
 63 // 初始化队列
 64 void InitQueue()
 65 {
 66    Push_Count  = 0;
 67    Push_Index  = 0;
 68    Pop_Count   = 0;
 69    Pop_Index   = 0;
 70    memset(List, 0, sizeof(List));
 71 }
 72 
 73 // 加入
 74 bool Push(void* AData)
 75 {
 76    if (Push_Count - Pop_Count < Max_Count)
 77    {
 78       List[Push_Index] = AData;
 79       Push_Count++;
 80       if (Push_Index == High_Index)
 81          Push_Index = 0;
 82       else
 83          Push_Index++;
 84 
 85       return true;
 86    }
 87    else
 88       return false;
 89 }
 90 
 91 // 取出
 92 void* Pop()
 93 {
 94    // 初始化
 95    void* result = NULL;
 96 
 97    // 判断是否为空
 98    if (Push_Count != Pop_Count)
 99    {
100       result = List[Pop_Index];
101       Pop_Count++;
102       if (Pop_Index == High_Index)
103          Pop_Index = 0;
104       else
105          Pop_Index++;
106    }
107 
108    // 返回结果
109    return result;
110 }
111 

   一读一写情况下，无锁队列如何实现？其实并不难，先说说一读一写无锁队列的实际应
用吧。读写队列最大的应用是：一个线程收到事件或消息后直接加入到队列，而处理线程读
取队列中的事件或消息，并加以处理。在这个模式中，有一个线程负责写，多个处理线程读
自己的队列并处理。虽然看起来象是一写多读，其实不然，针对某一事件队列而言，只有一
个线程是写一个线程是读。

   此示例可以封装成一个Queue类，在KYLib中有TKYQueue类，其实现原理相同。代码示例
如下：

   一个线程收到事件或消息后直接加入到队列，而处理线程读取队列中的事件或消息，并
加以处理。在这个模式中，有一个线程负责写，多个处理线程读自己的队列并处理。虽然看
起来象是一写多读，其实不然，针对某一事件队列而言，只有一个线程是写一个线程是读。

队列和事件的配合使用示例如下：

  1 /* 方法一: 独立线程处理队列 */
  2 
  3 // 线程执行体
  4 void TDealThread::Execute()
  5 {
  6    // 初始化
  7    Longword dwNo;
  8    Longword dwCount;
  9    TItem*   pItem;
 10 
 11    // 线程循环体
 12    while (!Terminated())
 13    {
 14       // 等待事件
 15       FEvent->Wait(INFINITE);
 16 
 17       // 循环处理事件项
 18       dwCount = FQueue->Count();
 19       for (dwNo = 0; !Terminated() && (dwNo < dwCount); dwNo++)
 20       {
 21          pItem = (TItem*)FQueue->Pop();
 22          if (pItem != NULL)
 23          {
 24             // 处理事件项
 25             // ???  
 26 
 27             // 释放项
 28             delete pItem;
 29          }
 30       }
 31    }
 32 }
 33 
 34 // 添加事件
 35 bool TDealThread::AddEvent(const TItem& AItem)
 36 {
 37    // 初始化
 38    bool result = false;
 39 
 40    // 判断线程是否未终止
 41    if (!Terminated())
 42    {
 43       // 初始化
 44       TItem* pItem;
 45 
 46       // 新建项
 47       pItem  = new TItem;
 48       *pItem = AItem;
 49 
 50       // 加入队列
 51       if (FQueue->Push(pItem))
 52       {
 53          // 事件置位
 54          FEvent->Set();
 55          result = true;
 56       }
 57       else
 58          delete pItem;
 59    }
 60 
 61    // 返回结果
 62    return result;
 63 }
 64 
 65 // 关闭线程
 66 void TDealThread::Close()
 67 {
 68    // 置终止标志
 69    Terminate();
 70    FEvent->Set();
 71 
 72    // 唤醒休眠线程
 73    if (!Finished() && Suspended())
 74       Resume();
 75 }
 76 
 77 /* 方法二: 外部线程处理 */
 78 
 79 // 外部线程取事件
 80 bool TOwnerObj::GetEvent(TItem& AItem, Longword ATimeout)
 81 {
 82    // 先取队列项
 83    bool result = GetItem(AItem);
 84 
 85    // 判断是否需要等待
 86    if (!result && (ATimeout != 0))
 87    {
 88       // 初始化
 89       Longword dwBegin = GetTickCount();
 90 
 91       // 循环等待事件
 92       while (GetTickCount() - dwBegin < ATimeout)
 93       {
 94          // 防止其它多线程读取时信号取不到, 50 毫秒等待
 95          FEvent->Wait(50);
 96 
 97          // 取队列项
 98          if (GetItem(AItem))
 99          {
100             result = true;
101             break;
102          }
103       }
104    }
105 
106    // 返回结果
107    return result;
108 }
109 
110 // 添加事件
111 bool TOwnerObj::AddEvent(const TItem& AItem)
112 {
113    // 初始化
114    bool   result = false;
115    TItem* pItem;
116 
117    // 新建项
118    pItem  = new TItem;
119    *pItem = AItem;
120 
121    // 加入队列
122    if (FQueue->Push(pItem))
123    {
124       // 事件置位
125       FEvent->Set();
126       result = true;
127    }
128    else
129       delete pItem;
130 
131    // 返回结果
132    return result;
133 }
134 
135 // 取队列项
136 bool TOwnerObj::GetItem(TItem& AItem)
137 {
138    // 初始化
139    TItem* pItem;
140    bool   result = false;
141 
142    // 判断队列是否非空
143    while (FQueue->Count() != 0)
144    {
145       pItem = (TItem*)FQueue->Pop();
146       if (pItem != NULL)
147       {
148          AItem  = *pItem;
149          result = true;
150 
151          // 释放项
152          delete pItem;
153          break;
154       }
155    }
156 
157    // 返回结果
158    return result;
159 }
160 

   其实，类方法调用原理很简单，若知道如何使用C语言模拟类实现就知道怎么回事了，只
是这个工作由编译器来做罢了。调用方法与调用函数的区别是在调用方法时，编译器把当前
对象的指针当做第一个参数传入，其它参数的传递与函数没有区别，也就说，这为提供回调
事件的方法指针提供一条方便之门。方法指针不能滥用，用好它可以使你的视野更加开阔！

  1 /* TObject - 基类 */
  2 
  3 class TObject
  4 {
  5 };
  6 
  7 
  8 /* TDemoA - A 类 */
  9 
 10 class TDemoA
 11 {
 12 public:
 13    TDemoA();
 14    virtual ~TDemoA();
 15 
 16    void  AF1(void* AParam);
 17    void  AF2(const char* AStr, long AValue);
 18 
 19    // ???  
 20 };
 21 
 22 /* TDemoB - B 类 */
 23 
 24 class TDemoB
 25 {
 26 public:
 27    TDemoB();
 28    virtual ~TDemoB();
 29 
 30    void  BF1(void* AParam);
 31    void  BF2(const char* AStr, long AValue);
 32 
 33    // ???  
 34 };
 35 
 36 /* TDemoC - C 类 */
 37 
 38 class TDemoC
 39 {
 40 public:
 41    // TOnFunc1 事件类型
 42    typedef void (TObject::*TDoFunc1)(void* AParam);
 43    typedef struct
 44    {
 45       TDoFunc1          Method;
 46       void*             Object;
 47    } TOnFunc1;
 48 
 49    // TOnFunc2 事件类型
 50    typedef void (TObject::*TDoFunc2)(const char* AStr, long AValue);
 51    typedef struct
 52    {
 53       TDoFunc2          Method;
 54       void*             Object;
 55    } TOnFunc2;
 56 
 57 public:
 58    TDemoC();
 59    virtual ~TDemoC();
 60 
 61    // Func1
 62    void  Func1(void* AParam)
 63    {
 64       if (OnFunc1.Method != NULL)
 65          ((TObject*)OnFunc1.Object->*OnFunc1.Method)(AParam);
 66    }
 67 
 68    // Func2
 69    void  Func2(const char* AStr, long AValue)
 70    {
 71       if (OnFunc2.Method != NULL)
 72          ((TObject*)OnFunc2.Object->*OnFunc2.Method)(AStr, AValue);
 73    }
 74 
 75    // 事件
 76    TOnFunc1    OnFunc1;
 77    TOnFunc1    OnFunc2;
 78 };
 79 
 80 
 81 // 例子
 82 TDemoA A;
 83 TDemoB B;
 84 TDemoC C;
 85 
 86 int demo()
 87 {
 88    // ???  
 89 
 90    C.OnFunc1.Object  = &B;
 91    C.OnFunc1.Method  = (TDemoC::TDoFunc1)&TDemoB::BF1;
 92 
 93    C.OnFunc2.Object  = &A;
 94    C.OnFunc2.Method  = (TDemoC::TDoFunc2)&TDemoA::AF2;
 95 
 96    // 调用 C 方法
 97    C.Func1();     // <=> B.BF1();
 98    C.Func2();     // <=> A.AF2();
 99 
100    // ???  
101 
102    C.OnFunc1.Object  = &A;
103    C.OnFunc1.Method  = (TDemoC::TDoFunc1)&TDemoA::AF1;
104 
105    C.OnFunc2.Object  = &B;
106    C.OnFunc2.Method  = (TDemoC::TDoFunc2)&TDemoB::BF2;
107 
108    // 调用 C 方法
109    C.Func1();     // <=> A.AF1();
110    C.Func2();     // <=> B.BF2();
111 
112    // ???  
113 
114 }
115 
116 /* TKYFmtMemEvent - 格式化内存项事件类 */
117 
118 class TKYFmtMemEvent
119 {
120 public:
121    // TOnFormat 事件类型
122    typedef void (TObject::*TDoFormat)(void* AItem, Word ASize);
123    typedef struct
124    {
125       TDoFormat         Method;
126       void*             Object;
127    } TOnFormat;
128 
129 public:
130    TKYFmtMemEvent()  { Clear(); }
131    ~TKYFmtMemEvent() { Clear(); }
132 
133    // 清除
134    void  Clear();
135 
136    // 执行 OnInitialize 事件
137    void  DoInitialize(void* AItem, Word ASize)
138    {
139       if (OnInitialize.Method != NULL)
140          ((TObject*)OnInitialize.Object->*OnInitialize.Method)(AItem, ASize);
141    }
142 
143    // 执行 OnFinalize 事件
144    void  DoFinalize(void* AItem, Word ASize)
145    {
146       if (OnFinalize.Method != NULL)
147          ((TObject*)OnFinalize.Object->*OnFinalize.Method)(AItem, ASize);
148    }
149 
150    // 事件
151    TOnFormat   OnInitialize;
152    TOnFormat   OnFinalize;
153 
154 protected:
155 private:
156 };
157 
158 // 例子：如何设置事件方法指针
159 void TDemo::SetEvent()
160 {
161    FDemo.OnInitialize.Object = this;
162    FDemo.OnInitialize.Method = (TKYFmtMemEvent::TDoFormat)&TDemo::DoFormat;
163 
164    // ???  
165 }
166 
167 // FDemo 的 OnInitialize 事件方法
168 void TDemo::DoFormat(void* AItem, Word ASize)
169 {
170    // ???  
171 }
172 

    回调事件的方法指针需要C++编译器支持，至少VC的不同版本及GCC编译器都支持。
在VC6和VC2003中设置方法指针相对较宽松，VC2005之后就很严格了，如下：
FDemo.OnInitialize.Method = (TKYFmtMemEvent::TDoFormat)&TDemo::DoFormat;

   这行代码都被不同版本VC编译器支持，但如下代码就只能被VC6、VC2003支持：
FDemo.OnInitialize.Method = (TKYFmtMemEvent::TDoFormat)DoFormat;

   其实，类方法调用原理很简单，若知道如何使用C语言模拟类实现就知道怎么回事了，只
是这个工作由编译器来做罢了。不过不是什么方法都可以调用的，如：静态方法就只能当做
函数指针来用，而重载方法、虚方法等等是不可靠的，所以最好使用普通的类方法指针。

   调用方法与调用函数的区别是在调用方法时，编译器把当前对象的指针当做第一个参数传
入，其它参数的传递与函数没有区别，也就说，这为提供回调事件的方法指针提供一条方便之门。

   方法指针不能滥用，用好它可以使你的视野更加开阔！