井泉

Posted on 2006-06-24 16:55 Gin 阅读(125) 评论(0)  编辑 收藏
摘自网上的，呵，这几个是自己比较少用到的

F2　　　　　　　　　　　    当你选中一个文件的话，这意味着“重命名”
ALT+ ENTER或 ALT+双击      查看项目的属性
F10或ALT                                   激活当前程序的菜单栏
CTRL+ ESC                                显示“开始”菜单
ALT+空格键                               显示当前窗口的系统菜单
CTRL+F5　　　　　　　　      强行刷新
ALT+RIGHT ARROW　　　　 显示前一页（前进键）
ALT+LEFT ARROW　　　　　显示后一页（后退键）
ALT+ESC　　　　　　　　 切换当前程序
CTRL+N　　　　　　　　　新建一个新的文件
CTRL+O　　　　　　　　　打开“打开文件”对话框
CTRL+P　　　　　　　　　打开“打印”对话框

SHIFT+F10                            显示某个链接的快捷菜单
CTRL+W                               关闭当前窗口
ALT+D                                  选择地址栏中的文字
CTRL+ENTER                     在地址栏中将"www."添加到键入的文本的前面，将".com"添加到文本的后面
CTRL+D                                将当前Web 页添加到收藏夹中
CTRL+B                               打开"整理收藏夹"对话框
CTRL+I                               在浏览栏中打开收藏夹
ALT+ENTER
将 Windows 下运行的命令行窗口在窗口和全屏幕状态间切换；查看选定的文件的属性；选定任务栏时打开"任务栏和开始菜单"属性
Alt+空格→X                       最大化当前窗口
Alt+空格→N                       最小化当前窗口

条款28: 划分全局名字空间

全局空间最大的问题在于它本身仅有一个。在大的软件项目中，经常会有不少人把他们定义的名字都放在这个单一的空间中，从而不可避免地导致名字冲突。例如，假设library1.h定义了一些常量，其中包括：

const double lib_version = 1.204;

类似的，library2.h也定义了：

const int lib_version = 3;

很显然，如果某个程序想同时包含library1.h和library2.h就会有问题。对于这类问题，你除了嘴里骂几句，或给作者发报复性邮件，或自己编辑头文件来消除名字冲突外，也没其它什么办法。

但是，作为程序员，你可以尽力使自己写的程序库不给别人带来这些问题。例如，可以预先想一些不大可能造成冲突的某种前缀，加在每个全局符号前。当然得承认，这样组合起来的标识符看起来不是那么令人舒服。

另一个比较好的方法是使用c++ namespace。namespace本质上和使用前缀的方法一样，只不过避免了别人总是看到前缀而已。所以，不要这么做：

const double sdmbook_version = 2.0;      // 在这个程序库中,
                                         // 每个符号以"sdm"开头
class sdmhandle { ... };                

sdmhandle& sdmgethandle();             // 为什么函数要这样声明？
                                       // 参见条款47

而要这么做：

namespace sdm {
  const double book_version = 2.0;
  class handle { ... };
  handle& gethandle();
}

用户于是可以通过三种方法来访问这一名字空间里的符号：将名字空间中的所有符号全部引入到某一用户空间；将部分符号引入到某一用户空间；或通过修饰符显式地一次性使用某个符号：

void f1()
{
  using namespace sdm;           // 使得sdm中的所有符号不用加
                                 // 修饰符就可以使用

  cout << book_version;          // 解释为sdm::book_version
  ...

  handle h = gethandle();        // handle解释为sdm::handle,
                                 // gethandle解释为sdm::gethandle
  ...                           

}

void f2()
{
  using sdm::book_version;        // 使得仅book_version不用加
                                 // 修饰符就可以使用

  cout << book_version;           // 解释为
                                  // sdm::book_version
  ...

  handle h = gethandle();         // 错误! handle和gethandle
                                  // 都没有引入到本空间
  ...                            

}

void f3()
{
  cout << sdm::book_version;      // 使得book_version
                                  // 在本语句有效
  ...                            

  double d = book_version;        // 错误! book_version
                                  // 不在本空间

  handle h = gethandle();         // 错误! handle和gethandle
                                  // 都没有引入到本空间
  ...                           

}

