欧美午夜免费电影,欧美国产日韩a欧美在线观看,欧美日韩成人免费

井泉 — Wed, 19 Nov 2008 06:59:00 GMT

RTTI �?#8220;Runtime Type Information”的羃写，意思是�Q�运行时�c�d��信息。它提供了运行时��定对象�c�d��的方法。本文将��略介�l?RTTI 的一些背景知识、描�q? RTTI 的概念，�q��过具体例子和代码介�l�什么时候��用以及如何��?RTTI�Q�本文还��详�l�描�q�C��个重要的 RTTI �q�算�W�的使用�Ҏ��Q�它们是 typeid �?dynamic_cast�?br> 其实�Q�RTTI 在C++中�ƈ不是什么新的东西，它早在十多年以前��已�l�出��C��。但是大多数开发�h员，包括许多高层�ơ的C++�E�序员对它�ƈ不怎么熟悉�Q�更不用说��?RTTI 来设计和�~�写应用�E�序了�?br> 一些面向对象专家在传播自己的设计理忉|��Q�大多都��d��在设计和开发中明智��C��用虚拟成员函敎ͼ�而不�?RTTI 机制。但是，在很多情况下�Q�虚拟函数无法克服本�w�的局限。每每涉及到处理异类容器和根基类层次�Q�如 MFC�Q�时�Q�不可避免要对对象类型进行动态判断，也就是动态类型的侦测。如何确定对象的动态类型呢�Q�答案是使用内徏�? RTTI 中的�q�算�W�：typeid �?dynamic_cast�?br> 首先让我们来设计一个类层次�Q�假设我们创��Z��某个处理文�g的抽象基�c�R��它声明下列�U�虚拟函敎ͼ�open()、close()、read()�? write()�Q?

class File
{
public:
 virtual int open(const string & filename)=0;
 virtual int close(const string & filename)=0;
 //
 virtual ~File()=0; // ��C����d���U�虚拟析构函敎ͼ�dtor�Q?br>};

现在�?File �c�L��生的�c�要实现基类的纯虚拟函数�Q�同时还要提供一些其他的操作。假设派生类�?DiskFile�Q�除了实现基�cȝ��U�虚拟函数外�Q�还要实现自��q��flush()和defragment()操作�Q?

class DiskFile: public File
{
public:
 int open(const string & filename);

 // 实现其他的纯虚拟函数
    ......

