久久伊人精品一区二区三区,久久综合给久久狠狠97色,久久av免费天堂小草播放

nacci — Fri, 19 May 2006 01:08:00 GMT

摘要: �l�箋上一个主题直�U�上溯的消息上次说到消息被�{发到了AfxWndProc�Q��l��? LRESULT CALLBACKAfxWndProc(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam) { // … �?/ all other messages route through message map CWnd* pWnd = CW... 阅读全文

nacci 2006-05-19 09:08 发表评论

MFC漫谈�Q�四�Q�——消息的路由

nacci — Thu, 18 May 2006 09:29:00 GMT

有了消息映射表，如何利用呢？消息如何被分门别�cȝ��z�֏�出去的？

用最基本的一句话概述�Q�钩子函数�v了很大作用。故事是�q�样的，有些漫长�Q�也需要些耐心�?br />
MFC中消息分�?�c�：

1. WM_COMMAND�Q�所有的UI�l��g和加速键都会产生�q�种消息�Q�所有派生于CCmdTarget的类都有能力处理该消�?br /> 2. 标准消息�Q�除WM_COMMAND之外的WM_xx消息都是标准消息�Q�派生于CWnd的类都有能力处理该消�?br /> 3. 控�g通知消息�Q�用于子�H�口控�g向父�H�口发送的消息

在MFC的消息映��表的徏立中�Q�通过一�l�宏�Q�你��可以让自己的类先于父类处理某些Windows消息�Q�这�U�行为很像虚函数�Q�只是我们重载的内容不是虚函敎ͼ�而是消息�?/font>

推动消息的�܇

�W�一阶段 �H�口�q�程

在��生一个窗口的时候，会调用CFrameWnd::Create�Q�所有的故事也都从这里展开。下面的代码��Z��z�，��L��了不相关的代�?br />

BOOL CFrameWnd::Create(�? {
     // �?/span>
     if ( ! CreateEx(�?) {
         // �?/span>
    }
     // �?/span>
}

BOOL CWnd::CreateEx(�? {
     // �?/span>
    AfxHookWindowCreate( this );
    HWND hWnd = ::CreateWindowEx(�?;
     // �?/span>
}

void AFXAPI AfxHookWindowCreate(CWnd * pWnd) {
     // �?/span>
     if (pThreadState -> m_hHookOldCbtFilter == NULL) {
        pThreadState -> m_hHookOldCbtFilter = ::SetWindowsHookEx(WH_CBT,
        _AfxCbtFilterHook, NULL, ::GetCurrentThreadId());
         // �?/span>
    }
     // �?/span>
    pThreadState -> m_pWndInit = pWnd;
}

�q�样�Q�通过AfxHookWindowCreate�Q�在当前�U�程中安装了一个钩子，用来拦截和窗口相关的事�g�Q�每当：

1. 另一个窗口成为active�Q?br />2. 产生或摧毁一个窗�?br />3. Minimize或maximize一个窗口；
4. �U�d��或羃放一个窗口；
5. 完成一个来自系�l�菜单的命��o�Q?br />6. 从系�l�队列中取出一个消息；

�Ӟ��都会先调用_AfxCbtFilterHook�Q�接下来看看钩子函数作了什么：

LRESULT CALLBACK
_AfxCbtFilterHook( int code, WPARAM wParam, LPARAM lParam) {
     // �?/span>
    WNDPROC afxWndProc = AfxGetAfxWndProc();
    oldWndProc = (WNDPROC)SetWindowLongPtr(hWnd, GWLP_WNDPROC,(DWORD_PTR)afxWndProc);
     // �?/span>
}

WNDPROC AFXAPI AfxGetAfxWndProc() {
     // �?/span>
     return & AfxWndProc;
}

�q�样�Q�_AfxCbtFilterHook的工作�ȝ��h��是通过�H�口子类化，把新建的�H�口的窗口过�E�设�|�成AfxWndProc�?br />到这里，我们�l�于扑ֈ�了窗口过�E��?br />
�l�论
CFrameWnd::Create创徏�H�口调用CWnd::CreateEx
CWnd::CreateEx调用AfxHookWindowCreate准备为窗口设�|�钩�?br />AfxHookWindowCreate调用::SetWindowHookEx为窗口设�|�了一个WH_CBT�c�d��的钩子来�q��o消息�Q��ƈ把过滤函数设�|�成_AfxCbtFilterHook
_AfxCbtFilterHook通过�H�口子类化设�|�窗口的�H�口�q�程为AfxWndProc
�q�样�Q�通过::DispatchMessage发送给�H�口的消息就会源源不断地送到AfxWndProc中来�Q�可以想刎ͼ�AfxWndProc利用MFC的消息映��表�Q�分门别�cȝ��Ҏ��息进行分��?br />
�Q�待�l�……）

nacci 2006-05-18 17:29 发表评论

nacci — Thu, 18 May 2006 08:31:00 GMT

MFC中的消息循环呢？我们熟悉的switch……case……到哪里��M��Q?br />

在MFC中，消息的��@环�ƈ不是用switch……case……实现的�Q�它依赖于一张由�E�序自��n定义的消息网�?br />
首先�Q�MFC用一个名为AFX_MSGMAP_ENTRY�l�构来对消息的信息进行封装：

struct AFX_MSGMAP_ENTRY
{
　　UINT nMessage;    // windows message
　　UINT nCode;      　 // control code or WM_NOTIFY code
　　UINT nID;        　　 // control ID (or 0 for windows messages)
　　UINT nLastID;    　 // used for entries specifying a range of control id's
　　UINT_PTR nSig;   　 // signature type (action) or pointer to message #
　　AFX_PMSG pfn;     // routine to call (or special value)
} ;

其中　typedef void (AFX_MSG_CALL CCmdTarget::*AFX_PMSG)(void);

之后�Q�通过一个链表，把这些描�q�消息的�l�构�l�织��h��Q�构成消息映��表的结构是AFX_MSGMAP

struct AFX_MSGMAP　 {
　　 const AFX_MSGMAP * pBaseMap;
　　 const AFX_MSGMAP_ENTRY * lpEntries;
} ;

�q�样一个AFX_MSGMAP对象��成了构建消息映��表的关键�h物，它一只手拉着基类的AFX_MSGMAP对象�Q�另一只手拉着�c�L��w�的消息映射表，�q�样只要正确地在每一个类中都安插一个AFX_MSGMAP对象�Q�那么整个消息映��表��徏立�v来了。那么，何�ؓ正确呢？含义�?�Q�一是正��的讄��pBaseMap�Q��o它指向基�c�，二是正确的徏立类自��n的消息映��表。这两个工作是由4个宏完成的，

它们是：DECLARE_MEMSSAGE_MAP() / BEGIN_MESSAGE_MAP() / ON_COMMAND()�Q�注�Q�ON_COMMAND宏只是�ؓ了处理命令消息，对于其它的消息还有对应的宏，但是原理是相同的�Q?/ END_MESSAGE_MAP()�?br />让我们一个个的看看：

#define DECLARE_MESSAGE_MAP() \
private : \
　　 static const AFX_MSGMAP_ENTRY _messageEntries[]; \
protected : \
　　 static const AFX_MSGMAP messageMap; \
　　 virtual const AFX_MSGMAP * GetMessageMap() const ; \

�q�个宏的作用�?�Q?br /> 1. 在类中插入一个静态成员_messageEntries�Q�这是用来存攄��要处理的消息的数�l�（即类本��n的消息映��表�Q?br /> 2. 另一个静态成员massageMap用来指向基类的消息映��表
3. 安插一个虚函数�Q�其内容有待实现

接下来，_messageEntries的初始化�Q�messageMap的正��指向，GetMessageMap函数的实现这些工作还都没做，那正是后三个宏的责�Q�Q�它们要��序使用�Q�方能工作正常�?

#define BEGIN_MESSAGE_MAP(theClass, baseClass) \
   const AFX_MSGMAP * theClass::GetMessageMap() const \
   { return & theClass::messageMap; } \
  AFX_COMDAT const AFX_MSGMAP theClass::messageMap = \
   { & baseClass::messageMap, & theClass::_messageEntries[ 0 ] } ; \
  AFX_COMDAT const AFX_MSGMAP_ENTRY theClass::_messageEntries[] = \
{ \

�q�个宏的作用�?�Q?br />1. 定义了安插在�c�M��的虚函数GetMessageMap()�Q�只是简单的�q�回messageMap对象的地址
2. 初始化messageMap�Q�把�z��c�d��基类联系��h��构成一个大的消息映��表
3. 为类本��n的消息映��表的初始化做语法准�?/font>

ON_COMMAND�q�个宏的作用��是向_messageEntries数组中添加类本��n要处理的命��o消息�Q�其实在MFC中还有很多更方便的宏可以向类中添加消息，例如OM_WM_PAINT�{�，�q�里�Q�我们主要讨论ON_COMMAND�Q�毕竟原理都是相同的�?br />

#define ON_COMMAND(id, memberFxn) \
{ WM_COMMAND, CN_COMMAND, (WORD)id, (WORD)id, AfxSigCmd_v, \
static_cast < AFX_PMSG > (memberFxn) } ,

无非是对AFX_MSG_ENTRY�l�构的初始化�Q�这样在�c�M��为每一个想要处理的消息都是用一个ON_COMMAND宏，��p��动的初始化了�c�L��w�的消息映射表�?/font>

最后，当全部的信息��d��完毕后，使用END_MESSAGE_MAP()宏通知MFC一个类消息映射表结束了�?br />

#define END_MESSAGE_MAP() \
{ 0 , 0 , 0 , 0 , AfxSig_end, (AFX_PMSG) 0 } \
}; \

实现手法单纯得很�Q�无非是一个全0的AFX_MESSAGE_MAP对象�?br />
�l�论
惌��让你的类处理某个消息�Q��用下面的�l�合�Q?/font>

BEGIN_MESSAGE_MAP(theClass, the base Class)
// 消息处理�?/span>
END_MESSAGE_MAP()

�Q�待�l�……）

nacci 2006-05-18 16:31 发表评论

nacci — Thu, 18 May 2006 08:07:00 GMT

接上�ơRTTI的话题�?br />

能够在运行时发现一个对象的�c�d��Q�就可以在运行时动态的创徏一个对象。在一个类库中�Q�拥有统一的对象创建方式是非常重要的�?br />

在MFC中，对象的动态创��依赖于RTTI所建立��h��的类别型录，和动态创建有关的CRuntimeClass成员有两个：

CObject* (PASCAL* m_pfnCreateObject)(); // 指向用于创徏对象的函�?/span>
CObject* CreateObject(); // 利用m_pfnCreateObject创徏对象

利用RTTI建立的类别型录，DECLARE_DYNCREATE / IMPLEMENT_DYNCREATE�l�箋为类��d��了动态创建的功能�?/p>

#define DECLARE_DYNCREATE (class_name) \
　　　　DECLARE_DYNAMIC (class_name) \
　　　　static CObject* PASCAL CreateObject();

�q�个宏同��L��在类声明中，它不但�ؓ�c�L��加了class##class_name对象和GetRuntimeClass()�Q�还为类加入了一个静态函数CreateObject,用来�q�行对象的动态创建。同样IMPLEMENT_DYNCREATE用来对上面添加的内容作定义和初始化工作�?/p>

#define IMPLEMENT_DYNCREATE (class_name, base_class_name) \
　　　　CObject* PASCAL class_name::CreateObject() \
　　　　{ return new class_name; } \
　　　　IMPLEMENT_RUNTIMECLASS (class_name, base_class_name, 0xFFFF, \
　　　　class_name::CreateObject, NULL)

和IMPLEMENT_DYNAMIC不同的是�Q�这里的IMPLEMENT_RUNTIMECLASS中的�W?个参数�ƈ不�ؓNULL�Q�而是class_name::CreateObject�Q�这样就指定了用于创建对象的函数�Q�至于其它的内容�Q�与RTTI没有什么不同�?br />
于是�Q�整个对象的动态创��E�就变得非常��单了�Q�只要我们找到某个特定类的CRuntimeClass对象�Q�利用class##class_name.CreateObject()��可以了�?/p>

CObject* CRuntimeClass::CreateObject()
{
　　CObject* pObject = NULL;
　　pObject = (*m_pfnCreateObject)();
　　return pObject;
}

�l�论
惌��你的�c�d��MFC中支持动态创建，
1. 在类声明中��用DECLARE_DYNAMIC
2. 在类定义文�g中��用IMPLEMENT_DYNAMIC�Q�此�?br />    class##class_name.m_pfnCreateObject = class_name::CreateObject;　
    CRuntimeClass::CreateObject利用m_pfnCreateObject��可以进行对象的动态创��Z��
                                                                                                                                                �Q�待�l�……）

nacci 2006-05-18 16:07 发表评论

MFC漫谈�Q�一�Q�——RTTI

nacci — Thu, 18 May 2006 06:53:00 GMT

所有的�q�一�p�d��的东襉K��来源于前天晚上的一个电话，内容大概是说�Q?/span> �?/span> 你能教会我一个让我对 MFC 有点感觉�?/span> Hello World 吗？我��望一个像�?/span> C 写的 Win32 Hello World 一��L��观的例子�?/span> �?/span> ��x��q�曾�l�是我学�?/span> MFC 的时候也惛_��q�的问题。我是一个喜�Ƣ刨栚w��底的人，喜欢把事情搞明白�Q�于是曾�l�很长的一�D�|��间里�Q�我都困惑在�U�L��杂�ؕ的代码里。现在回惌��v来，侯捷老师的�?/span> Dessecting MFC 》和 Jeff Prosise 的�?/span> Programming MFC 》一赯��来，估计能达到解惑的目的。当�Ӟ��需要的是一点点耐心和对 Win32 �E�序的一�Ҏ��基本的了解（貌似废话。。。）。于是那天晚上， QQ 上和那个朋友聊了挺长一�D�|��_��腾了一�?/span> MFC 的源代码�Q�就有了�q�一�p�d��的东西，全当是故地重�怺�一番。言归正传吧。文章中所有的代码都提取自MFC 7.0

在MFC中，RTTI是依靠�ؓ彼此有��承关�pȝ��c�d��立一个记录其�c�d��的链表来实现的，和RTTI有关的CRuntimeClass成员�?个：

LPCSTR m_lpszClassName; // 用于记录�c�d��
// 用于指向基类的CRuntimeClass�l�构
CRuntimeClass* m_pBaseClass;
// 用于指向链表中前一个类的CRuntimeClass�l�构
CRuntimeClass* m_pNextClass;
// 用于建立�c�d��型录
const AFX_CLASSINIT* m_pClassInit;

�q�样在这个类别型录中��有了许多条路径�Q�每一条都是沿着m_pBaseClass一直可以找到某个类的最�l�基�c�R��要把一个类加入到这个类别型录中要用��C��个宏�Q?br />DECLARE_DYNAMIC / IMPLEMENT_DYNAMIC
其中�Q?br />

#define DECLARE_DYNAMIC (class_name) \
public: \
static const CRuntimeClass class##class_name; \
virtual CRuntimeClass* GetRuntimeClass() const; \

�q�个宏是用在�c�d��明中的，其作用就是根据类的名字�ؓ该类��d��两个public的成员，分别用于记录�cȝ��型别和获得对象class##class_name的地址�Q�注意这里的class##class_name是个静态成员，�q�就为后面我们做�c�d��的比较奠定了基础�Q��承于同一个基�cȝ��z��c�d��象包含共同的静态类成员�Q�。在�c�M��使用了DECLARE_DYNAMIC后，�q�要�?cpp的文件中使用IMPLEMENT_DYNAMIC宏，该宏的作用就是初始化class##class_name对象和定义GetRuntimeClass函数�?br />

#define IMPLEMENT_DYNAMIC (class_name, base_class_name) \
IMPLEMENT_RUNTIMECLASS (class_name, base_class_name, 0xFFFF, NULL, NULL)

IMPLEMENT_DYNAMIC在��用的时候，要指定类和其基类的名字，之后利用IMPLEMENT_RUNTIMECLASS�q�行实质性的初始化活动�?br />

#define IMPLEMENT_RUNTIMECLASS (class_name, base_class_name, wSchema, pfnNew, class_init) \
    AFX_COMDAT const CRuntimeClass class_name::class##class_name = { \
        　　#class_name, sizeof(class class_name), wSchema, pfnNew, \
        　　RUNTIME_CLASS(base_class_name), NULL, class_init }; \

    CRuntimeClass* class_name::GetRuntimeClass() const \
    { return RUNTIME_CLASS (class_name); } \

其中�Q�在class#class_name的初始化中和RTTI相关的只有：
&name_class用来初始化m_lpszClassName
RUNTIME_CLASS(base_class_name)用来初始化CRuntimeClass* m_pBaseClass
NULL用来初始化CRuntimeClass* m_pNextClass�Q�此时类别型录还没有建立��h��Q?

另外�Q�RUNTIME_CLASS��是用来获得class##class_name对象地址的宏�Q?br />

#define RUNTIME_CLASS (class_name) _RUNTIME_CLASS (class_name)
#define _RUNTIME_CLASS (class_name) \
((CRuntimeClass*) (&class_name::class##class_name))

�q�样�Q�当对程序中的每一个类都��用了DECLARE_DYNAMIC / IMPLEMENT_DYNAMIC宏之后，��׃ؓ该类在类别型录中�q�行了登记工作。当�Ӟ��MFC中所有的�c�都�z��于CObject�Q�所以所有的路线最�l�都要在CObject处会合，�׃��CObject没有基类�Q�所以它的CRuntimeClass对象�q�不能用上面的两个宏来实玎ͼ�在objcore.cpp中，为CObject的classCObject对象单独作了初始化的工作�Q?/p>

const struct CRuntimeClass CObject::classCObject =
{ "CObject", sizeof(CObject), 0xffff, NULL, NULL, NULL };

我们可以看到m_pBaseClass被初始化为NULL。另外，也单独实��C��GetRuntimeClass():

CRuntimeClass* CObject::GetRuntimeClass() const {
return _RUNTIME_CLASS (CObject);
}

至于_RUNTIME_CLASS�Q�前面已�l�说�q�了。这��P��如果惌��把自��q��c�M��l�给MFC�Q�只要在�c�d��明中使用DECLARE_DYNAMIC�Q�在�cȝ��实现中加入IMPLEMENT_DYNAMIC
�Q�就可以把自己注册到�c�d��型录中了。至此，��Z��实现�c�d��象的RTTI�Q�我们已�l�做好了所有的准备工作�Q�下面就来看一下它的实玎ͼ�它主要是靠CObject中的IsKindOf函数完成的�?/p>

BOOL CObject::IsKindOf(const CRuntimeClass* pClass) const
{
　　// ��Z��z�，略去了不相关的代�?/span>
　　CRuntimeClass* pClassThis = GetRuntimeClass();
　　return pClassThis->IsDerivedFrom(pClass);
}

�q�里�Q�由于GetRuntimeClass是虚函数�Q�所以pClassThis会指向调用IsKindOf函数的类对象的class##class_name�Q�之后利用指向该对象的指针调用IsDerivedFrom�Q?/p>

BOOL CRuntimeClass::IsDerivedFrom(const CRuntimeClass* pBaseClass) const {
    //��Z��z�，略去了不相关的代�?/span>
    if (pBaseClass == NULL)
        return FALSE;

    // simple SI case
    const CRuntimeClass* pClassThis = this;
    while (pClassThis != NULL) {
        if (pClassThis == pBaseClass)
        　return TRUE;
        pClassThis = pClassThis->m_pBaseClass;
    }
    return FALSE;       // walked to the top, no match
}

我们知道�Q�派生类和基�c�d��享基�cȝ��static对象�Q�所以在�q�里�Q�派生类和基�c�M��定共享相同的class##class_name对象�Q�这��׃ؓ我们判定两个�c�L��否有�l�承关系提供了理论基��Q�同��P��在IsDerivedFrom中，while循环中的if也的��是�q�样做的�Q�它沿着该类的同宗�\�U�上行，只要不到共同的祖先CObject�Q�就决不�|�休。　

�l�论
如果惌��把自��q��c�M��l�给MFC�Q�只要在�c�d��明中使用DECLARE_DYNAMIC�Q�在�cȝ��实现中加入IMPLEMENT_DYNAMIC
�Q�就可以把自己注册到�c�d��型录中了。　　�Q�待�l�……）

nacci 2006-05-18 14:53 发表评论

nacci — Mon, 15 May 2006 09:20:00 GMT

2个类�?span lang="EN-US">U�?span lang="EN-US">T�Q�你如何来确�?span lang="EN-US">U是否�l�承�?span lang="EN-US">T呢？在编译时发现两个�c�d��的这�U�关�p�d��于泛型库的优化是极�ؓ重要的。在泛型函数中，如果某个�c�d��C��特定的接口，你可以根据这�U�关�p�Mؓ其利用特定的优化��法。另外，如果我们可以在编译期军_��2个类的关�p�，我们也可以远��?span lang="EN-US">dynamic_cast�Q�从而避免运行时的效率开销�?br />

2个�Q意类�?span lang="EN-US">U�?span lang="EN-US">T�Q�如何确�?span lang="EN-US">T能否自动转换�?span lang="EN-US">U呢？

sizeof用在��M��复杂的表辑ּ�上， sizeof可以�q�回�q�个表达式值的大小�Q�而不会在�q�行时评估表辑ּ�的倹{��这也就意味着�Q�你可以把函数重载、模版实例化、�{换规则等�{�所有你可以�?span lang="EN-US">C++表达式中使用的设施统�l�塞�?span lang="EN-US">sizeof中来。实际上�Q?span lang="EN-US">sizeof隐藏了一个可以演�l�表辑ּ��c�d��的设施，最�l�，sizeof会返回表辑ּ��l�果的类型�?span lang="EN-US">

sizeof和重载函数来解决判断�c�d��之间的可转换性的问题。思�\很简单：我们提供2个重载函敎ͼ�一个函数的参数是我们要转换成的�c�d��Q�我们用U表示�Q�，而另一个则用来接收其他所有类型的参数。然后我们把要检��的�c�d��Q�用T表示�Q�传递给重蝲函数。如果接受类�?span lang="EN-US">U为参数的函数被调用了�Q�我们就认�ؓT可以转换�?span lang="EN-US">U�Q�反之则不可以。如何确定哪个函数被调用了呢�Q�我们利�?span lang="EN-US">sizeof出马�Q�我们只要让重蝲函数�q�回不同的类型，然后��查一下返回值就可以了�?span lang="EN-US">

2个不同的�c�d��Q?span lang="EN-US">

typedef char Small;
class Big { char dummy[ 2 ]; } ;

默认情况下， sizeof(Small) �?/span> 1 �Q��?/span> Big 的大��则无关紧要�Q�我们只要知道肯定不�?/span> 1 ��好了�?/span>

其次�Q�定�?/span> 2 个重载函敎ͼ�一个接收要转换成的�c�d��Q?/span>

Small Test(U);

另一个用来接收“其他的所有类型”，我们要保证在排除所有的转换之后才调用这个函敎ͼ� OK, 用省略号表示的参数列表真好满��需�?/span>

Big Test(...);

��管把一�?/span> C++ 对象传递给 ... 参数�c�d��的函敎ͼ�其结果未定义�Q�但是实际上我们�q�没有调用这个函数。我们甚臛_��以不用实现它�?/span>

最后，我们�?/span> sizeof 判断一下就完成��d��了：

const bool convExist = sizeof (Test(T())) == sizeof (Small);

你也�怼��_��是它了�Q?/span> Test 的调用会创徏一个��时对�?/span> T �Q�之后可能的�l�果只能�?/span> sizeof(Small) �?/span> sizeof(Big) 。兴奋之余，我们�q�要看到一个问题。如�?/span> T 的构造函数被设计�?/span> private �Q�我们就前功��弃了。当然解决的�Ҏ��也很��单，定义一个函敎ͼ�让他�q�回�c�d��?/span> T 的对象�?/span>

T MakeT();
const bool convExist = sizeof (Test(MakeT())) == sizeof (Small);

最后，把刚才的东西��装��C��个类里：

template < class T, class U >
class Conversion {
    typedef char Small;
     class Big { char dummy[ 2 ]; } ;

     static Small Test(U);
     static Big Test();
     static T MakeT();

public :
     enum { exist = sizeof (Test(MakeT())) == sizeof (Small) } ;
} ;

另外�Q�我们还可以讄��另外一个常�?/span> Conversion::SameType �Q�如�?/span> T �?/span> U 表示同一个类型，那么�q�回 true �Q?/span>

template < class T, class U >
class Conversion {
.. as above..
enum { sameType = false }
} ;

之后为同一个类型设计一个偏特化版本�Q?/span>

template < class T >
class Conversion < T, T > {
enum { exists = 1 , sameType = 1 } ;
} ;

最后，回到我们的主题，通过 Conversion 的帮助，我们可以来决定两个类型的�l�承性了�?/span>

#define SUPERSUBCLASS(T, U) \
(Conversion < const U * , const T * )::exists && \
! Conversion < const T * , const void *> ::sameType)

�?/span> U �l�承�?/span> T 或�?/span> U �?/span> T 是同一个类型的时候， SUPERSUBCLASS �q�回 true 。�ȝ��一下，只有下面�q?/span> 3 �U�情�?/span> const U* 可以隐式转换�?/span> const T* �Q?/span>

1. T �?/span> U 是同一个类�?/span>

2. T �?/span> U 的�Q意一个基�c?/span>

3. T �?/span> void

我们通过�W?/span> 2 个测试屏蔽了最后一�U�情形。当�Ӟ��如果你认为同一�U�类型也不算是��承关�pȝ��话，可以�q�一步严格其条�g�Q?/span>

#define SUPERSUBCLASS_STRICT(T, U) \
(SUPERSUBCLASS(T, U) && \
! Conversion( const T, const U)::sameType)

nacci 2006-05-15 17:20 发表评论

nacci — Fri, 11 Nov 2005 03:42:00 GMT

我们可以用不同的整数来实例化同一个模板，从而构造不同的�c�d��Q�进而在�~�译期执行某些抉择�?/font>

Alexandrescu 最初设计的一个简单的模版�Q�现在成了泛型设计的常用手法�Q?/span>

template <int v>

struct Int2Type {

enum { value = v };

};

对于每一个不同的常整敎ͼ� Int2Type 都代表不同的�c�d��。这是因��Z��同的模版实例化都代表不同的类型，也就是说 Int2Type<0> �?/span> Int2Type<1> 是完全不同的�?/span>

当你��x��据编译时�l�果来进行某些抉择——例如选择不同的函数——时�Q�你可以依赖一个常整数来帮你完成分�z�ַ�作，�q�时 Int2Type 便可以帮你是实现�q�个�Ҏ��?/span>

一般来��_��你在下面两个情况中需要��?/span> Int2Type �Q?/span>

l 你需要根据编译时帔R��来调用不同的函数

l 你需要在�~�译时执行分�z�ַ��?/span>

如果是在�q�行时执行分�z�ַ�作，你可以用 if-else �?/span> switch 语句来简单的实现。在大部分的时候，�q�种�q�行时成本都是微不��道的。但是，有时它们却不能满��你的要求。既是是在编译期可以军_��其分支，�~�译器还是会勤劳的�ؓ你编译其所有的分支�Q�这也就意味着 if-else 的所有分支必��被成功�~�译。有些困惑？�l�箋看下去：

考虑下面的情形：你设计了一个泛型容�?/span> NiftyContainer �Q?/span>

template <class T> class NiftyContainer {

...

};

�?/span> NiftyContainer 容器包含指向 T 对象的指针。�ؓ了复�?/span> NiftyContainer 中的一个对象，你可能需要调�?/span> T 的拷贝构造函敎ͼ�对于非多态类型）或者一个名�?/span> Clone() 的虚函数�Q�对于多态类型）。你可以通过讄��一�?/span> bool �c�d��的模版参数来从类的客��h��里获得关于多态的信息�?/span>

template <class T, bool isPolymorphic> class NiftyContainer {

// Other actions

void DoSomething() {

T* pSomeObj = ...;

if(isPolymorphic) {

T* pNewObj = pSomeObj->Clone();

// Some polymorphic algorithm

}

else {

T* pNewObj = new T(*pSomeObj);

// Some non-polymorphic algorithm

}

};

问题在于�~�译器不会让你��o�q�编译上面的代码。例如，如果一个多态类型没有定�?/span> Clone() �Q�那�?/span> NiftyContainer::DoSomething �l�对不会通过�~�译。尽��在�~�译时我们肯定可以对于分支进行判断，但这毕竟不是�~�译器的工作�Q�他只会勤劳的�ؓ你编译出所有的代码。于是当你试图调�?/span> NiftyContainer::DoSomething 的时候，�~�译器还是会停在 pObj->Clone() 上，�q�且抱怨说�Q�“你在做什么？�?/span>

对于非多态类型分支，也有可能发生�~�译错误。如�?/span> T 是一个多态类型，�q�且把它的拷贝构造函数设定�ؓ private 的时候（�q�时一个多态类的良好行为）�Q�非多态分支的 new T(*pObj) ��׃��发生错误�?/span>

你可能会惻I��如果�~�译器可以不�ȝ��会那些不必要的分支就好了�Q�但是看来不太可能。那么，如何是好呢？

其实�Q�方法有很多�Q?/span> Int2Type 提供了一个简�z�的办法。它可以�Ҏ�� true �?/span> false 来生成两个不同的�c�d��Q�而后�Ҏ�� Int2Type 评估正确的调用�?/span>

template <class T, bool isPolymorphic> class NiftyContainer {

private :

// Other actions

void DoSomething(T* pObj, Int2Type<true>) {

T* pNewObj = pSomeObj->Clone();

// Some polymorphic algorithm

}

void DoSomething(T* pObj, Int2Type<false>) {

T* pNewObj = new T(*pSomeObj);

// Some non-polymorphic algorithm

}

public :

void DoSomething(T* pObj) {

DoSomething(pObj, Int2Type());

}

};

当你��x��常整数用作一个类型的时候， Int2Type 是非常方便的。你可以传递一个��时的变量来重载函数。而之所以我们可以这样做�Q�是因�ؓ�~�译器不会去�~�译没有用到的模板函数�?/span>

nacci 2005-11-11 11:42 发表评论

nacci — Thu, 10 Nov 2005 08:43:00 GMT

摘要: 关于virtual desctructor的详�l�讨论。同��h��自于《Effective C++�?rd Edition�? 跟踪旉��是很�q�_��的�Q务，所以开发一个名�? TimeKeeper 的基�c�，�q�让不同的派生类来实��C��同的计时�Ҏ��是很合理的事情： ... 阅读全文

nacci 2005-11-10 16:43 发表评论

nacci — Mon, 07 Nov 2005 15:10:00 GMT

摘要: 你可能经帔R��要利用运行时断言技术，它可以方便地��试前提条�g。但是，随着Metaprogramming概念的出玎ͼ��~�译时断�a�技术也已经和runtime assertion一��L��普遍了。如何在�~�译时进行断�a�呢？其实�Q�方法只有一个，��是让编译器生成一条错误信息，但是�~�译器生成的错误信息信息性往往有又理想。�ƈ且，即��你在一�U�编译上设计了一�U�方案，你也很难把它�U�L��到其他的�~�译器上。我们通过其实现方法的改进�?.. 阅读全文

nacci 2005-11-07 23:10 发表评论

nacci — Thu, 03 Nov 2005 02:03:00 GMT

摘要: 自从C++中引入了template后，以泛型技术�ؓ中心的设计得��C��长��的进步。STL��是�q�个阶段杰出的��物。STL的目标就是要把数据和��法分开�Q�分别对其进行设计，之后通过一�U�名为iterator的东西，把这二者再�_�接��C��赗��设计模式中�Q�关于iterator的描�q�Cؓ�Q�一�U�能够顺序访问容器中每个元素的方法，使用该方法不能暴露容器内部的表达方式。可以说�Q�类型萃取技术就是�ؓ了要解决和iterator有关�?.. 阅读全文

nacci 2005-11-03 10:03 发表评论

C++默认会�ؓ我们做些什么工作？

nacci — Thu, 03 Nov 2005 01:17:00 GMT

class不是�I�的�Q?span lang="EN-US">C++会在何时做些什么事情？如果你不声明它们�Q�编译器会�ؓ你声明它们自��q��拯��构造函数、一个赋��D��符和一个析构函数。另外，如果你不声明一个构造函敎ͼ��~�译器还会�ؓ你创��Z��个。所有这些自动生成的函数都是public�?span lang="EN-US">inline的。例如，如果你写下：

class Empty {};

�q�和你写下如下的代码本质上是一��L��Q?/span>

class Empty {

Empty() {…} // default constructor

Empty(const Empty& rhs) {…} // Copy constructor

~Empty() {…} // destructor - whether it's virtual?

// copy assignment operator

Empty& operator=(const Empty& rhs) {}

}

当然�Q�这些函数只有它们真正被需要的时候才会被创徏。下面这些情况会使得�q�些函数被创建：

Empty e1; // default constructor & destructor

Empty e2(e1); // copy constructor

e2 = e1; // copy assignment operator

既然�~�译器会��Z��创徏�q�些函数�Q�那么这些函数都做些什么工作呢�Q�默认的构造和析构函数主要是让�~�译器放�|�一些执行“幕后工作”的代码�Q�例如调用基�c�d��非静态数据成员的构造和析构函数�{�。需要注意的是编译器��Z��生成的这个析构函数�ƈ不是虚拟的，除非�q�个�cȝ��基类明确声明了一个虚拟的析构函数�?span lang="EN-US">

对于拯��构造函数和赋��D��符�Q�编译器生成的版本只是简单的copy每一个非静态数据成员。例如，考虑一个名�?span lang="EN-US">NamedObject的模�?span lang="EN-US">,它可以让你把名字和类�?span lang="EN-US">T兌��h��?/font>

template <typename T>

class NamedObject {

public :

NamedObject(constchar* name, const T& value);

NamedObject(const std::string& name, const T& value);

private :

std::string nameValue;

T objectValue;

};

�׃��NamedObject中声明了构造函敎ͼ��~�译器便不会再自做主张�ؓ你生成一个默认的。这是很重要的。这意味着如果你精心设计的�cȝ��构造方式，你就不用再去担心�~�译器会愚蠢的�ؓ你添加一个不带参数的构造函数而破坏你的设计�?span lang="EN-US">

NamedObject 中既没有声明拯��构造函��C��没有声明赋��D��符�Q�所以当需要的时候，�~�译器会自动��Z��生成。显�Ӟ��下面的代码需要拷贝构造函数的支持�Q?span lang="EN-US">

NamedObject<int> no1("Smallest Prime Number", 2);

NamedObject<int> no2(no1);

no1.nameValue�?span lang="EN-US">no1.objectValue来初始化no2中对应的成员。由�?span lang="EN-US">nameValue的类型是string�Q��ƈ且标准的string有一个拷贝构造函敎ͼ�所�?span lang="EN-US">no2.nameValue��可以通过string的拷贝构造函数完成。另�?span lang="EN-US">objectValue是一个整敎ͼ�对于�q�个内置�c�d��Q�简单的bit-copy��可以完成复制的��d��了�?span lang="EN-US">

NamedObject来生成一个赋��D��符。但是，只有当生成的代码在语法和语义都都正确的时候，�~�译器才会�ؓ你执行生成工作，如果其中��M��一斚w��除了问题�Q�编译器��׃��拒绝��Z��重蝲operator =�?span lang="EN-US">

NamedObject�Q?span lang="EN-US">

template <typename T>

class NamedObject {

public :

NamedObject(const std::string& name, const T& value);

private :

std::string& nameValue;

const T objectValue;
};

之后�Q�下面的代码会怎样呢？

std::string newDog("Persephone");

std::string oldDog("Satch");

NamedObject<int> p(newDog, 2);

NamedObject<int> s(oldDog, 36);
p = s; // What should happen?

p.nameValue�?span lang="EN-US">s.nameValue分别指向不同�?span lang="EN-US">string对象。这个复制应该对p.nameValue做怎样的改变呢�Q�直觉上�Q?span lang="EN-US">p.nameValue��会指向s.nameValue所指的string对象。但是这破坏�?span lang="EN-US">C++的一条基本的准则�Q?span lang="EN-US">C++不允许引用指向不同的对象。换句话��_��N��改变p.nameValue所引用的对象应该要影响到其它对象所引用的字�W�串吗？�q�是�~�译器生成的赋��D��符应该做的事情吗？

对于�q�个问题的解�{�方法是拒绝�~�译�q�样的代码。如果你惌��含有引用数据成员的类支持赋值功能，那么你就必须自己定义赋��D��符。对于含�?font face="新宋�?>const数据成员的类来说�Q�故事是�c�M��的。修改对象中�?span lang="EN-US">const成员��L��非法的，所以编译器对于如何处理�q�种问题一无所知。最后，如果基类�?span lang="EN-US">operator=声明�?span lang="EN-US">private�Q�那么编译器同样会拒�l��ؓ�z��cȝ��?span lang="EN-US">operator=。毕竟，一斚w��Q�即便编译器可以生成�Q?span lang="EN-US">operator=也只能处理派生类中属于基�cȝ��那一部分�Q�另一斚w��Q�派生类也根本无权访问基�c�M��?span lang="EN-US">private成员�?span lang="EN-US">

l operator=和析构函数�?span lang="EN-US">

nacci 2005-11-03 09:17 发表评论