（有些名字空间没有名字。这种没命名的名字空间一般用于限制名字空间内部元素的可见性。详见条款m31。）

名字空间带来的最大的好处之一在于：潜在的二义不会造成错误（参见条款26）。所以，从多个不同的名字空间引入同一个符号名不会造成冲突（假如确实真的从不使用这个符号的话）。例如，除了名字空间sdm外，假如还要用到下面这个名字空间：

namespace acmewindowsystem {

  ...

  typedef int handle;

  ...

}

只要不引用符号handle，使用sdm和acmewindowsystem时就不会有冲突。假如真的要引用，可以明确地指明是哪个名字空间的handle：

void f()
{
  using namespace sdm;                 // 引入sdm里的所有符号
  using namespace acmewindowsystem;    // 引入acme里的所有符号

  ...                                  // 自由地引用sdm
                                       // 和acme里除handle之外
                                       // 的其它符号

  handle h;                            // 错误! 哪个handle?

  sdm::handle h1;                      // 正确, 没有二义

  acmewindowsystem::handle h2;         // 也没有二义

  ...

}

假如用常规的基于头文件的方法来做，只是简单地包含sdm.h和acme.h，这样的话，由于handle有多个定义，编译将不能通过。

名字空间的概念加入到c++标准的时间相对较晚，所以有些人会认为它不太重要，可有可无。但这种想法是错误的，因为c++标准库（参见条款49）里几乎所有的东西都存在于名字空间std之中。这可能令你不以为然，但它却以一种直接的方式影响到你：这就是为什么c++提供了那些看起来很有趣的、没有扩展名的头文件，如<iostream>, <string>等。详细介绍参见条款49。

由于名字空间的概念引入的时间相对较晚，有些编译器可能不支持。就算是这样，那也没理由污染全局名字空间，因为可以用struct来近似实现namespace。可以这样做：先创建一个结构用以保存全局符号名，然后将这些全局符号名作为静态成员放入结构中：

// 用于模拟名字空间的一个结构的定义
struct sdm {
  static const double book_version;
  class handle { ... };
  static handle& gethandle();
};

const double sdm::book_version = 2.0;      // 静态成员的定义

现在，如果有人想访问这些全局符号名，只用简单地在它们前面加上结构名作为前缀：

void f()
{
  cout << sdm::book_version;

  ...

  sdm::handle h = sdm::gethandle();

  ...
}

但是，如果全局范围内实际上没有名字冲突，用户就会觉得加修饰符麻烦而多余。幸运的是，还是有办法来让用户选择使用它们或忽略它们。

对于类型名，可以用类型定义（typedef）来显式地去掉空间引用。例如，假设结构s（模拟的名字空间）内有个类型名t，可以这样用typedef来使得t成为s::t的同义词：

typedef sdm::handle handle;

对于结构中的每个（静态）对象x，可以提供一个（全局）引用x，并初始化为s::x：

const double& book_version = sdm::book_version;

老实说，如果读了条款47，你就会不喜欢定义一个象book_version这样的非局部静态对象。（你就会用条款47中所介绍的函数来取代这样的对象）

处理函数的方法和处理对象一样，但要注意，即使定义函数的引用是合法的，但代码的维护者会更喜欢你使用函数指针：

sdm::handle& (* const gethandle)() =      // gethandle是指向sdm::gethandle
  sdm::gethandle;                         // 的const 指针 (见条款21)

注意gethandle是一个常指针。因为你当然不想让你的用户将它指向别的什么东西，而不是sdm::gethandle，对不对？

（如果真想知道怎么定义一个函数的引用，看看下面：

sdm::handle& (&gethandle)() =      // gethandle是指向
  sdm::gethandle;                  // sdm::gethandle的引用

我个人认为这样的做法也很好，但你可能以前从没见到过。除了初始化的方式外，函数的引用和函数的常指针在行为上完全相同，只是函数指针更易于理解。）

有了上面的类型定义和引用，那些不会遭遇全局名字冲突的用户就会使用没有修饰符的类型和对象名；相反，那些有全局名字冲突的用户就会忽略类型和引用的定义，代之以带修饰符的符号名。还要注意的是，不是所有用户都想使用这种简写名，所以要把类型定义和引用放在一个单独的头文件中，不要把它和（模拟namespace的）结构的定义混在一起。