 // 自己的专有操�?br> virtual int flush();
 virtual int defragment();
};

接着�Q�又�?DiskFile �c�L��生两个类�Q�假设�ؓ TextFile �?MediaFile。前者针�Ҏ��本文�Ӟ��后者针寚w��频和视频文�g�Q?

class TextFile: public DiskFile
{
  // ......
  int  sort_by_words();
};

class MediaFile: public DiskFile
{
  //......
};

我们之所以要创徏�q�样的类层次�Q�是因�ؓ�q�样做以后可以创建多态对象，如：

File *pfile; // *pfile的静态类型是 File
if(some_condition)
  pfile = new TextFile; // 动态类型是 TextFile
else
  pfile = new DiskFile; // 动态类型是 DiskFile

假设你正在开发一个基于图形用��L��面（GUI�Q�的文�g��理器，每个文�g都可以以图标方式昄��。当鼠标�U�d��图标上�ƈ单击右键�Ӟ��文�g��理器打开一个菜单，�? 个文仉��了共同的菜单��，不同的文件类型还有不同的菜单��V��如�Q�共同的菜单��Ҏ��“打开”“拯��”、和“�_�脓”�Q�此外，�q�有一些针对特�D�文件的专门操作。比如，文本文�g会有“�~�辑”操作�Q�而多媒体文�g则会�?#8220;播放”菜单。�ؓ了��?RTTI 来动态定制菜单，文�g��理器必��M��每个文件的动态类型。利�? �q�算�W?typeid 可以获取与某个对象关联的�q�行时类型信息。typeid 有一个参敎ͼ�传递对象或�c�d��名。因此，��Z��定 x 的动态类型是不是Y�Q�可以用表达式：typeid(x) == typeid(Y)实现�Q?

#include  // typeid 需要的头文�?br>void menu::build(const File * pfile)
{
 if (typeid(*pfile)==typeid(TextFile))
 {
  add_option("edit"); 
 }
 else if (typeid(*pfile)==typeid(MediaFile))
 {
 add_option("play"); 
 }
}

使用 typeid 要注意一个问题，那就是某些编译器�Q�如 Visual C++�Q�默认状态是��用 RTTI 的，目的是消除性能上的开销。如果你的程序确实��用了 RTTI�Q�一定要��C��在编译前启用 RTTI。��?typeid 可能产生一些将来的�l�护问题。假设你军_��扩展上述的类层次�Q�从MediaFile �z��另一个叫 LocalizeMedia 的类�Q�用�q�个�c�表�C�带有不同语�a�说明文字的媒体文件。但 LocalizeMedia 本质上还是个 MediaFile �c�d��的文件。因此，当用户在该类文�g图标上单��d��键时�Q�文件管理器必须提供一�?#8220;播放”菜单。可�? build()成员函数会调用失败，原因是你没有��查这�U�特定的文�g�c�d��。�ؓ了解册��个问题，你必��象下面�q�样�?build() 打补丁：

void menu::build(const File * pfile)
{

 //......

  else if (typeid(*pfile)==typeid(LocalizedMedia))
 {
  add_option("play"); 
  }
}

唉，�q�种做法真是昑־�太业余了�Q�以后每�ơ添加新的类�Q�毫无疑问都必须打类似的补丁。显�Ӟ��q�不是一个理想的解决�Ҏ��。这个时候我们就要用�? dynamic_cast�Q�这个运��符用于多态编�E�中保证在运行时发生正确的�{换（即编译器无法验证是否发生正确的�{换）。用它来��定某个对象�? MediaFile 对象�q�是它的�z��c�d��象。dynamic_cast 常用于从多态编�E�基�c�L��针向�z��c�L��针的向下�c�d��转换。它有两个参敎ͼ�一个是�c�d��名；另一个是多态对象的指针或引用。其功能是在�q�行时将对象强制转换为目标类型�ƈ�q�回布尔型结果。也��是��_��如果该函数成功地�q�且是动态的��? *pfile 强制转换�?MediaFile�Q�那�?pfile的动态类型是 MediaFile 或者是它的�z��c�R��否则，pfile 则�ؓ其它的类型：

void menu::build(const File * pfile)
{
 if (dynamic_cast  (pfile))
 {
  // pfile �?MediaFile 或者是MediaFile的派生类 LocalizedMedia
  add_option("play"); 
 }
 else if (dynamic_cast  (pfile))
 {
  // pfile �?TextFile 是TextFile的派生类
  add_option("edit"); 
 }
}

�l�细想一下，虽然使用 dynamic_cast ��实很好地解决了我们的问题，但也需要我们付��Z��P��那就是与 typeid 相比�Q�dynamic_cast 不是一个常量时间的操作。�ؓ了确定是否能完成强制�c�d��转换�Q�dynamic_cast`必须在运行时�q�行一些�{换细节操作。因此在使用 dynamic_cast 操作�Ӟ��应该权衡�Ҏ��能的媄响�?img src ="http://m.shnenglu.com/zjj2816/aggbug/67286.html" width = "1" height = "1" />

井泉 2008-11-19 14:59 发表评论

(�?�q�程通信机制

井泉 — Thu, 13 Dec 2007 07:50:00 GMT

Windows 95�q�程间数据通讯的实现技�?br>1、引�a�
在Windows�E�序中，各个�q�程之间常常需要交换数据，�q�行数据通讯。WIN32 API提供�?br>许多函数使我们能够方侉K��效的�q�行�q�程间的通讯�Q�通过�q�些函数我们可以控制不同�q?br>�E�间的数据交换，��如同在WIN16中对本地�q�程�q�行��d��操作一栗��?br>典型的WIN16两进�E�可以通过�׃�n内存来进行数据交换：�Q?�Q�进�E�A��GlobalAlloc�Q�GM
EM_SHARE...�Q�API分配一定长度的内存�Q�（2�Q�进�E�A��GlobalAlloc函数�q�回的句柄传�?br>�l�进�E�B�Q�通过一个登录消息）�Q�（3�Q�进�E�B对这个句柄调用GlobalLock函数�Q��ƈ利用G
lobalLock函数�q�回的指针访问数据。这�U�方法在WIN32中可能失败，�q�是因�ؓGlobalLo
ck函数�q�回指向的是�q�程A的内存，�׃��q�程使用的是虚拟地址而非实际物理地址�Q�因�?br>�q�一指针仅与A�q�程有关�Q�而于B�q�程无关�?br>本文探讨了几�U�WIN32下进�E�之间通讯的几�U�实现方法，读者可以��用不同的�Ҏ��以达�?br>�E�序�q�行高效可靠的目的�?br>2、Windows95中进�E�的内存�I�间��理
WIN32�q�程间通讯与Windows95的内存管理有密切关系�Q�理解Windows95的内存管理对我们
如下的程序设计将会有很大的帮助，下面我们讨论以下Windows95中进�E�的内存�I�间��理
�?br>在WIN16下，所有Windows应用�E�序�׃�n单一地址�Q��Q何进�E�都能够对这一�I�间中属于共
享单一的地址�I�间�Q��Q何进�E�都能够对这一�I�间中属于其他进�E�的内存�q�行��d��操作�Q?br>甚至可以存取操作�pȝ��本��n的数据，�q�样��可能破坏其他程序的数据�D�代码�?br>在WIN32下，每个�q�程都有自己的地址�I�间�Q�一个WIN32�q�程不能存取另一个地址的私�?br>数据�Q�两个进�E�可以用��h��相同值的指针��d��Q�但所��d��的只是它们各自的数据�Q�这�?br>��减��了�q�程之间的相互干扰。另一斚w��Q�每个WIN32�q�程拥有4GB的地址�I�间�Q�但�q�不
代表它真正拥�?GB的实际物理内存，而只是操作系�l�利用CPU的内存分配功能提供的�?br>拟地址�I�间。在一般情况下�Q�绝大多数虚拟地址�q�没有物理内存于它对应，在真正可�?br>使用�q�些地址�I�间之前�Q�还要由操作�pȝ��提供实际的物理内存（�q�个�q�程�?#8220;提交”co
mmit�Q�。在不同的情况下�Q�系�l�提交的物理内存是不同的�Q�可能是RAM�Q�也可能是硬盘模
拟的虚拟内存�?br>3、WIN32中进�E�间的通讯
在Windows 95中，为实现进�E�间�q�等的数据交换，用户可以有如下几�U�选择�Q?br>* 使用内存映射文�g
* 通过�׃�n内存DLL�׃�n内存
* 向另一�q�程发送WM_COPYDATA消息
* 调用ReadProcessMemory以及WriteProcessMemory函数�Q�用户可以发送由GlobalLock(
GMEM_SHARE,...)函数调用提取的句柄、GlobalLock函数�q�回的指针以及VirtualAlloc�?br>数返回的指针�?br>3.1、利用内存映��文件实现WIN32�q�程间的通讯
Windows95中的内存映射文�g的机制�ؓ我们高效地操作文件提供了一�U�途径�Q�它允许我们
在WIN32�q�程中保留一�D�内存区域，把目标文件映��到�q�段虚拟内存中。在�E�序实现中必
��考虑各进�E�之间的同步。具体实现步骤如下：
首先我们在发送数据的�q�程中需要通过调用内存映射API函数CreateFileMapping创徏一
个有名的�׃�n内存�Q?br>HANDLE CreateFileMapping(
HANDLE hFile,    // 映射文�g的句柄，
//设�ؓ0xFFFFFFFF以创��Z��个进�E�间�׃�n的对�?br>LPSECURITY_ATTRIBUTES lpFileMappingAttributes,    // 安全属�?br>DWORD flProtect,    // 保护方式
DWORD dwMaximumSizeHigh,    //对象的大��?br>DWORD dwMaximumSizeLow,
LPCTSTR lpName     // 必须为映��文件命�?br>);
与虚拟内存类��|��保护方式可以是PAGE_READONLY或是PAGE_READWRITE。如果多�q�程都对
同一�׃�n内存�q�行写访问，则必��M��持相互间同步。映��文件还可以指定PAGE_WRITECO
PY标志�Q�可以保证其原始数据不会遭到破坏�Q�同时允许其他进�E�在必要时自��q��操作�?br>据的拯��?br>在创建文件映��对象后使用可以调用MapViewOfFile函数映射到本�q�程的地址�I�间内�?br>下面说明创徏一个名为MySharedMem的长度�ؓ4096字节的有名映��文�Ӟ��
HANDLE hMySharedMapFile=CreateFileMapping((HANDLE)0xFFFFFFFF)�Q?br>NULL�Q�PAGE_READWRITE�Q?�Q?x1000�Q?MySharedMem")�Q?br>�q�映��缓存区视图�Q?br>LPSTR pszMySharedMapView=(LPSTR)MapViewOfFile(hMySharedMapFile�Q?br>FILE_MAP_READ|FILE_MAP_WRITE�Q?�Q?�Q?);
其他�q�程讉K��׃�n对象�Q�需要获得对象名�q�调用OpenFileMapping函数�?br>HANDLE hMySharedMapFile=OpenFileMapping(FILE_MAP_WRITE�Q?br>FALSE�Q?MySharedMem");
一旦其他进�E�获得映��对象的句柄�Q�可以象创徏�q�程那样调用MapViewOfFile函数来映��?br>对象视图。用户可以��用该对象视图来进行数据读写操作，以达到数据通讯的目的�?br>当用戯��E�结束��用共享内存后�Q�调用UnmapViewOfFile函数以取消其地址�I�间内的视图
�Q?br>if (!UnmapViewOfFile(pszMySharedMapView))
{ AfxMessageBox("could not unmap view of file"); }
3.2、利用共享内存DLL
�׃�n数据DLL允许�q�程以类��g��Windows 3.1 DLL�׃�n数据的方式访问读写数据，多个�q?br>�E�都可以对该�׃�n数据DLL�q�行数据操作�Q�达到共享数据的目的。在WIN32中�ؓ建立�׃�n
内存�Q�必��L��行以下步骤：
首先创徏一个有名的数据区。这在Visual C++中是使用data_seg pragma宏。��用data_
seg pragma宏必��L��意数据的初始化：
#pragma data_seg("MYSEC")
char MySharedData[4096]={0};
#pragma data_seg()
然后在用��L��DEF文�g中�ؓ有名的数据区讑֮��׃�n属性�?br>LIBRARY TEST
DATA READ WRITE
SECTIONS
    .MYSEC READ WRITE SHARED
�q�样每个附属于DLL的进�E�都��接受到属于自己的数据拷贝，一个进�E�的数据变化�q�不�?br>反映到其他进�E�的数据中�?br>在DEF文�g中适当地输出数据。以下的DEF文�g��说明了如何以常数变量的形式输出MySh
aredData�?br>EXPORTS
    MySharedData CONSTANT
最后在应用�E�序�Q�进�E�）按外部变量引用共享数据�?br>extern _export"C"{char * MySharedData[];}
�q�程中��用该变量应注意间接引用�?br>m_pStatic=(CEdit*)GetDlgItem(IDC_SHARED);
m_pStatic->GetLine(0,*MySharedData,80);
3.3、用于传输只��L��据的WM_COPYDATA
传输只读数据可以使用Win32中的WM_COPYDATA消息。该消息的主要目的是允许在进�E�间
传递只��L��据。Windows95在通过WM_COPYDATA消息传递期��_��不提供��承同步方式。SD
K文档推荐用户使用SendMessage函数�Q�接受方在数据拷贝完成前不返回，�q�样发送方��?br>不可能删除和修改数据�Q?br>SendMessage(hwnd,WM_COPYDATA,wParam,lParam);
其中wParam讄��为包含数据的�H�口的句柄。lParam指向一个COPYDATASTRUCT的结构：
typedef struct tagCOPYDATASTRUCT{
    DWORD dwData;//用户定义数据
    DWORD cbData;//数据大小
    PVOID lpData;//指向数据的指�?br>}COPYDATASTRUCT;
该结构用来定义用��h��据�?br>3.4、直接调用ReadProcessMemory和WriteProcessMemory函数实现�q�程间通讯
通过调用ReadProcessMemory以及WriteProcessMemory函数用户可以按类��g��Windows3.
1的方法实现进�E�间通讯�Q�在发送进�E�中分配一块内存存放数据，可以调用GlobalAlloc
或者VirtualAlloc函数实现�Q?br>pApp->m_hGlobalHandle=GlobalAlloc(GMEM_SHARE,1024);
可以得到指针地址�Q?br>pApp->mpszGlobalHandlePtr=(LPSTR)GlobalLock
(pApp->m_hGlobalHandle);
在接收进�E�中要用到用户希望媄响的�q�程的打开句柄。�ؓ了读写另一�q�程�Q�应按如下方
式调用OpenProcess函数�Q?br>HANDLE hTargetProcess=OpenProcess(
STANDARD_RIGHTS_REQUIRED|
PROCESS_VM_REDA|
PROCESS_VM_WRITE|
PROCESS_VM_OPERATION,//讉K��权限
FALSE,//�l�承关系
dwProcessID);//�q�程ID
��Z��证OpenProcess函数调用成功�Q�用��h��影响的进�E�必��ȝ��上述标志创徏�?br>一旦用戯��得一个进�E�的有效句柄�Q�就可以调用ReadProcessMemory函数��d��该进�E�的�?br>存：
BOOL ReadProcessMemory(
HANDLE hProcess,    // �q�程指针
LPCVOID lpBaseAddress,    // 数据块的首地址
LPVOID lpBuffer,    // ��d��数据所需�~�冲�?br>DWORD cbRead,    // 要读取的字节�?br>LPDWORD lpNumberOfBytesRead
);
使用同样的句柄也可以写入该进�E�的内存�Q?br>BOOL WriteProcessMemory(
HANDLE hProcess,    // �q�程指针
LPVOID lpBaseAddress,    // 要写入的首地址
LPVOID lpBuffer,    // �~�冲区地址
DWORD cbWrite,    // 要写的字节数
LPDWORD lpNumberOfBytesWritten
);
如下所�C�是��d��另一�q�程的共享内存中的数据：
ReadProcessMemory((HANDLE)hTargetProcess,
(LPSTR)lpsz,m_strGlobal.GetBuffer(_MAX_FIELD),
_MAX_FIELD,&cb);
WriteProcessMemory((HANDLE)hTargetProcess,
(LPSTR)lpsz,(LPSTR)STARS,
m_strGlobal.GetLength(),&cb);
4、进�E�之间的消息发送与接收
在实际应用中�q�程之间需要发送和接收Windows消息来通知�q�程间相互通讯�Q�发送方发�?br>通讯的消息以通知接收方，接收方在收到发送方的消息后��可以对内存�q�行��d��操作�?br>
我们在程序设计中采用Windows注册消息�q�行消息传递，首先在发送进�E�初始化�q�程中进
行消息注册：
m_nMsgMapped=::RegisterWindowsMessage("Mapped");
m_nMsgHandle=::RegisterWindowsMessage("Handle");
m_nMsgShared=::RegisterWindowsMessage("Shared");
在程序运行中向接收进�E�发送消息：
CWnd* pWndRecv=FindWindow(lpClassName,"Receive");
pWndRecv->SendMessage(m_MsgMapped,0,0);
pWndRecv->SendMessage(m_nMsgHandle,
(UINT)GetCurrentProcessID(),(LONG)pApp->m_hGlobalHandle);
pWndRecv->SendMessage(m_nMsgShared,0,0);
可以按如下方式发送WM_COPYDATA消息�Q?br>static COPYDATASTRUCT cds;//用户存放数据
pWnd->SendMessage(WM_COPYDATA,NULL,(LONG)&cds);
接收方进�E�初始化也必��进行消息注册：
UNIT CRecvApp:: m_nMsgMapped=::RegisterWindowsMessage("Mapped");
UNIT CRecvApp::m_nMsgHandle=::RegisterWindowsMessage("Handle");
UNIT CRecvApp::m_nMsgShared=::RegisterWindowsMessage("Shared");
同时映射消息函数如下�Q?br>ON_REGISTERED_MASSAGE(CRecvApp::m_nMsgMapped,OnRegMsgMapped)
ON_REGISTERED_MASSAGE(CRecvApp::m_nMsgHandle,OnRegMsgHandle)
ON_REGISTERED_MASSAGE(CRecvApp::m_nMsgShared,OnRegMsgShared)
在这些消息函数我们就可以采用上述技术实现接收进�E�中数据的读写操作了�?br>5、结束语
从以上分析中我们可以看出Windows95的内存管理与Windows 3.x相比有很多的不同�Q�对
�q�程之间的通讯有较��Z��格的限制。这��q��保了��M��故障�E�序无法意外地写入用��L��?br>址�I�间�Q�而用户则可根据实际情�늁��z�d��q�行�q�程间的数据通讯�Q�从�q�一点上来讲Wind
ows95增强应用�E�序的强壮性�?br>参考文献：
1�?nbsp;David J.Kruglinski, Visual C++技术内�q? 北京�Q�清华大学出版社�Q?995.
2�?nbsp;Microsoft Co. Visual C++ 5.0 On Line Help.

井泉 2007-12-13 15:50 发表评论

windows mobile 关闭gprs�q�接

井泉 — Thu, 22 Nov 2007 04:59:00 GMT

unsigned int CloseRasGPRSConnections()
{
     int index; // An integer index
     DWORD dwError, dwRasConnSize, dwNumConnections; // Number of connections found
     RASCONN RasConn[20]; // Buffer for connection state data,Assume the maximum number of entries is 20.
    BOOL RETURN_VALUE=0;
    WCHAR *MySelectNetName;

     // Assume no more than 20 connections.
     RasConn[0].dwSize = sizeof (RASCONN);
     dwRasConnSize = 20 * sizeof (RASCONN);

     // Find all connections.
    if (dwError = RasEnumConnections (RasConn, &dwRasConnSize,&dwNumConnections))
     {
        return -1;
     }

     // If there are no connections, return zero.
     if (!dwNumConnections)
     {
        return 0;
     }

     // Terminate all of the remote access connections.
     GetConnectionStatus();
    //here add to get selected network
    MySelectNetName=GetMMSSelectNet();

    GPRSServerName* P_CMWAPtemp=pCMWAP_backup;
     for (index = 0; index < (int)dwNumConnections; ++index)
     {
         while( P_CMWAPtemp )
         {
            if(!wcscmp(RasConn[index].szEntryName,P_CMWAPtemp->ServerName)||
                !wcscmp(RasConn[index].szEntryName, MySelectNetName))
            {
                   if (dwError = RasHangUp (RasConn[index].hrasconn))

                        RETURN_VALUE=-1;
                   else
                           //successfully disconnect cmwap;
                        RETURN_VALUE=0;
            }
            P_CMWAPtemp = P_CMWAPtemp->pnext ;
        }
     }
    //free mem
     freelink(pCMWAP_backup);
     return RETURN_VALUE;
}

井泉 2007-11-22 12:59 发表评论

c++ �?jscript

井泉 — Tue, 20 Nov 2007 01:19:00 GMT

#pragma once

#include
#include

class CCodeObject;
class CScriptSite;

class CScriptingSupportHelper
{
public:
    CScriptingSupportHelper();
    ~CScriptingSupportHelper();

    BOOL Create(CWnd* pWnd);
    BOOL RunScript(CString str);

    CCodeObject* GetCodeObject() const { return m_pCodeObject; }
    CScriptSite* GetScriptSite() const { return m_pScriptSite; }
    IActiveScript* GetActiveScript() const { return m_pActiveScript; }

private:
    CCodeObject* m_pCodeObject;
    CScriptSite* m_pScriptSite;

    IActiveScript* m_pActiveScript;
    IActiveScriptParse* m_pActiveScriptParse;
};

class CCodeObject : public CCmdTarget
{
public:
    CCodeObject(CScriptingSupportHelper* pScripting, CWnd* pWnd);
    virtual ~CCodeObject();

    void Line(long, long, long, long);
    void Ellipse(long, long, long, long);
    void DrawText(LPCTSTR msg, long x, long y, long w, long h);

    void OnPaint();
    void OnMouseClick(long x, long y);

private:
    CWnd* m_pWnd;
    CScriptingSupportHelper* m_pScripting;
    BOOL GetDispatch(OLECHAR* name, COleDispatchDriver& disp, DISPID& dispid);

    enum
    {
        idLine = 1,
        idEllipse,
        idDrawText,
    };

    DECLARE_DISPATCH_MAP()
};

class CScriptSite : public IActiveScriptSite
{
public:
    CScriptSite(CScriptingSupportHelper* pScripting)
    {
        m_pScripting = pScripting;
    };

    ~CScriptSite()
    {
    };

    virtual ULONG STDMETHODCALLTYPE AddRef()
    {
        return InterlockedIncrement(&m_nRefCount);
    }

    virtual ULONG STDMETHODCALLTYPE Release()
    {
        return InterlockedDecrement(&m_nRefCount);
    };

    virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, void** ppObj)
    {
        *ppObj = NULL;

        if ((iid == IID_IUnknown) || (iid == IID_IActiveScriptSite))
        {
            *ppObj= (IActiveScriptSite*)this;
            AddRef();
            return S_OK;
        }

        return E_NOINTERFACE;
    }

    virtual HRESULT STDMETHODCALLTYPE GetLCID(LCID __RPC_FAR *)
    {
        return E_NOTIMPL;
    }

    virtual HRESULT STDMETHODCALLTYPE GetItemInfo(LPCOLESTR, DWORD, IUnknown __RPC_FAR *__RPC_FAR * pObj, ITypeInfo __RPC_FAR *__RPC_FAR *)
    {
        ASSERT(m_pScripting);
        ASSERT(m_pScripting->GetCodeObject());

        *pObj = m_pScripting->GetCodeObject()->GetIDispatch(TRUE);
        return S_OK;
    }

    virtual HRESULT STDMETHODCALLTYPE GetDocVersionString(BSTR __RPC_FAR *)
    {
        return E_NOTIMPL;
    }

    virtual HRESULT STDMETHODCALLTYPE OnScriptTerminate(const VARIANT __RPC_FAR * ,const EXCEPINFO __RPC_FAR *)
    {
        return E_NOTIMPL;
    }


    virtual HRESULT STDMETHODCALLTYPE OnStateChange(SCRIPTSTATE)
    {
        return E_NOTIMPL;
    }

    virtual HRESULT STDMETHODCALLTYPE OnScriptError(IActiveScriptError __RPC_FAR * pScriptError)
    {
        return E_NOTIMPL;
    }

    virtual HRESULT STDMETHODCALLTYPE OnEnterScript()
    {
        return E_NOTIMPL;
    }

    virtual HRESULT STDMETHODCALLTYPE OnLeaveScript()
    {
        return E_NOTIMPL;
    }

private:
    long m_nRefCount;
    CScriptingSupportHelper* m_pScripting;
};

#include "StdAfx.h"
#include "ScriptingSupport.h"

CCodeObject::CCodeObject(CScriptingSupportHelper* pScripting, CWnd* pWnd)
    : m_pWnd(pWnd),
    m_pScripting(pScripting)

{
    EnableAutomation();
}

CCodeObject::~CCodeObject()
{
}

BEGIN_DISPATCH_MAP(CCodeObject, CCmdTarget)
DISP_FUNCTION_ID(CCodeObject, "Line", idLine, Line, VT_EMPTY, VTS_I4 VTS_I4 VTS_I4 VTS_I4)
DISP_FUNCTION_ID(CCodeObject, "Ellipse", idEllipse, Ellipse, VT_EMPTY, VTS_I4 VTS_I4 VTS_I4 VTS_I4)
DISP_FUNCTION_ID(CCodeObject, "DrawText", idDrawText, DrawText, VT_EMPTY, VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_I4)
END_DISPATCH_MAP()

void CCodeObject::Line(long x1, long y1, long x2, long y2)
{
    CWindowDC dc(m_pWnd);

    dc.MoveTo(x1, y1);
    dc.LineTo(x2, y2);
}

void CCodeObject::Ellipse(long x1, long y1, long x2, long y2)
{
    CWindowDC dc(m_pWnd);
    dc.Ellipse(x1, y1, x2, y2);
}

void CCodeObject::DrawText(LPCTSTR msg, long x, long y, long w, long h)
{
    CWindowDC dc(m_pWnd);
    CRect rect(x, y, x+w, y+h);

    dc.DrawText(msg, rect, 0);
}

void CCodeObject::OnPaint()
{
    COleDispatchDriver disp;
    DISPID dispid;
    if (GetDispatch(L"OnPaint", disp, dispid)) {
        disp.InvokeHelper(dispid, DISPATCH_METHOD, VT_EMPTY, 0, 0);
    }
}

BOOL CCodeObject::GetDispatch(OLECHAR* name, COleDispatchDriver& disp, DISPID& dispid)
{
    IDispatch* pScriptDispatch = 0;
    m_pScripting->GetActiveScript()->GetScriptDispatch(0, &pScriptDispatch);
    disp.AttachDispatch(pScriptDispatch);
    HRESULT hr = pScriptDispatch->GetIDsOfNames(IID_NULL, &name, 1, LOCALE_SYSTEM_DEFAULT, &dispid);
    return SUCCEEDED(hr);
}

void CCodeObject::OnMouseClick(long x, long y)
{
    COleDispatchDriver disp;
    DISPID dispid;
    if (GetDispatch(L"OnMouseClick", disp, dispid)) {
        disp.InvokeHelper(dispid, DISPATCH_METHOD, VT_EMPTY, 0, (const BYTE*)(VTS_I4 VTS_I4), x, y);
    }
}

CScriptingSupportHelper::CScriptingSupportHelper()
    : m_pCodeObject(0),
    m_pScriptSite(0),
    m_pActiveScript(0),
    m_pActiveScriptParse(0)
{
}

CScriptingSupportHelper::~CScriptingSupportHelper()
{
    if (m_pActiveScript)
    {
        m_pActiveScript->Close();
        m_pActiveScriptParse->Release();
        m_pActiveScript->Release();
    }

    delete m_pCodeObject; m_pCodeObject=0;
    delete m_pScriptSite; m_pScriptSite=0;
}

BOOL CScriptingSupportHelper::RunScript(CString strText)
{
    EXCEPINFO ei = {0};
    BSTR bstrText = strText.AllocSysString();
    m_pActiveScriptParse->ParseScriptText(bstrText, NULL, NULL, NULL, 0, 0, 0, NULL, &ei);
    SysFreeString(bstrText);

    m_pActiveScript->SetScriptState(SCRIPTSTATE_CONNECTED);

    return TRUE;
}

BOOL CScriptingSupportHelper::Create(CWnd* pWnd)
{
    m_pCodeObject = new CCodeObject(this, pWnd);
    m_pScriptSite = new CScriptSite(this);

    CLSID clsidJScript;
    CLSIDFromProgID(L"JScript", &clsidJScript);
    CoCreateInstance(clsidJScript, NULL, CLSCTX_INPROC_SERVER, IID_IActiveScript, (void **)&m_pActiveScript);
    m_pActiveScript->QueryInterface(IID_IActiveScriptParse, (void**)&m_pActiveScriptParse);
    m_pActiveScript->SetScriptSite(m_pScriptSite);
    m_pActiveScript->AddNamedItem(L"Code", SCRIPTITEM_ISVISIBLE | SCRIPTITEM_ISSOURCE | SCRIPTITEM_GLOBALMEMBERS);
    m_pActiveScriptParse->InitNew();

    return TRUE;
}

井泉 2007-11-20 09:19 发表评论

(msdn)Using MFC to Automate SAPI (SAPI 5.3)http://msdn2.microsoft.com/en-us/library/ms717069.aspx

井泉 — Tue, 20 Nov 2007 01:06:00 GMT

Microsoft Speech API 5.3 用oleview 可以产生 idl 文�g 再用 midl工具可以产生 tlb,h,c 存根文�g �{?

Using MFC to Automate SAPI

Introduction

The Microsoft Foundation Classes (MFC) provides an easy and convenient way to automate calls to SAPI using its Class Wizard to generate wrappers for the SAPI layer from the SAPI Type Library.

In order to accomplish this, perform the following steps:

Create a new MFCAppWizard(exe) project in Visual C++.
Based on the type of application you are creating, follow the wizard prompts. In Step 3 of the wizard prompts, (or Step 2 if you are creating a Dialog Based application) make sure that the Automation check box is selected under the heading, What other support would you like to include?

Once the new project is ready, access Class Wizard.

Click the Automation tab, and then click Add Class and select From a type library in the drop-down list.
Browse for the sapi.dll file and open it.
Select the classes you would like Class Wizard to generate a wrapper for. The resulting default header and implementation files are sapi.h and sapi.cpp respectively. The rest of this document assumes that you have chosen to use these default file names. Click OK.
You should now be back in the Class Wizard window. Click OK.

After you are done with the above steps, Visual C++ will automatically add the Class Wizard generated files sapi.cpp and sapi.h to your project.

Upon viewing the sapi.h file, you should notice that it is nothing more than an automation wrapper that has been generated for all the classes you selected. Notice that all the classes inherit from COleDispatchDriver, hence the dispatch interface needs to be set up. This only requires a few lines of simple code, after which the wrapper class can be used just like any other C++ class.

Example

This example assumes that you chose to generate a wrapper for the ISpeechVoice class from among any other classes you may have selected. Using the project created above, include the sapi.h file within a source file in the project that will make automation calls to SAPI using the wrapper. In that source file, type the following code.

CLSID CLSID_SpVoice;    // class ID for the SAPI SpVoice object
LPDISPATCH pDisp;       // dispatch interface for the class
ISpeechVoice voice;     // use the MFC Class Wizard generated wrapper

CLSIDFromProgID(L"SAPI.SpVoice", &CLSID;_SpVoice);
voice.CreateDispatch(CLSID_SpVoice);
pDisp = voice.m_lpDispatch;

HRESULT hr = pDisp->QueryInterface(CLSID_SpVoice, (void**)&voice;.m_lpDispatch);

if (hr == S_OK) {
    pDisp->Release();
}
else {
    voice.AttachDispatch(pDisp, TRUE);
}

voice.Speak("hello world", 1);   // asynchronous call to Speak method of ISpeechVoice interface

If you have been following the steps outlined above properly, you should hear your computer say "hello world!" That's all there is to using MFC to make automation calls to SAPI. Currently however, not all the wrapper classes generated by MFC's Class Wizard work properly. For instance, the ISpeechLexicon interface does not work. The work around for this is to implement your own automation wrapper classes using C++. The steps to do that are beyond the scope of this document. Of course, you can always use the COM interfaces in C++ and Automation in Visual Basic to ensure that every interface in SAPI works easily and flawlessly.

井泉 2007-11-20 09:06 发表评论

客户端调用com

井泉 — Tue, 20 Nov 2007 00:49:00 GMT

void opercom()
{
    ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
    //    {2D8EBDEE-437C-47c9-ABCC-F169E5E781D0}speeddial
    //    {85140985-7A18-4009-B5FB-43268FD154F8}ISpRecognizerLite

        CLSID CLSID_SpVoice;
        ::CLSIDFromProgID(L"SpeedDial", &CLSID_SpVoice);
        LPCLASSFACTORY pClsF;
        LPUNKNOWN punk;                   ::CoGetClassObject(CLSID_SpVoice,CLSCTX_INPROC_SERVER,NULL,IID_IClassFactory,(void**)&pClsF);
        pClsF->CreateInstance(NULL,IID_IUnknown,(void**)&punk);
    punk->QueryInterface(IID_ISpRecognizerLite,(void**)&非抽象类);
    ::CoUninitialize();
}

井泉 2007-11-20 08:49 发表评论

(�?手工注册com

井泉 — Tue, 20 Nov 2007 00:48:00 GMT

BOOL regcom(LPCWSTR strLib)
{
    //for registration
    HMODULE hLib = ::LoadLibrary(strLib);
    if(hLib == 0) {
        return FALSE;
    }
    HRESULT (STDAPICALLTYPE *pDllRegisterServer)();
    (FARPROC&)pDllRegisterServer = ::GetProcAddress(hLib, _T("DllRegisterServer"));
    if(pDllRegisterServer == NULL) {
        ::FreeLibrary(hLib);
        return FALSE;
    }
    if(FAILED(pDllRegisterServer ())) {
        ::FreeLibrary(hLib);
        return FALSE;
    } else {
        ::FreeLibrary(hLib);
        return TRUE;
    }
}

BOOL unregcom(LPCWSTR strLib)
{
    HMODULE hLib = ::LoadLibrary(strLib);
    if(hLib == 0) {
        return FALSE;
    }
    HRESULT (STDAPICALLTYPE *pDllUnregisterServer)();
    (FARPROC&)pDllUnregisterServer = ::GetProcAddress(hLib, _T("DllUnregisterServer"));
    if(pDllUnregisterServer == NULL) {
        ::FreeLibrary(hLib);
        return FALSE;
    }
    if(FAILED(pDllUnregisterServer())) {
        ::FreeLibrary(hLib);
        return FALSE;
    } else {
        ::FreeLibrary(hLib);
        return TRUE;
    }
}

井泉 2007-11-20 08:48 发表评论

(�?Rapi 使用

井泉 — Tue, 20 Nov 2007 00:46:00 GMT

void CopyFilePCtoWinCE(CString strFileNamePC, CString strFileNamePPC)
{
    CFile oldFile;
    oldFile.Open(strFileNamePC, CFile::modeRead |CFile::typeBinary);
    int iLen = oldFile.GetLength();
    iLen = iLen / BUFFER_SIZE;
    BSTR bstr = strFileNamePPC.AllocSysString();
    SysFreeString(bstr);
    CeRapiInit();
    HANDLE h = CeCreateFile(bstr, GENERIC_READ | GENERIC_WRITE, 0, NULL,
        OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    char cTemp[BUFFER_SIZE];
    DWORD nbytes;
    int iTotBytes = 0;
    int iReaded=0;
    while((iReaded=oldFile.Read(&cTemp, BUFFER_SIZE)) >= 1)
        CeWriteFile(h, &cTemp, (DWORD)iReaded, &nbytes, NULL);
    CeCloseHandle(h);
    oldFile.Close();
    CeRapiUninit();
}

void CopyFileWinCEtoPC(CString strFileNamePPC, CString strFileNamePC)
{
    BSTR bstr = strFileNamePPC.AllocSysString();
    SysFreeString(bstr);
    CeRapiInit();

    HANDLE h;
    h = CeCreateFile(bstr, GENERIC_READ, FILE_SHARE_READ, NULL,
        OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

    CFile oldFile;
    oldFile.Open(strFileNamePC, CFile::modeCreate | CFile::modeWrite);

    char cTemp[BUFFER_SIZE];
    DWORD nbytes;
    CString s;

    while(CeReadFile(h, &cTemp, (DWORD)BUFFER_SIZE, &nbytes, NULL) == TRUE)
    {
        oldFile.Write(&cTemp, nbytes);
        if(nbytes < BUFFER_SIZE)
            break;
    }
    CeCloseHandle(h);
    oldFile.Close();
    CeRapiUninit();
}

BOOL DeleteFileFromCE(CString strFileNamePPC)
{
    BSTR bstr = strFileNamePPC.AllocSysString();
    SysFreeString(bstr);
    CeRapiInit();
    BOOL bRet = CeDeleteFile(bstr);
    CeRapiUninit();
    return bRet;
}

井泉 2007-11-20 08:46 发表评论

函数�Ҏ��

井泉 — Mon, 19 Nov 2007 02:25:00 GMT

用_t替换字符'w',比如 wcsncpy to _tcsncpy(自适应函数).

_tcsncpy_l 后缀 _l 不推荐��用的函数

_tcsncpy_s 后缀 _s Security Enhancements in the CRT

_tcsncpy_s_l 后缀 _s_l �?_s

security enhancements

宽字�W�处理函数函��C��普通函数对照表


字符分类�Q?nbsp;    宽字�W�函数普通C函数描述
iswalnum�Q�）     isalnum�Q�） ��试字符是否为数字或字母
iswalpha�Q�）     isalpha�Q�） ��试字符是否是字�?nbsp;
iswcntrl�Q�）     iscntrl�Q�） ��试字符是否是控制符
iswdigit�Q�）     isdigit�Q�） ��试字符是否为数�?nbsp;
iswgraph�Q�）     isgraph�Q�） ��试字符是否是可见字�W?nbsp;
iswlower�Q�）     islower�Q�） ��试字符是否是小写字�W?nbsp;
iswprint�Q�）     isprint�Q�） ��试字符是否是可打印字符
iswpunct�Q�）     ispunct�Q�） ��试字符是否是标点符�?nbsp;
iswspace�Q�）     isspace�Q�） ��试字符是否是空白符�?nbsp;
iswupper�Q�）     isupper�Q�） ��试字符是否是大写字�W?nbsp;
iswxdigit�Q�）     isxdigit�Q�）��试字符是否是十六进制的数字

大小写�{换：
宽字�W�函�?nbsp;   普通C函数描述
towlower�Q�）     tolower�Q�）把字�W��{换�ؓ��写
towupper�Q�）     toupper�Q�）把字�W��{换�ؓ大写

字符比较�Q?nbsp;    宽字�W�函数普通C函数描述
wcscoll�Q�）     strcoll�Q�）比较字符�?nbsp;

日期和时间�{换：
宽字�W�函数描�q?nbsp;
strftime�Q�）     �Ҏ��指定的字�W�串格式和locale讄��格式化日期和旉��
wcsftime�Q�）     �Ҏ��指定的字�W�串格式和locale讄��格式化日期和旉��Q?nbsp;�q�返回宽字符�?nbsp;
strptime�Q�）     �Ҏ��指定格式把字�W�串转换为时间��|�� 是strftime的反�q�程

打印和扫描字�W�串�Q?nbsp;
宽字�W�函数描�q?nbsp;
fprintf�Q�）/fwprintf�Q�）     使用vararg参量的格式化输出
fscanf�Q�）/fwscanf�Q�）         格式化读�?nbsp;
printf�Q�）             使用vararg参量的格式化输出到标准输�?nbsp;
scanf�Q�）             从标准输入的格式化读�?nbsp;
sprintf�Q�）/swprintf�Q�）     �Ҏ��vararg参量表格式化成字�W�串
sscanf�Q�）             以字�W�串作格式化��d��
vfprintf�Q�）/vfwprintf�Q�）     使用stdarg参量表格式化输出到文�?nbsp;
vprintf�Q�）             使用stdarg参量表格式化输出到标准输�?nbsp;
vsprintf�Q�）/vswprintf�Q�）     格式化stdarg参量表�ƈ写到字符�?nbsp;

数字转换�Q?nbsp;
宽字�W�函�?nbsp;   普通C函数描述
wcstod�Q�）     strtod�Q�）  把宽字符的初始部分�{换�ؓ双精度��Q�Ҏ��
wcstol�Q�）     strtol�Q�）  把宽字符的初始部分�{换�ؓ长整�?nbsp;
wcstoul�Q�）     strtoul�Q�）把宽字符的初始部分�{换�ؓ无符号长整数

多字节字�W�和宽字�W��{换及操作�Q?nbsp;
宽字�W�函数描�q?nbsp;
mblen�Q�）         �Ҏ��locale的设�|�确定字�W�的字节�?nbsp;
mbstowcs�Q�）         把多字节字符串�{换�ؓ宽字�W�串
mbtowc�Q�）/btowc�Q�）    把多字节字符转换为宽字符
wcstombs�Q�）         把宽字符串�{换�ؓ多字节字�W�串
wctomb�Q�）/wctob�Q�）     把宽字符转换为多字节字符

输入和输出：
宽字�W�函�?nbsp;   普通C函数描述
fgetwc�Q�）     fgetc�Q�）     从流中读入一个字�W��ƈ转换为宽字符
fgetws�Q�）     fgets�Q�）     从流中读入一个字�W�串�q��{换�ؓ宽字�W�串
fputwc�Q�）     fputc�Q�）     把宽字符转换为多字节字符�q�且输出到标准输�?nbsp;
fputws�Q�）     fputs�Q�）     把宽字符串�{换�ؓ多字节字�W��ƈ且输出到标准输出�?nbsp;
getwc�Q�）     getc�Q�）     从标准输入中��d��字符�Q?nbsp;�q�且转换为宽字符
getwchar�Q�）     getchar�Q�）     从标准输入中��d��字符�Q?nbsp;�q�且转换为宽字符
None         gets�Q�）     使用fgetws�Q�）
putwc�Q�）     putc�Q�）     把宽字符转换成多字节字符�q�且写到标准输出
putwchar�Q�）     putchar�Q�）     把宽字符转换成多字节字符�q�且写到标准输出
None         puts�Q�）     使用fputws�Q�）
ungetwc�Q�）     ungetc�Q�）     把一个宽字符攑֛�到输入流�?nbsp;

字符串操作：
宽字�W�函�?nbsp;       普通C函数描述
wcscat�Q�）         strcat�Q�）     把一个字�W�串接到另一个字�W�串的尾�?nbsp;
wcsncat�Q�）         strncat�Q�）     �c�M��于wcscat�Q�）�Q?nbsp;而且指定�_�接字符串的�_�接长度.
wcschr�Q�）         strchr�Q�）     查找子字�W�串的第一个位�|?nbsp;
wcsrchr�Q�）         strrchr�Q�）     从尾部开始查扑֭�字符串出现的�W�一个位�|?nbsp;
wcspbrk�Q�）         strpbrk�Q�）     从一字符字符串中查找另一字符串中��M��一个字�W�第一�ơ出现的位置
wcswcs�Q�）/wcsstr�Q�）     strchr�Q�）     在一字符串中查找另一字符串第一�ơ出现的位置
wcscspn�Q�）         strcspn�Q�）     �q�回不包含第二个字符串的的初始数�?nbsp;
wcsspn�Q�）         strspn�Q�）     �q�回包含�W�二个字�W�串的初始数�?nbsp;
wcscpy�Q�）         strcpy�Q�）     拯��字符�?nbsp;
wcsncpy�Q�）         strncpy�Q�）     �c�M��于wcscpy�Q�）�Q?nbsp;同时指定拯��的数�?nbsp;
wcscmp�Q�）         strcmp�Q�）     比较两个宽字�W�串
wcsncmp�Q�）         strncmp�Q�）     �c�M��于wcscmp�Q�）�Q?nbsp;�q�要指定比较字符字符串的数目
wcslen�Q�）         strlen�Q�）     获得宽字�W�串的数�?nbsp;
wcstok�Q�）         strtok�Q�）     �Ҏ��标示�W�把宽字�W�串分解成一�p�d��字符�?nbsp;
wcswidth�Q�）         None         获得宽字�W�串的宽�?nbsp;
wcwidth�Q�）         None         获得宽字�W�的宽度

另外�q�有对应于memory操作�?nbsp;wmemcpy�Q�）�Q?nbsp;wmemchr�Q�）�Q?nbsp;wmemcmp�Q�）�Q?nbsp;wmemmove�Q�）�Q?nbsp;wmemset�Q�）�Q?/span>

井泉 2007-11-19 10:25 发表评论

IBasicVideo::GetCurrentImage 抓图

井泉 — Mon, 19 Nov 2007 00:40:00 GMT

http://www.geekpage.jp/en/programming/directshow/getcurrentimage.php

#include 
#include 
// change here
#define	FILENAME L"C:\\DXSDK\\Samples\\Media\\butterfly.mpg"
// note that this sample fails on some environment
int
main()
{
IGraphBuilder *pGraphBuilder;
IMediaControl *pMediaControl;
IBasicVideo *pBasicVideo;
CoInitialize(NULL);
CoCreateInstance(CLSID_FilterGraph,
NULL,
CLSCTX_INPROC,
IID_IGraphBuilder,
(LPVOID *)&pGraphBuilder);
pGraphBuilder->QueryInterface(IID_IMediaControl,
(LPVOID *)&pMediaControl);
pMediaControl->RenderFile(FILENAME);

pGraphBuilder->QueryInterface(IID_IBasicVideo,
(LPVOID *)&pBasicVideo);

pMediaControl->Run();
// The image will be saved when OK is clicked
MessageBox(NULL,
"Grab Image",
"Grab",
MB_OK);

// Must Pause before using GetCurrentImage
pMediaControl->Pause();
// get width and height
long height, width;
pBasicVideo->get_VideoHeight(&height);
pBasicVideo->get_VideoWidth(&width);
long bufSize;
long *imgData;
HRESULT hr;
/*
The second value is NULL to resolve required buffer size.
The required buffer size will be returned in variable "bufSize".
*/
hr = pBasicVideo->GetCurrentImage(&bufSize, NULL);
if (FAILED(hr)) {
printf("GetCurrentImage failed\n");
return 1;
}
if (bufSize < 1) {
printf("failed to get data size\n");
return 1;
}
imgData = (long *)malloc(bufSize);
// The data will be in DIB format
pBasicVideo->GetCurrentImage(&bufSize, imgData);

// save DIB file as Bitmap.
// This sample saves image as bitmap to help
// understanding the sample.
HANDLE fh;
BITMAPFILEHEADER bmphdr;
BITMAPINFOHEADER bmpinfo;
DWORD nWritten;
memset(&bmphdr, 0, sizeof(bmphdr));
memset(&bmpinfo, 0, sizeof(bmpinfo));
bmphdr.bfType = ('M' << 8) | 'B';
bmphdr.bfSize = sizeof(bmphdr) + sizeof(bmpinfo) + bufSize;
bmphdr.bfOffBits = sizeof(bmphdr) + sizeof(bmpinfo);
bmpinfo.biSize = sizeof(bmpinfo);
bmpinfo.biWidth = width;
bmpinfo.biHeight = height;
bmpinfo.biPlanes = 1;
bmpinfo.biBitCount = 32;
fh = CreateFile("result.bmp",
GENERIC_WRITE, 0, NULL,
CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
WriteFile(fh, &bmphdr, sizeof(bmphdr), &nWritten, NULL);
WriteFile(fh, &bmpinfo, sizeof(bmpinfo), &nWritten, NULL);
WriteFile(fh, imgData, bufSize, &nWritten, NULL);
CloseHandle(fh);

free(imgData);
// Release resource
pBasicVideo->Release();

pMediaControl->Release();
pGraphBuilder->Release();
CoUninitialize();
return 0;
}

井泉 2007-11-19 08:40 发表评论

井泉 — Fri, 01 Dec 2006 00:52:00 GMT

对于普通类型的对象来说�Q�它们之间的复制是很��单的�Q�例如：

int a=100;
int b=a;

　　而类对象与普通对象不同，�c�d��象内部结构一般较为复杂，存在各种成员变量。下面看一个类对象拯��的简单例子�?

#include
using namespace std;
class CA
{
　public:
　　CA(int b)
　　{
　　　a=b;
　　}
　　void Show ()
　　{
　　　cout<　　}
　private:
　　int a;
};

int main()
{
　CA A(100);
　CA B=A;
　B.Show ();
　return 0;
}

　　�q�行�E�序�Q�屏�q�输�?00。从以上代码的运行结果可以看出，�pȝ��为对象B分配了内存�ƈ完成了与对象A的复制过�E�。就�c�d��象而言�Q�相同类型的�c�d��象是通过拯��构造函数来完成整个复制�q�程的。下面我们�D例说明拷贝构造函数的工作�q�程�?br />

#include
using namespace std;
class CA
{
　public:
　　CA(int b)
　　{
　　　a=b;
　　}
　　CA(const CA& C)
　　{
　　　a=C.a;
　　}
　　void Show()
　　{
　　　cout<　　}
　private:
　　int a;
};

int main()
{
　CA A(100);
　CA B=A;
　B.Show ();
　return 0;
}

　　CA(const CA& C)��是我们自定义的拯��构造函数。可见，拯��构造函数是一�U�特�D�的构造函敎ͼ�函数的名�U�必��d��c�d��U�C��_��它的唯一的一个参数是本类型的一个引用变量，该参数是const�c�d��Q�不可变的。例如：�c�X的拷贝构造函数的形式为X(X& x)�?br />
　　当用一个已初始化过了的自定义类�c�d��对象��d��始化另一个新构造的对象的时候，拯��构造函数就会被自动调用。也��是��_��当类的对象需要拷贝时�Q�拷贝构造函数将会被调用。以下情况都会调用拷贝构造函敎ͼ�

　　一个对象以��g��递的方式传入函数�?

　　一个对象以��g��递的方式从函数返�?

　　一个对象需要通过另外一个对象进行初始化�?

　　如果在类中没有显式地声明一个拷贝构造函敎ͼ�那么�Q�编译器��会自动生成一个默认的拯��构造函敎ͼ�该构造函数完成对象之间的位拷贝。位拯��又称��拷贝，后面��进行说明�?

　　自定义拷贝构造函数是一�U�良好的�~�程风格�Q�它可以��L��~�译器�Ş成默认的拯��构造函敎ͼ�提高源码效率�?br />
　　��拷贝和深拷�?/b>

　　在某些状况下�Q�类内成员变量需要动态开辟堆内存�Q�如果实行位拯��Q�也��是把对象里的值完全复制给另一个对象，如A=B。这�Ӟ��如果B中有一个成员变量指针已�l�申请了内存�Q�那A中的那个成员变量也指向同一块内存。这��出��C��问题�Q�当B把内存释放了�Q�如�Q�析构）�Q�这时A内的指针��是野指针了�Q�出现运行错误�?br />
　　深拷贝和��拷贝可以简单理解�ؓ�Q�如果一个类拥有资源�Q�当�q�个�cȝ��对象发生复制�q�程的时候，资源重新分配�Q�这个过�E�就是深拯��Q�反之，没有重新分配资源�Q�就是浅拯��。下面�D个深拯��的例子�?

#include
using namespace std;
class CA
{
　public:
　　CA(int b,char* cstr)
　　{
　　　a=b;
　　　str=new char[b];
　　　strcpy(str,cstr);
　　}
　　CA(const CA& C)
　　{
　　　a=C.a;
　　　str=new char[a]; //深拷�?br />　　　if(str!=0)
　　　　strcpy(str,C.str);
　　}
　　void Show()
　　{
　　　cout<　　}
　　~CA()
　　{
　　　delete str;
　　}
　private:
　　int a;
　　char *str;
};

int main()
{
　CA A(10,"Hello!");
　CA B=A;
　B.Show();
　return 0;
}

　　好吧�Q�就说这些，希望本文能对您有所帮助�?img src ="http://m.shnenglu.com/zjj2816/aggbug/15831.html" width = "1" height = "1" />

井泉 2006-12-01 08:52 发表评论

井泉 — Wed, 05 Jul 2006 01:59:00 GMT
在用C++写要导出�cȝ��库时�Q�我们经常只��x��露接口，而隐藏类的实现细节。也��是说我们提供的头文仉��只提供要暴露的公共成员函数的声明�Q�类的其他所有信息都不会在这个头文�g里面昄��出来。这个时候就要用到接口与实现分离的技术�?br />
　　下面用一个最��单的例子来说明�?br />
　　�c�ClxExp是我们要导出的类�Q�其中有一个私有成员变量是ClxTest�cȝ��对象�Q�各个文件内容如下：

　　lxTest.h文�g内容�Q?br />
class ClxTest
{
　public:
　　ClxTest();
　　virtual ~ClxTest();
　　void DoSomething();
};

　　lxTest.cpp文�g内容�Q?br />
#include "lxTest.h"

#include
using namespace std;

ClxTest::ClxTest()
{}

ClxTest::~ClxTest()
{}

void ClxTest::DoSomething()
{
　cout << "Do something in class ClxTest!" << endl;
}

////////////////////////////////////////////////////////////////////////////

　　lxExp.h文�g内容�Q?br />
#include "lxTest.h"

class ClxExp
{
　public:
　　ClxExp();
　　virtual ~ClxExp();
　　void DoSomething();
　private:
　　ClxTest m_lxTest;
　　void lxTest();
};

　　lxExp.cpp文�g内容�Q?br />
#include "lxExp.h"

ClxExp::ClxExp()
{}

ClxExp::~ClxExp()
{}

// 其实该方法在�q�里�q�没有必要，我这样只是�ؓ了说明调用关�p?br />void ClxExp::lxTest()
{
　m_lxTest.DoSomething();
}

void ClxExp::DoSomething()
{
　lxTest();
}

　　��Z��让用戯��使用我们的类ClxExp�Q�我们必��L��供lxExp.h文�g�Q�这��L��ClxExp的私有成员也暴露�l�用户了。而且�Q�仅仅提供lxExp.h文�g是不够的�Q�因为lxExp.h文�ginclude了lxTest.h文�g�Q�在�q�种情况下，我们�q�要提供lxTest.h文�g。那样ClxExp�cȝ��实现�l�节��全暴露�l�用户了。另外，当我们对�c�ClxTest做了修改�Q�如��d��或删除一些成员变量或�Ҏ��Q�时�Q�我们还要给用户更新lxTest.h文�g�Q�而这个文件是跟接口无关的。如果类ClxExp里面有很多像m_lxTest那样的对象的话，我们��p��l�用��h��供N个像lxTest.h那样的头文�g�Q�而且其中��M��一个类有改动，我们都要�l�用��h��新头文�g。还有一点就是用户在�q�种情况下必��进行重新编译！

　　上面是非常小的一个例子，重新�~�译的时间可以忽略不计。但是，如果�c�ClxExp被用户大量��用的话，那么在一个大��目中，重新�~�译的时候我们就有时间可以去喝杯咖啡什么的了。当然上面的�U�种情况不是我们想看到的�Q�你也可以想像一下用户在自己�E�序不用改动的情况下要不停的更新头文件和�~�译�Ӟ��他们心里会骂些什么。其实对用户来说�Q�他们只兛_��c�ClxExp的接口DoSomething()�Ҏ��。那我们怎么才能只暴露类ClxExp的DoSomething()�Ҏ��而不又��生上面所说的那些问题呢？�{�案��是�Q�－接口与实现的分离。我可以让类ClxExp定义接口�Q�而把实现攑֜�另外一个类里面。下面是具体的方法：

　　首先�Q�添加一个实现类ClxImplement来实现ClxExp的所有功能。注意：�c�ClxImplement有着跟类ClxExp一��L��公有成员函数�Q�因��Z��们的接口要完全一致�?br />
　　lxImplement.h文�g内容�Q?br />
#include "lxTest.h"

class ClxImplement
{
　public:
　　ClxImplement();
　　virtual ~ClxImplement();

　　void DoSomething();
　
　private:
　　ClxTest m_lxTest;
　　void lxTest();
};

　　lxImplement.cpp文�g内容�Q?br />
#include "lxImplement.h"

ClxImplement::ClxImplement()
{}

ClxImplement::~ClxImplement()
{}

void ClxImplement::lxTest()
{
　m_lxTest.DoSomething();
}

void ClxImplement::DoSomething()
{
　lxTest();
}

　　然后�Q�修改类ClxExp�?br />
　　修改后的lxExp.h文�g内容�Q?br />
// 前置声明
class ClxImplement;

class ClxExp
{
　public:
　　ClxExp();
　　virtual ~ClxExp();
　　void DoSomething();
　private:
　　// 声明一个类ClxImplement的指针，不需要知道类ClxImplement的定�?br />　　ClxImplement *m_pImpl;
};

　　修改后的lxExp.cpp文�g内容�Q?br />
// 在这里包含类ClxImplement的定义头文�g
#include "lxImplement.h"

ClxExp::ClxExp()
{
　m_pImpl = new ClxImplement;
}

ClxExp::~ClxExp()
{
　delete m_pImpl;
}

void ClxExp::DoSomething()
{
　m_pImpl->DoSomething();
}

　　通过上面的方法就实现了类ClxExp的接口与实现的分��R��请注意两个文�g中的注释。类ClxExp里面声明的只是接口而已�Q�而真正的实现�l�节被隐藏到了类ClxImplement里面。�ؓ了能在类ClxExp中��用类ClxImplement而不include头文件lxImplement.h�Q�就必须有前�|�声明class ClxImplement�Q�而且只能使用指向�c�ClxImplement对象的指针，否则��׃��能通过�~�译�?br />
　　在发布库文�g的时候，我们只需�l�用��h��供一个头文�glxExp.h��p��了，不会暴露�c�ClxExp的�Q何实现细节。而且我们对类ClxTest的�Q何改动，都不需要再�l�用��h��新头文�g�Q�当�Ӟ��库文件是要更新的�Q�但是这�U�情况下用户也不用重新编译！�Q�。这样做�q�有一个好处就是，可以在分析阶�D는��pȝ��分析员或者高�U�程序员来先把类的接口定义好�Q�甚臛_��以把接口代码写好�Q�例如上面修改后的lxExp.h文�g和lxExp.cpp文�g�Q�，而把�cȝ��具体实现交给其他�E�序员开发�?

井泉 2006-07-05 09:59 发表评论

C++ Primer��M��W�记

井泉 — Thu, 29 Jun 2006 07:11:00 GMT
前些日子开始看《C++ Primer》，��Z��做一些笔讎ͼ�既有书上的，也有自己理解的�?br />因�ؓ刚学C++不久�Q�笔下难免有谬误之处�Q�行文更是凌乱；
所�q怸�是用来显配的东西�Q�发在linuxsir只是��Z��方便自己阅读记忆�Q�以防只��上�|�忘了正事�?br />书看了不��C��半，所以大�U�才写了一半，慢慢补充�?br />=========================================

==========================================
转蝲务必注明原作�?br />neplusultra 2005.2.3
==========================================

const要注意的问题
　　1、下面是一个几乎所有�h刚开始都会搞错的问题�Q?br />已知�Q�typedef char *cstring;
在以下声明中�Q�cstr的类型是什么？
extern const cstring cstr;

错误�{�案�Q�const char *cstr;
正确�{�案�Q�char *const cstr;

　　错误在于��typedef当作宏扩展。const 修饰cstr的类型。cstr是一个指针，因此�Q�这个定义声明了cstr是一个指向字�W�的const指针�?br />　　2、指针是const�q�是data为const�Q?br />辨别�Ҏ��很简单，如下�Q?br />
代码:
char *p="hello"; //non-const pointer, non-const data; const char *p="hello"; // non-const pointer, const data; char * const p="hello"; // const pointer , non-const data; const char * const p="hello"; // const pointer, const data;
　　要注意的是，"hello"的类型是const char * �Q�按C++standard规则�Q�char *p="hello" 是非法的(叛_��的const char* 不能转换为左式的char *)�Q�违反了帔R��性。但是这�U�行为在C中实在太频繁�Q�因此C++standard对于�q�种初始化动作给予豁免。尽��如此，�q�是��量避免�q�种用法�?br />　　3、const初始化的一些问�?br />const 对象必须被初始化�Q?br />
代码:
const int *pi=new int; // 错误�Q�没有初始化 const int *pi=new int(100); //正确 const int *pci=new const int[100]; //�~�译错误�Q�无法初始化用new表达式创建的内置�c�d��数组元素�?/div>

什么时候需要copy constructor,copy assignment operator,destructor
　　注意�Q�若class需要三者之一�Q�那么它往往需要三者�?br />当class的copy constructor内分配有一块指向hcap的内存，需要由destructor释放�Q�那么它也往往需要三者�?br />
��Z��么需要protected 讉K��U�别
　　有�h认�ؓ�Q�protected讉K��U�别允许�z��cȝ��接访问基�c�L��员，�q�破坏了��装的概念，因此所有基�cȝ��实现�l�节都应该是private的；另外一些�h认�ؓ�Q�如果派生类不能直接讉K��基类的成员，那么�z��cȝ��实现��无法有��_��的效率供用户使用�Q�如果没有protected�Q�类的设计者将被迫把基�c�L��员设�|��ؓpublic�?br />　　事实上，protected正是在高�U�度的封装与效率之间做出的一个良好折��h��案�?br />
��Z��么需要virtual member function又不能滥用virtual
　　若基�c�设计者把本应设计成virtual的成员函数设计成非virtual�Q�则�l�承�c�d��无法实现改写(overridden)�Q�给�l�承�cȝ��实现带来不便�Q?br />　　另一斚w��Q�一旦成员函数被设计成virtual�Q�则该类的对象将额外增加虚拟指针�Q�vptr�Q�和虚拟表格�Q�vtbl�Q�，所以倘若��Z��方便�l�承�c�overridden的目的而��所有成员函数都为virtual�Q�可能会影响效率�Q�因为每个virtual成员函数都需付出动态分�z��成本。而且virtual成员函数不能内联�Q�inline�Q�，我们知道�Q�内联发生在�~�译时刻�Q�而虚拟函数在�q�行时刻才处理。对于那些小巧而被频繁调用、与�c�d��无关的函敎ͼ�昄��不应该被讄��成virtual�?br />
关于引用的一些注意点
　　1、把函数参数声明为数�l�的引用�Q�当函数参数是一个数�l�类型的引用�Ӟ��数组长度成�ؓ参数和实参类型的一部分�Q�编译器��查数�l�实参的长度和与在函数参数类型中指定的长度是否匹配�?br />
代码:
//参数�?0个int数组 void showarr(int (&arr)[10]); void func() { int i,j[2],k[10]; showarr(i); //错误�Q�实参必��L��10个int的数�l? showarr(j); //错误�Q�实参必��L��10个int的数�l? showarr(k); //正确�Q? } //更灵�zȝ��实现�Q�借助函数模板。下面是一个显�C�数�l�内容的函数�? template void printarr(const Type (& r_array)[size]) { for(int i=0;i
　　2�?br />　　3�?br />
goto语句的一些要注意的地�?/font>
　　1、label语句只能用作goto的目标，且label语句只能用冒��L��束，且label语句后面不能紧接双��括号'}'�Q�如
代码:
label8: }
　　办法是在冒号后面加一个空语句�Q�一�?;'卛_��Q�，�?br />
代码:
label7: ;}
　　 2、goto语句不能向前跌��如下声明语句�Q?br />
代码:
goto label6; int x=1; //错误�Q�不能蟩�q�该声明�Q? cout<
但是�Q�把int x=1; 改�ؓint x; 则正��了。另外一�U�方法是�Q?br />
代码:
goto label6; { int x=1; //正确�Q��用了语句�? cout<
　　3、goto语句可以向后�Q�向�E�序开头的方向�Q�蟩�q�声明定义语句�?br />
代码:
begin: int i=22; cout<< i <

变量作用�?/font>
　　1、花括号可以用来指明局部作用域�?br />　　2、在for、if、switch、while语句的条�?循环条�g中可以声明变量，该变量仅在相应语句块内有效�?br />　　3、extern为声明但不定义一个对象提供了一�U�方法；它类��g��函数声明�Q�指明该对象会在其他地方被定义：或者在此文本的其他地方�Q�或者在�E�序的其他文本文件中。例如extern int i; 表示在其他地方存在声�?int i;
　　extern 声明不会引�v内存分配�Q�他可以在同一个文件或同一个程序中出现多次。因此在全局作用域中�Q�以下语句是正确的：
代码:
extern int c; int c=1; //没错 extern int c; //没错
　　但是�Q�extern声明若指定了一个显式初始值的全局对象�Q�将被视为对该对象的定义�Q�编译器��ؓ其分配存储区�Q�对该对象的后箋定义��出错。如下：
代码:
extern int i=1; int i=2; //出错�Q�重复定�?/div>

auto_ptr若干注意�?/font>
　　1、auto_ptr的主要目的是支持普通指针类型相同的语法�Q��ƈ为auto_ptr所指对象的释放提供自动��理�Q�而且auto_ptr的安全性几乎不会带来额外的代�h�Q�因为其操作支持都是内联的）。定义�Ş式有三种�Q?br />
代码:
auto_ptridentifier(ptr_allocated_by_new); auto_ptridentifier(auto_ptr_of_same_type); auto_ptridentifier;
　　2、所有权概念。auto_ptr_p1=auto_ptr_p2的后果是�Q�auto_ptr_p2丧失了其原指向对象的所有权�Q��ƈ且auto_ptr_p2.get()==0。不要让两个auto_ptr对象拥有�I�闲存储区内同一对象的所有权。注意以下两�U�种初始化方式的区别�Q?br />
代码:
auto_ptrauto_ptr_str1(auto_ptr_str2.get()); //注意�Q�用str2指针初始化str1, 两者同时拥有所有权�Q�后果未定义�? auto_ptrauto_ptr_str1(auto_ptr_str2.release());//OK�Q�str2释放了所有权�?

　　3、不能用一个指向“内存不是通过应用new表达式分配的”指针来初始化或者赋值auto_ptr。如果这样做了，delete表达式会被应用在不是动态分配的指针上，�q�将��D��未定义的�E�序行�ؓ�?br />
C风格字符串结��字符问题
代码:
char *str="hello world!"; //str末尾自动加上一个结��字符�Q�但strlen不计该空字符�? char *str2=new char[strlen(str)+1] // +1用来存放�l�尾�I�字�W��?/div>

定位new表达�?/font>
　　头文�Ӟ��
　　形式�Q�new (place_address) type-specifier
　　该语句可以允许程序员��对象创建在已经分配好的内存中，允许�E�序员预分配大量的内存供以后通过�q�种形式的new表达式创建对象。其中place_address必须是一个指针。例如：
代码:
char *buf=new char[sizeof(myclass-type)*16]; myclass-type *pb=new (buf) myclass-type; //使用预分配空间来创徏对象 // ... delete [] buf; // 无须 delete pb�?/div>

名字�I�间namespace

　　1、namespace的定义可以是不连�l�的�Q�即namespace的定义是可以�U�篏的）�Q�即�Q�同一个namespace可以在不同的文�g中定义，分散在不同文件中的同一个namespace中的内容彼此可见。这对生成一个库很有帮助�Q�可以��我们更容易将库的源代码组�l�成接口和实现部分。如�Q�在头文�Ӟ��.h文�g�Q�的名字�I�间部分定义库接口；在实现文�Ӟ��?c�?cpp文�g�Q�的名字�I�间部分定义库实现。名字空间定义可�U�篏的特性是“向用户隐藏实现�l�节”必需的，它允许把不同的实现文�Ӟ��?c�?cpp文�g�Q�编译链接到一个程序中�Q�而不会有�~�译错误和链接错误�?br />　　2、全局名字�I�间成员�Q�可以用�?:member_name”的方式引用。当全局名字�I�间的成员被嵌套的局部域中声明的名字隐藏�Ӟ��可以采用这�U�方法引用全局名字�I�间成员�?br />　　3、名字空间成员可以被定义在名字空间之外。但是，只有包围该成员声明的名字�I�间�Q�也��是该成员声明所在的名字�I�间及其外围名字�I�间�Q�才可以包含它的定义�?br />　　��其要注意的�?include语句的次序。假定名字空间成员mynamespace::member_i的声明在文�gdec.h中，�?include "dec.h"语句�|�于全局名字�I�间�Q�那么在include语句之后定义的其他名字空间内�Q�mynamespace::member_i的声明均可见。即�Q�mynamespace::member_i可以�?include "dec.h"之后的�Q何地方�Q何名字空间内定义�?br />　　4、未命名的名字空间。我们可以用未命名的名字�I�间声明一个局部于某一文�g的实体。未命名的名字空间可以namespace开��_��其后不需名字�Q�而用一对花括号包含名字�I�间声明块。如�Q?br />
代码:
//　其他代码�? namespace { void mesg() { cout<<"**********\n"; } } int main() { mesg();　//正确　　　　//... return 0; }
　　�׃��未命名名字空间的成员是程序实体，所以mesg()可以在程序整个执行期间被调用。但是，未命名名字空间成员只在特定的文�g中可见，在构成程序的其他文�g中是不可以见的。未命名名字�I�间的成员与被声明�ؓstatic的全局实体��h��c�M��的特性。在�Q�中�Q�被声明为static的全局实体在声明它的文件之外是不可见的�?br />
using关键�?/font>
　　1、using声明与using指示�W�：前者是声明某名字空间内的一个成员，后者是使用整个名字�I�间。例如：
代码:
using cpp_primer::matrix; // ok,using声明 using namespace cpp_primer; //ok,using指示�W?/div>
　　2�?该using指示�W�语句可以加在程序文件的几乎��M��地方�Q�包括文件开��_��#include语句之前�Q�、函数内部。不�q�用using指定的名字空间作用域�Q�生命周期）受using语句所在位�|�的生命周期�U�束。如�Q�函数内部��用“using namespace myspacename;”则 myspacename仅在该函数内部可见�?br />　　3、可以用using语句指定多个名字�I�间�Q��得多个名字空间同时可见。但�q�增加了名字污染的可能性，而且只有�?font color="blue">使用各名字空间相同成员时由多个using指示�W�引��L��二义性错误才能被��到�Q�这��给�E�序的检��、扩展、移植带来很大的隐患。因此，因该��量使用using声明而不是滥用using指示�W��?br />
重蝲函数
　　1、如果两个函数的参数表中参数的个数或者类型不同，则认��两个函数是重载的�?br />　　如果两个函数的返回类型和参数表精��匹配，则第二个声明被视为第一个的重复声明�Q�与参数名无兟뀂如 void print(string& str)与void print(string&)是一��L��?br />　　如果两个函数的参数表相同�Q�但是返回类型不同，则第二个声明被视为第一个的错误重复声明�Q�会标记为编译错误�?br />　　如果在两个函数的参数表中�Q�只有缺省实参不同，则第二个声明被视为第一个的重复声明。如int max(int *ia,int sz)与int max(int *, int=10)�?br />　　参数名类型如果是由typedef提供的，�q�不��作新类型，而应该当作typedef的原�c�d��?br />　　当参数类型是const或者volatile�Ӟ��分两�U�情况：对于实参按��g��递时�Q�const、volatile修饰�W�可以忽略；对于把const、volatile应用在指针或者引用参数指向的�c�d��Ӟ��const、volatile修饰�W�对于重载函数的声明是有作用的。例如：
代码:
//OK,以下两个声明其实一�? void func(int i); void func(const int i); //Error,无法通过�~�译�Q�因为func函数被定义了两次�? void func(int i){} void func(const int i){} //OK,声明了不同的函数 void func2(int *); void func2(const int *); //OK,声明了不同的函数 void func3(int&); void func3(const int&);
　　2、链接指�C�符extern "C"只能指定重蝲函数集中的一个函数。原因与内部名编码有养I��在大多数�~�译器内部，每个函数明及其相兛_��数表都被作�ؓ一个惟一的内部名�~�码�Q�一般的做法是把参数的个数和�c�d��都进行编码，然后��其附在函数名后面。但是这�U�编码不使用于用链接指示�W�extern "C"声明的函敎ͼ��q�就是�ؓ什么在重蝲函数集合中只有一个函数可以被声明为extern "C"的原因，��h��不同的参数表的两个extern "C"的函��C��被链接编辑器视�ؓ同一函数。例如，包含以下两个声明的程序是非法的�?br />
代码:
//error:一个重载函数集中有两个extern "C"函数 extern "C" void print(const char*); extern "C" void print(int);

函数模板
　　1、定义函数模板：
代码:
template [inline/extern] ReturnType FunctionName(FuncParameters...) { 　　//definition of a funciton template... }

井泉 2006-06-29 15:11 发表评论

划分全局名字�I�间

井泉 — Thu, 29 Jun 2006 07:09:00 GMT

条款28: 划分全局名字�I�间
全局�I�间最大的问题在于它本�w�仅有一个。在大的软�g��目中，�l�常会有不少人把他们定义的名字都攑֜��q�个单一的空间中�Q�从而不可避免地��D��名字冲突。例如，假设library1.h定义了一些常量，其中包括�Q?/p>
const double lib_version = 1.204;
�c�M��的，library2.h也定义了�Q?/p>
const int lib_version = 3;
很显�Ӟ��如果某个�E�序惛_��时包含library1.h和library2.h��׃��有问题。对于这�c�问题，你除了嘴里骂几句�Q�或�l�作者发报复性邮�Ӟ��或自��q��辑头文�g来消除名字冲�H�外�Q�也没其它什么办法�?/p>
但是�Q�作为程序员�Q�你可以��力使自己写的程序库不给别�h带来�q�些问题。例如，可以预先想一些不大可能造成冲突的某�U�前�~��Q�加在每个全局�W�号前。当然得承认�Q�这��L��合�v来的标识�W�看��h��不是那么令�h舒服�?/p>
另一个比较好的方法是使用c++ namespace。namespace本质上和使用前缀的方法一��P��只不�q�避免了别�h��L��看到前缀而已。所以，不要�q�么做：
const double sdmbook_version = 2.0;      // 在这个程序库�?
                                         // 每个�W�号�?sdm"开�?br />class sdmhandle { ... };
sdmhandle& sdmgethandle();             // ��Z��么函数要�q�样声明�Q?br />                                       // 参见条款47
而要�q�么做：
namespace sdm {
const double book_version = 2.0;
class handle { ... };
handle& gethandle();
}
用户于是可以通过三种�Ҏ��来访问这一名字�I�间里的�W�号�Q�将名字�I�间中的所有符号全部引入到某一用户�I�间�Q�将部分�W�号引入到某一用户�I�间�Q�或通过修饰�W�显式地一�ơ性��用某个符��P��
void f1()
{
using namespace sdm;           // 使得sdm中的所有符号不用加
                                 // 修饰�W�就可以使用
cout << book_version;          // 解释为sdm::book_version
...
handle h = gethandle();        // handle解释为sdm::handle,
                                 // gethandle解释为sdm::gethandle
...
}
void f2()
{
using sdm::book_version;        // 使得仅book_version不用�?br />                                 // 修饰�W�就可以使用
cout << book_version;           // 解释�?br />                                  // sdm::book_version
...
handle h = gethandle();         // 错误! handle和gethandle
                                  // 都没有引入到本空�?br /> ...
}
void f3()
{
cout << sdm::book_version;      // 使得book_version
                                  // 在本语句有效
...
double d = book_version;        // 错误! book_version
                                  // 不在本空�?/p>
handle h = gethandle();         // 错误! handle和gethandle
                                  // 都没有引入到本空�?br /> ...
}
�Q�有些名字空间没有名字。这�U�没命名的名字空间一般用于限制名字空间内部元素的可见性。详见条�ƾm31。）
名字�I�间带来的最大的好处之一在于�Q�潜在的二义不会造成错误�Q�参见条��?6�Q�。所以，从多个不同的名字�I�间引入同一个符号名不会造成冲突�Q�假如确实真的从不��用这个符��L��话）。例如，除了名字�I�间sdm外，假如�q�要用到下面�q�个名字�I�间�Q?/p>
namespace acmewindowsystem {
...
typedef int handle;
...
}
只要不引用符号handle�Q��用sdm和acmewindowsystem时就不会有冲�H�。假如真的要引用�Q�可以明��地指明是哪个名字空间的handle�Q?/p>
void f()
{
using namespace sdm;                 // 引入sdm里的所有符�?br /> using namespace acmewindowsystem;    // 引入acme里的所有符�?/p>
...                                  // 自由地引用sdm
                                       // 和acme里除handle之外
                                       // 的其它符�?/p>
handle h;                            // 错误! 哪个handle?
sdm::handle h1;                      // 正确, 没有二义
acmewindowsystem::handle h2;         // 也没有二�?/p>
...
}
假如用常规的��Z��头文件的�Ҏ��来做�Q�只是简单地包含sdm.h和acme.h�Q�这��L��话，�׃��handle有多个定义，�~�译��不能通过�?/p>
名字�I�间的概念加入到c++标准的时间相对较晚，所以有些�h会认为它不太重要�Q�可有可无。但�q�种��x��是错误的�Q�因为c++标准库（参见条款49�Q�里几乎所有的东西都存在于名字�I�间std之中。这可能令你不以为然�Q�但它却以一�U�直接的方式影响��C��Q�这��是��Z��么c++提供了那些看��h��很有��的、没有扩展名的头文�g�Q�如, �{�。详�l�介�l�参见条��?9�?/p>
�׃��名字�I�间的概念引入的旉��相对较晚�Q�有些编译器可能不支持。就��是�q�样�Q�那也没理由污染全局名字�I�间�Q�因为可以用struct来近似实现namespace。可以这样做�Q�先创徏一个结构用以保存全局�W�号名，然后��这些全局�W�号名作为静态成员放入结构中�Q?/p>
// 用于模拟名字�I�间的一个结构的定义
struct sdm {
static const double book_version;
class handle { ... };
static handle& gethandle();
};
const double sdm::book_version = 2.0;      // 静态成员的定义
现在�Q�如果有人想讉K��q�些全局�W�号名，只用��单地在它们前面加上结构名作�ؓ前缀�Q?/p>
void f()
{
cout << sdm::book_version;
...
sdm::handle h = sdm::gethandle();
...
}
但是�Q�如果全局范围内实际上没有名字冲突�Q�用户就会觉得加修饰�W�麻烦而多余。幸�q�的是，�q�是有办法来让用户选择使用它们或忽略它们�?/p>
对于�c�d��名，可以用类型定义（typedef�Q�来昑ּ�地去掉空间引用。例如，假设�l�构s�Q�模拟的名字�I�间�Q�内有个�c�d��名t�Q�可以这��L��typedef来��得t成�ؓs::t的同义词�Q?/p>
typedef sdm::handle handle;
对于�l�构中的每个�Q�静态）对象x�Q�可以提供一个（全局�Q�引用x�Q��ƈ初始化�ؓs::x�Q?/p>
const double& book_version = sdm::book_version;
老实��_��如果��M��条款47�Q�你��׃��不喜�Ƣ定义一个象book_version�q�样的非局部静态对象。（你就会用条款47中所介绍的函数来取代�q�样的对象）
处理函数的方法和处理对象一��P��但要注意�Q�即使定义函数的引用是合法的�Q�但代码的维护者会更喜�Ƣ你使用函数指针�Q?/p>
sdm::handle& (* const gethandle)() =      // gethandle是指向sdm::gethandle
sdm::gethandle;                         // 的const 指针 (见条��?1)
注意gethandle是一个常指针。因��Z��当然不想让你的用户将它指向别的什么东西，而不是sdm::gethandle�Q�对不对�Q?/p>
�Q�如果真想知道怎么定义一个函数的引用�Q�看看下面：
sdm::handle& (&gethandle)() =      // gethandle是指�?br /> sdm::gethandle;                  // sdm::gethandle的引�?/p>
我个��L��做法也很好，但你可能以前从没见到�q�。除了初始化的方式外�Q�函数的引用和函数的常指针在行�ؓ上完全相同，只是函数指针更易于理解。）
有了上面的类型定义和引用�Q�那些不会遭遇全局名字冲突的用户就会��用没有修饰符的类型和对象名；相反�Q�那些有全局名字冲突的用户就会忽略类型和引用的定义，代之以带修饰�W�的�W�号名。还要注意的是，不是所有用户都想��用这�U�简写名�Q�所以要把类型定义和引用攑֜�一个单独的头文件中�Q�不要把它和�Q�模拟namespace的）�l�构的定义�؜在一赗��?/p>
struct是namespace的很好的�q�似�Q�但实际上还是相差很�q�。它在很多方面很�Ơ缺�Q�其中很明显的一�Ҏ��对运��符的处理。如果运��符被定义�ؓ�l�构的静态成员，它就只能通过函数调用来��用，而不能象常规的运��符所设计的那��P��可以通过自然的中�~�语法来��用：
// 定义一个模拟名字空间的�l�构�Q�结构内部包含widgets的类�?br />// 和函数。widgets对象支持operator+�q�行加法�q�算
struct widgets {
class widget { ... };

// 参见条款21�Q��ؓ什么返回const
static const widget operator+(const widget& lhs,
                                const widget& rhs);
...
};
// ��Z��面所�q�的widge和operator+
// 建立全局�Q�无修饰�W�的�Q�名�U?/p>
typedef widgets::widget widget;

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

widget w1, w2, sum;
sum = w1 + w2;                           // 错误! 本空间没有声�?br />                                         // 参数为widgets 的operator+
sum = widgets::operator+(w1, w2);        // 合法, 但不�?br />                                         // "自然"的语�?/p>
正因��些限�Ӟ��所以一旦编译器支持�Q�就要尽早��用真正的名字�I�间�?/p>

井泉 2006-06-29 15:09 发表评论