struct是namespace的很好的近似，但实际上还是相差很远。它在很多方面很欠缺，其中很明显的一点是对运算符的处理。如果运算符被定义为结构的静态成员，它就只能通过函数调用来使用，而不能象常规的运算符所设计的那样，可以通过自然的中缀语法来使用：

// 定义一个模拟名字空间的结构，结构内部包含widgets的类型
// 和函数。widgets对象支持operator+进行加法运算
struct widgets {
  class widget { ... };

  // 参见条款21：为什么返回const
  static const widget operator+(const widget& lhs,
                                const widget& rhs);

  ...

};

// 为上面所述的widge和operator+
// 建立全局（无修饰符的）名称

typedef widgets::widget widget;

const widget (* const operator+)(const widget&,        // 错误!
                                 const widget&);       // operator+不能是指针名
 

widget w1, w2, sum;

sum = w1 + w2;                           // 错误! 本空间没有声明
                                         // 参数为widgets 的operator+

sum = widgets::operator+(w1, w2);        // 合法, 但不是
                                         // "自然"的语法

正因为这些限制，所以一旦编译器支持，就要尽早使用真正的名字空间。

#ifndef MSG_H
#define MSG_H
//msgid
#define LISTEN_THREAD  7
#define CENTER_THREAD  0
#define SEND_THREAD   2
#define REV_THREAD   3
#define TIME_THREAD   4
//lp
#define EXIT    0
#define SEND_SGIP_SUBMIT 1
#define SEND_SGIP_BIND
#define SEND_SGIP_R
#define SEND_SGIP_UNBIND
#define SEND_SGIP_UNBIND_R
#define REV_SGIP_SOCKET
//wp
#define SEND_SUCCESS
#define PACK_FAIL
#define SEND_FAIL
enum mgnt_cmd_type
{
 event_login         = 0,
  event_logout,
  event_sip_init_para,
  event_log_init_para,
  event_sip_clean,
  event_set_dtmf_mode,
  event_set_dhcp,
  event_set_pppoe,
  
  event_pstn_call_out,
  event_sip_call_out,
  event_answer_sipcall,
  event_release_sipcall,
  event_loadBMP_init,
  
  
  event_pstn_call_in=20,
  event_sip_call_in,
  event_remote_release_call,
  event_remote_establish_call,
  event_remote_cancelcall,
  event_login_return,
  event_remote_ignore,

  event_set_pstn_ring,
  event_set_sip_ring,
  event_set_alarm_ring,
  event_set_ring_volume
  
};

typedef struct msgbuf
{
 long   msgtype;
 unsigned long msgid;
 unsigned long lp;
 unsigned long wp;
}MSGBuf, *pMSGBuf;

int vvMSGSend(long thread_id, unsigned long msgid, unsigned long lp, unsigned long wp);
int vvMSGRecv(long thread_id, struct msgbuf *msg, int is_wait);

#ifndef _WINDOWS

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <unistd.h>

#define MSG_FILE_NAME    "/rw/"      //"/mnt/"
#define MSG_FLAG   (IPC_CREAT  | 00666)
//| IPC_EXCL
 

typedef struct sendMsg
{
 int sd;
 void *content;
}SendMsg, *pSendMsg;

#endif

#endif //MSG_H





#include "vvmsg.h"
#include <ps_log.h>

#ifndef _WINDOWS
#include <phone_Interface.h>
#include <pthread.h>
#include <basegdi.h>
#include <keyboard.h>
//#include "hash.h"
extern  pthread_t g_incomingthread;
//extern  hash_table table;
#endif

int vvMSGSend(long thread_id, unsigned long msgid, unsigned long lp, unsigned long wp)
{ 
 struct msgbuf bmsg;
#ifndef _WINDOWS
 key_t key;

 int msg_id;
 bmsg.msgtype = thread_id;
 bmsg.msgid = msgid;
 bmsg.lp = lp;
 bmsg.wp = wp;

 if((key = ftok(MSG_FILE_NAME,'a')) == -1)
 {
  return -1;
 }

 if((msg_id = msgget(key,MSG_FLAG)) == -1)
 {
  return -1;
 }

 if (msgsnd(msg_id, &bmsg, sizeof(struct msgbuf), IPC_NOWAIT) == -1)
 {
  return -1;
 }
#endif
 return 1;

}

int vvMSGRecv(long thread_id, struct msgbuf *msg, int is_wait)
{
 #ifndef _WINDOWS
 key_t key;  
 int msg_id;
 if((key = ftok(MSG_FILE_NAME,'a')) == -1)
 {
  printf("Recv msg error 1!\n");
  return -1;
 }
 if((msg_id = msgget(key,MSG_FLAG)) == -1)
 {
  printf("Recv msg error 2!\n");
  return -1;
 }
 if (is_wait != 1)
 {
  if (msgrcv(msg_id, msg, sizeof(struct msgbuf), thread_id, IPC_NOWAIT) == -1)
  {
   printf("Recv msg error 3!\n");
   return -1;
  } 
 }
 else
 {
  if (msgrcv(msg_id, msg, sizeof(struct msgbuf), thread_id, 0) == -1)
  {
   //printf("Recv msg error 4!\n");
   return -1;
  }
 }
  #endif
 return 1;

}

void *skype_thread_start(void *arg)
{
 #ifndef _WINDOWS
 MSGBuf msg;
 pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,0);//设置线程属性
 pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,0);
 for (;;)
 {
  pthread_testcancel();//设置取消点
  if (vvMSGRecv((long)g_incomingthread, &msg, 1) == -1)
   continue;
  
  // analysis the message
  switch (msg.msgid)
  {
   ps_show_str(log_DEBUG, "vvmsg event!!!!!!!!!!!!!!!%d\r\n", msg.msgid);
  case event_login:
   {
    userLogin();
    
   }
   break;
  case event_logout:
   {
    userLogout();
   }
  case event_sip_clean:
   {
    SipClean();
   }
   break;
  case event_sip_init_para:
   {
    ps_show_str(log_DEBUG, "event before################UpdateSipInitPara\r\n");
    UpdateSipInitPara();
    ps_show_str(log_DEBUG, "event after##################UpdateSipInitPara\r\n");
   }
   break;
  case event_log_init_para:
   {
    UpdateLogInitPara();
   }
   break;
  case event_set_dtmf_mode:
   {
    int i = (int)msg.lp;
    ps_show_str(log_DEBUG, "event_set_dtmf_mode########################%d\r\n", i);
    SetDTMFMode(i);
   }
   break;
  case event_set_dhcp:
   {
    SetDHCP();
   }
   break;
  case event_set_pppoe:
   {
    SetPPPOE();
   }
   break;

  case event_pstn_call_out:
   {
    pstncall((char*)msg.lp);
   }
   break;
  case event_sip_call_out:
   {
    
    sipcall((char*)msg.lp);
   }
   break;

  case event_answer_sipcall:
   {
    callmgr_answercall((LINE_ID_T *)msg.lp);
   }
   break;
        case event_release_sipcall:
   {
    callmgr_releasecall((LINE_ID_T *)msg.lp);
   }
   break;
  case event_loadBMP_init:
   {
    CreateSysBmp();
    
   }
   break;
   

  case event_pstn_call_in:
   {
    LINE_ID_T *line = (LINE_ID_T *)msg.wp;
    sipcome_create(line);
   }
   break;
  case event_sip_call_in:
   {
    LINE_ID_T *line = (LINE_ID_T *)msg.wp;
    sipcome_create(line);
   }
   break;
 
  case event_remote_establish_call:
   {
    
    LINE_ID_T *line = (LINE_ID_T *)msg.wp;
    pstnchat_create(line);
    if(g_Hwnd[HWND_CALLOUT]!=0)
    calling_destroy(g_Hwnd[HWND_CALLOUT]);
    
   }
   break;
  case event_remote_cancelcall:
   {
    if(g_Hwnd[HWND_CALLIN]!=0)
   SendMessage(g_Hwnd[HWND_CALLIN],MSG_KEYDOWN,KEY_SW_RSK,0);
   }
   break;
  case event_remote_release_call:
   {
    if(g_Hwnd[HWND_CHAT]!=0)
    SendMessage(g_Hwnd[HWND_CHAT],MSG_KEYDOWN,KEY_SW_RSK,0);
   }
   break;
  case event_login_return:
   {
    printf("sfds0000000000000000000000000000000dssssssss^^^^^^^^^^^^^^^^^\r\n");
    if(g_Hwnd[HWND_MAINSCREEN]!=0)
    {
     UpdateWindow(g_Hwnd[HWND_MAINSCREEN],1);
    // SetFocusChild(g_Hwnd[HWND_MAINSCREEN]);
    // ShowWindow(g_Hwnd[HWND_MAINSCREEN], SW_SHOW);
    }
   }
   break;
  case event_remote_ignore:
   {
    if(g_Hwnd[HWND_CALLOUT]!=0)
    SendMessage(g_Hwnd[HWND_CALLOUT],MSG_KEYDOWN,KEY_SW_RSK,0); 
   }
   break;
  case event_set_pstn_ring:
   {
    SetPstnRing((int)msg.lp);
   }
   break;
  case event_set_sip_ring:
   {
    SetSipRing((int)msg.lp);
   }
   break;
  case event_set_ring_volume:
   {
    SetRingVolume((int)msg.lp);
   }
   break;
  }

 }
 #endif
}

附（创建线程）：if (pthread_create(&g_incomingthread, NULL, skype_thread_start, NULL))
  return -1;

struct Struct_Object_A
　　{
　　　　int a;
　　　　int b;
　　　　Struct_Object_A *next;
　　
　　} OBJECT_A;
　　
　　typedef struct Struct_Object_B
　　{
　　　　int a;
　　　　int b;
　　　　int c;
　　　　Struct_Object_B *next;
　　
　　} OBJECT_B;　

上面定义的两个结构只有很小的一点差别。OBJECT_B 和 OBJECT_A 之间只差一个整型变量。但是，在编译器看来，它们仍然是非常不同的。必须为存储在链表中的每个对象复制用来添加、删除和搜索链表的函数。为了解决这个问题，可以使用具有全部三个变量的一个联合或结构，其中整数 c 并不是在所有的情况下都要使用。这可能变得非常复杂，并会形成不良的编程风格。

C 代码解决方案：虚拟链表

此问题更好的解决方案之一是虚拟链表。虚拟链表是只包含链表指针的链表。对象存储在链表结构背后。这一点是这样实现的，首先为链表节点分配内存，接着为对象分配内存，然后将这块内存分配给链表节点指针，如下所示：

虚拟链表结构的一种实现

typedef struct liststruct
　　{
　　　　liststruct *next;
　　
　　} LIST, *pLIST;
　　
　　pLIST Head = NULL;
　　
　　pLIST AddToList( pLIST Head,
void * data, size_t datasize )
　　{
　　pLIST newlist=NULL;
　　void *p;
　　
　　　　// 分配节点内存和数据内存
　　　　newlist = (pLIST) malloc
( datasize + sizeof( LIST ) );
　　
　　　　// 为这块数据缓冲区指定一个指针
　　　　p = (void *)( newlist + 1 );
　　
　　　　// 复制数据
　　　　memcpy( p, data, datasize );
　　
　　　　// 将这个节点指定给链表的表头
　　　　if( Head )
　　　　{
　　　　newlist->next = Head;
　　　　}
　　　　else
　　　　newlist->next = NULL;
　　
　　　　Head = newlist;
　　
　　　　return Head;
　　}　　

链表节点现在建立在数据值副本的基本之上。这个版本能很好地处理标量值，但不能处理带有用 malloc 或 new 分配的元素的对象。要处理这些对象，LIST 结构需要包含一个一般的解除函数指针，这个指针可用来在将节点从链表中删除并解除它之前释放内存（或者关闭文件，或者调用关闭方法）。

一个带有解除函数的链表

typedef void (*ListNodeDestructor)( void * );
　　
　　typedef struct liststruct
　　{
　　　　ListNodeDestructor DestructFunc;
　　　　liststruct *next;
　　
　　} LIST, *pLIST;
　　
　　pLIST AddToList( pLIST Head, void * data, 
size_t datasize,
　　ListNodeDestructor Destructor )
　　{
　　pLIST newlist=NULL;
　　void *p;
　　
　　
　　　　// 分配节点内存和数据内存
　　　　newlist = (pLIST) malloc
( datasize + sizeof( LIST ) );
　　
　　　　// 为这块数据缓冲区指定一个指针
　　　　p = (void *)( newlist + 1 );
　　
　　　　// 复制数据
　　　　memcpy( p, data, datasize );
　　
　　　　newlist->DestructFunc = Destructor;
　　　　
　　　　// 将这个节点指定给链表的表头
　　　　if( Head )
　　　　{
　　　　　　newlist->next = Head;
　　　　}
　　　　else
　　　　　　newlist->next = NULL;
　　
　　　　Head = newlist;
　　
　　　　return Head;
　　}
　　
　　void DeleteList( pLIST Head )
　　{
　　　　pLIST Next;
　　　　while( Head )
　　　　{
　　　　　　Next = Head->next;
　　　　　　Head->DestructFunc( 
(void *) Head );
　　　　　　free( Head );
　　　　　　Head = Next;
　　　　}
　　}
　　
　　typedef struct ListDataStruct
　　{
　　　　LPSTR p;
　　
　　} LIST_DATA, *pLIST_DATA;
　　
　　void ListDataDestructor( void *p )
　　{
　　　　// 对节点指针进行类型转换
　　　　pLIST pl = (pLIST)p;
　　
　　　　// 对数据指针进行类型转换
　　　　pLIST_DATA pLD = (pLIST_DATA)
( pl + 1 );
　　
　　　　delete pLD->p;
　　}
　　pLIST Head = NULL;
　　
　　void TestList()
　　{
　　　　pLIST_DATA d = new LIST_DATA;
　　　　d->p = new char[24];
　　　　strcpy( d->p, "Hello" ); 
　　　　Head = AddToList( Head, (void *) d,
sizeof( pLIST_DATA ),
　　　　ListDataDestructor );
　　　　// 该对象已被复制，现在删除原来的对象
　　　　delete d;
　　
　　　　d = new LIST_DATA;
　　　　d->p = new char[24];
　　　　strcpy( d->p, "World" ); 
　　　　Head = AddToList( Head, (void *) d,
sizeof( pLIST_DATA ),
　　　　ListDataDestructor );
　　　　delete d;
　　
　　　　// 释放链表
　　　　DeleteList( Head );
　　}　　　

在每个链表节点中包含同一个解除函数的同一个指针似乎是浪费内存空间。确实如此，但只有链表始终包含相同的对象才属于这种情况。按这种方式编写链表允许您将任何对象放在链表中的任何位置。大多数链表函数要求对象总是相同的类型或类。

虚拟链表则无此要求。它所需要的只是将对象彼此区分开的一种方法。要实现这一点，您既可以检测解除函数指针的值，也可以在链表中所用的全部结构前添加一个类型值并对它进行检测。

当然，如果要将链表编写为一个 C++ 类，则对指向解除函数的指针的设置和存储只能进行一次。

C++ 解决方案：类链表

本解决方案将 CList 类定义为从 LIST 结构导出的一个类，它通过存储解除函数的单个值来处理单个存储类型。请注意添加的 GetCurrentData() 函数，该函数完成从链表节点指针到数据偏移指针的数学转换。一个虚拟链表对象

// 定义解除函数指针
　　
　　typedef void (*ListNodeDestructor)
( void * );
　　
　　// 未添加解除函数指针的链表
　　
　　typedef struct ndliststruct
　　{
　　　　ndliststruct *next;
　　
　　} ND_LIST, *pND_LIST;
　　
　　// 定义处理一种数据类型的链表类
　　
　　class CList : public ND_LIST
　　{
　　public:
　　　　CList(ListNodeDestructor);
　　　　~CList();
　　　　pND_LIST AddToList
( void * data, size_t datasize );
　　　　void *GetCurrentData();
　　　　void DeleteList( pND_LIST Head );
　　
　　
　　private:
　　　　pND_LIST m_HeadOfList;
　　　　pND_LIST m_CurrentNode;
　　　　ListNodeDestructor
m_DestructFunc;
　　};
　　
　　// 用正确的起始值构造这个链表对象
　　
　　CList::CList(ListNodeDestructor Destructor)
　　　　: m_HeadOfList(NULL), 
m_CurrentNode(NULL)
　　{
　　　　m_DestructFunc = Destructor;
　　}
　　
　　// 在解除对象以后删除链表
　　
　　CList::~CList()
　　{
　　　　DeleteList(m_HeadOfList);
　　}
　　
　　// 向链表中添加一个新节点
　　
　　pND_LIST CList::AddToList
( void * data, size_t datasize )
　　{
　　pND_LIST newlist=NULL;
　　void *p;
　　
　　
　　　　// 分配节点内存和数据内存
　　　　newlist = (pND_LIST) malloc
( datasize + sizeof( ND_LIST ) );
　　
　　　　// 为这块数据缓冲区指定一个指针
　　　　p = (void *)( newlist + 1 );
　　
　　　　// 复制数据
　　　　memcpy( p, data, datasize );
　　
　　　　// 将这个节点指定给链表的表头
　　　　if( m_HeadOfList )
　　　　{
　　　　　　newlist->next = m_HeadOfList;
　　　　}
　　　　else
　　　　　　newlist->next = NULL;
　　
　　　　m_HeadOfList = newlist;
　　
　　　　return m_HeadOfList;
　　}
　　
　　// 将当前的节点数据作为 void 类型返回，
以便调用函数能够将它转换为任何类型
　　
　　void * CList::GetCurrentData()
　　{
　　　　return (void *)(m_CurrentNode+1);
　　}
　　
　　// 删除已分配的链表
　　
　　void CList::DeleteList( pND_LIST Head )
　　{
　　　　pND_LIST Next;
　　　　while( Head )
　　　　{
　　　　　　Next = Head->next;
　　　　　　m_DestructFunc( (void *) Head );
　　　　　　free( Head );
　　　　　　Head = Next;
　　　　}
　　}
　　
　　// 创建一个要在链表中创建和存储的结构
　　
　　typedef struct ListDataStruct
　　{
　　　　LPSTR p;
　　
　　} LIST_DATA, *pND_LIST_DATA;
　　
　　// 定义标准解除函数
　　
　　void ClassListDataDestructor( void *p )
　　{
　　　　// 对节点指针进行类型转换
　　　　pND_LIST pl = (pND_LIST)p;
　　
　　　　// 对数据指针进行类型转换
　　　　pND_LIST_DATA pLD = (pND_LIST_DATA)
( pl + 1 );
　　
　　　　delete pLD->p;
　　}
　　
　　// 测试上面的代码
　　
　　void MyCListClassTest()
　　{
　　　　// 创建链表类
　　
　　　　CList* pA_List_of_Data =
new CList(ClassListDataDestructor);
　　
　　　　// 创建数据对象
　　　　
　　　　pND_LIST_DATA d = new LIST_DATA;
　　　　d->p = new char[24];
　　　　strcpy( d->p, "Hello" ); 
　　
　　　　// 创建指向链表顶部的局部指针
　　
　　　　pND_LIST Head = NULL;
　　
　　　　//向链表中添加一些数据
　　
　　　　Head = pA_List_of_Data->AddToList
( (void *) d, 
　　　　sizeof( pND_LIST_DATA ) );
　　　　// 该对象已被复制，现在删除原来的对象
　　　　delete d;
　　
　　　　// 确认它已被存储
　　　　char * p = ((pND_LIST_DATA) pA_List_of_Data->GetCurrentData())->p;
　　
　　　　d = new LIST_DATA;
　　　　d->p = new char[24];
　　　　strcpy( d->p, "World" ); 
　　　　Head = pA_List_of_Data->AddToList
( (void *) d, sizeof( pND_LIST_DATA ) );
　　　　// 该对象已被复制，现在删除原来的对象
　　　　delete d;
　　
　　　　// 确认它已被存储
　　　　p = ((pND_LIST_DATA) 
pA_List_of_Data->GetCurrentData())->p;
　　
　　　　// 删除链表类，析构函数将删除链表
　　　　delete pA_List_of_Data;
　　}

小结

从前面的讨论来看，似乎仅编写一个简单的链表就要做大量的工作，但这只须进行一次。很容易将这段代码扩充为一个处理排序、搜索以及各种其他任务的 C++ 类，并且这个类可以处理任何数据对象或类（在一个项目中，它处理大约二十个不同的对象）。您永远不必重新编写这段代码。