C++博客-冬日飘雪

MFC非模态对话框的销毁（转）

Bomb — Thu, 05 Aug 2010 07:48:00 GMT

非模态对话框相对于模态对话框，他的创建和销毁过程和模态对话框有一定的区别，先看一下MSDN的原文：When you implement a modeless dialog box, always override the OnCancel member function and call DestroyWindow from within it. Don’t call the base class CDialog::OnCancel, because it calls EndDialog, which will make the dialog box invisible but will not destroy it. You should also override PostNcDestroy for modeless dialog boxes in order to delete this, since modeless dialog boxes are usually allocated with new. Modal dialog boxes are usually constructed on the frame and do not need PostNcDestroy cleanup.

MS的指示：非模态对话框需要重载函数OnCanel，并且在这个函数中调用DestroyWindow。并且不能调用基类的OnCancel，因为基类的OnCancel调用了EndDialog这个函数，这个函数是针对模态对话框的。
还有一个必须重载的函数就是PostNcDestroy，这也是一个虚函数，通常的非模态对话框是用类的指针，通过new创建的，这就需要在PostNcDestroy函数中delete掉这个指针。

了解了理论过后，下面我们就可以用代码实现一下非模态对话框的创建和销毁过程:
建立：
//主框架中，即调用/创建非模态对话框的对话框/窗体：
CTestDlg *pDlg=new CTestDlg;
pDlg->Create(IDD_TESTDLG,this);
pDlg->ShowWindow(SW_SHOW);
//非模态对话框中：
void CTestDlg::OnCancel()
{
     DestroyWindow();
}
void CTestDlg::PostNcDestroy()
{
     CDialog::PostNcDestroy();
     delete this;
}

如果要在点击按钮的情况下，销毁非模态对话框，只需要把按钮的事件映射到OnCancel函数即可。

以下是一点资料供参考，非模态对话框的销毁顺序：

MFC应用程序中处理消息的顺序
1.AfxWndProc()       该函数负责接收消息，找到消息所属的CWnd对象，然后调用AfxCallWndProc
2.AfxCallWndProc()   该函数负责保存消息(保存的内容主要是消息标识符和消息参数)供应用程序以后使用，然后调用WindowProc()函数
3.WindowProc()       该函数负责发送消息到OnWndMsg()函数，如果未被处理，则调用DefWindowProc()函数
4.OnWndMsg()         该函数的功能首先按字节对消息进行排序，对于WM_COMMAND消息，调用OnCommand()消息响应函数，对于WM_NOTIFY消息调用OnNotify()消息响应函数。任何被遗漏的消息将是一个窗口消息。OnWndMsg()函数搜索类的消息映像，以找到一个能处理任何窗口消息的处理函数。如果OnWndMsg()函数不能找到这样的处理函数的话，则把消息返回到WindowProc()函数，由它将消息发送给DefWindowProc()函数
5.OnCommand()       该函数查看这是不是一个控件通知(lParam参数不为NULL，如果lParam参数为空的话，说明该消息不是控件通知)，如果它是，OnCommand()函数会试图将消息映射到制造通知的控件；如果他不是一个控件通知(或者如果控件拒绝映射的消息)OnCommand()就会调用OnCmdMsg()函数
6.OnCmdMsg()         根据接收消息的类，OnCmdMsg()函数将在一个称为命令传递(Command Routing)的过程中潜在地传递命令消息和控件通知。例如：如果拥有该窗口的类是一个框架类，则命令和通知消息也被传递到视图和文档类，并为该类寻找一个消息处理函数

MFC应用程序创建窗口的过程
1.PreCreateWindow()   该函数是一个重载函数，在窗口被创建前，可以在该重载函数中改变创建参数 (可以设置窗口风格等等)
2.PreSubclassWindow() 这也是一个重载函数，允许首先子分类一个窗口
3.OnGetMinMaxInfo()   该函数为消息响应函数，响应的是WM_GETMINMAXINFO消息，允许设置窗口的最大或者最小尺寸
4.OnNcCreate()         该函数也是一个消息响应函数，响应WM_NCCREATE消息，发送消息以告诉窗口的客户区即将被创建
5.OnNcCalcSize()       该函数也是消息响应函数,响应WM_NCCALCSIZE消息，作用是允许改变窗口客户区大小
6.OnCreate()           该函数也是一个消息响应函数，响应WM_CREATE消息，发送消息告诉一个窗口已经被创建
7.OnSize()             该函数也是一个消息响应函数，响应WM_SIZE消息，发送该消息以告诉该窗口大小已经发生变化
8.OnMove()             消息响应函数，响应WM_MOVE消息，发送此消息说明窗口在移动
9.OnChildNotify()     该函数为重载函数，作为部分消息映射被调用，告诉父窗口即将被告知一个窗口刚刚被创建

MFC应用程序关闭窗口的顺序(非模态窗口)
1.OnClose()       消息响应函数，响应窗口的WM_CLOSE消息，当关闭按钮被单击的时候发送此消息
2.OnDestroy()     消息响应函数，响应窗口的WM_DESTROY消息，当一个窗口将被销毁时，发送此消息
3.OnNcDestroy()   消息响应函数，响应窗口的WM_NCDESTROY消息，当一个窗口被销毁后发送此消息
4.PostNcDestroy() 重载函数，作为处理OnNcDestroy()函数的最后动作，被CWnd调用

MFC应用程序中打开模式对话框的函数调用顺序
1.DoModal()             重载函数，重载DoModal()成员函数
2.PreSubclassWindow()   重载函数，允许首先子分类一个窗口
3.OnCreate()             消息响应函数，响应WM_CREATE消息，发送此消息以告诉一个窗口已经被创建
4.OnSize()               消息响应函数，响应WM_SIZE消息，发送此消息以告诉窗口大小发生变化
5.OnMove()               消息响应函数，响应WM_MOVE消息，发送此消息，以告诉窗口正在移动
6.OnSetFont()           消息响应函数，响应WM_SETFONT消息，发送此消息，以允许改变对话框中控件的字体
7.OnInitDialog()         消息响应函数，响应WM_INITDIALOG消息，发送此消息以允许初始化对话框中的控件，或者是创建新控件
8.OnShowWindow()        消息响应函数，响应WM_SHOWWINDOW消息，该函数被ShowWindow()函数调用
9.OnCtlColor()           消息响应函数，响应WM_CTLCOLOR消息，被父窗口发送已改变对话框或对话框上面控件的颜色
10. OnChildNotify()     重载函数，作为WM_CTLCOLOR消息的结果发送

MFC应用程序中关闭模式对话框的顺序
1.OnClose()         消息响应函数，响应WM_CLOSE消息，当"关闭"按钮被单击的时候，该函数被调用
2.OnKillFocus() 消息响应函数，响应WM_KILLFOCUS消息，当一个窗口即将失去键盘输入焦点以前被发送
3.OnDestroy()       消息响应函数，响应WM_DESTROY消息，当一个窗口即将被销毁时，被发送
4.OnNcDestroy()     消息响应函数，响应WM_NCDESTROY消息，当一个窗口被销毁以后被发送
5.PostNcDestroy()   重载函数，作为处理OnNcDestroy()函数的最后动作被CWnd调用

打开无模式对话框的顺序
1.PreSubclassWindow()     重载函数，允许用户首先子分类一个窗口
2.OnCreate()             消息响应函数，响应WM_CREATE消息，发送此消息以告诉一个窗口已经被创建
3.OnSize()               消息响应函数，响应WM_SIZE消息，发送此消息以告诉窗口大小发生变化
4.OnMove()               消息响应函数，响应WM_MOVE消息，发送此消息以告诉窗口正在移动
5.OnSetFont()          消息响应函数，响应WM_SETFONT消息，发送此消息以允许改变对话框中控件的字体

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/yaoohfox/archive/2009/06/19/4282857.aspx

Bomb 2010-08-05 15:48 发表评论

二叉树

Bomb — Thu, 05 Aug 2010 05:09:00 GMT

摘要: #includeusing namespace std;struct _node { int data; _node* left; _node* right;}... 阅读全文

Bomb 2010-08-05 13:09 发表评论

ADO智能指针（转）

Bomb — Wed, 04 Aug 2010 14:57:00 GMT

使用C++（MFC）操作数据库，首选就是ADO。ADO库包含三个基本接口:_ConnectionPtr接口、_CommandPtr接口和_RecordsetPtr接口。在MFC要使用ADO（COM）首先要引用COM地址，编译器才能够实现。从网上的很多资料都介绍，将EOF重命名，防止和其他冲突，那偶们也这样做反正也不会有坏处。格式如下：
#include
#import "c:\program files\common files\system\ado\msado15.dll" no_namespace rename("EOF", "EndOfFields")
只要用过MFC的人都知道把它放在哪（stdafx.h）。由于ADO是一个COM所以在调用他们之前要初始化COM环境，本人就在初始化这个栽了个跟头。初始化OLE（调用AfxOleInit();）在方法uApp::InitInstance()中进行（必须在DoModal()之前），当然也可以在你调用前初始化。OK下面就可以调用了，系统会生成两个文件，这些都是从COM高过来的。

    _ConnectionPtr接口返回一个记录集或一个空指针。通常使用它来创建一个数据连接或执行一条不返回任何结果的SQL语句，如一个存储过程。使用 _ConnectionPtr接口返回一个记录集不是一个好的使用方法。对于要返回记录的操作通常用_RecordserPtr来实现。而用 _ConnectionPtr操作时要想得到记录条数得遍历所有记录，而用_RecordserPtr时不需要。
    _CommandPtr接口返回一个记录集。它提供了一种简单的方法来执行返回记录集的存储过程和SQL语句。在使用_CommandPtr接口时，你可以利用全局 _ConnectionPtr接口，也可以在_CommandPtr接口里直接使用连接串。如果你只执行一次或几次数据访问操作，后者是比较好的选择。但如果你要频繁访问数据库，并要返回很多记录集，那么，你应该使用全局_ConnectionPtr接口创建一个数据连接，然后使用_CommandPtr 接口执行存储过程和SQL语句。
    _RecordsetPtr是一个记录集对象。与以上两种对象相比，它对记录集提供了更多的控制功能，如记录锁定，游标控制等。同_CommandPtr接口一样，它不一定要使用一个已经创建的数据连接，可以用一个连接串代替连接指针赋给 _RecordsetPtr的connection成员变量，让它自己创建数据连接。如果你要使用多个记录集，最好的方法是同Command对象一样使用已经创建了数据连接的全局_ConnectionPtr接口，然后使用_RecordsetPtr执行存储过程和SQL语句。

使用_ConnectionPtr和_RecordsetPtr来读取数据库内容：

1     try{
2         // TODO: 在此添加额外的初始化代码
3         CString szServerName = _T("Driver=SQL Server;Server=(local);Database=Domains;uid=sa;pwd=;");
4         HRESULT hr = m_pConnection.CreateInstance(__uuidof(Connection));
5         hr = m_pConnection->Open((_bstr_t)szServerName,"","",0);
6         hr = m_pRecordset.CreateInstance(__uuidof(Recordset));
7         CString szSQL=_T("SELECT DomainName FROM Domains;");
8         BSTR bstrSQL = szSQL.AllocSysString();
9         hr = m_pRecordset->Open(bstrSQL,(IDispatch *)m_pConnection,adOpenDynamic,adLockOptimistic,adCmdText);
10         while(!m_pRecordset->EndOfFields)
11         {
12             _variant_t theValue;
13             theValue = m_pRecordset->GetCollect("DomainName");
14
15             if(theValue.vt!=VT_NULL)
16             {
17                 AfxMessageBox(CString(theValue));
18             }
19             m_pRecordset->MoveNext();
20         }
21         m_pRecordset->Close();
22         m_pConnection->Close();
23     }
24     catch(_com_error *e)
25     {
26         MessageBox(e->Description(),e->Source());
27     }

原文出自：http://kb.cnblogs.com/a/949747/

Bomb 2010-08-04 22:57 发表评论

如何利用UDL文件来建立ADO连接（转）

Bomb — Wed, 04 Aug 2010 05:22:00 GMT

如何利用UDL文件来建立ADO连接使用通用数据连接文件（*.UDL，以下简称文件）来创建ADO连接，可以和ODBC一样可视化地定义要连接的数据源，从而实现数据访问的透明性。

1.使用UDL文件来创建ADO连接

创建ADO的连接，首先要设置ADO连接对象的ConnectionString属性，该属性提供所要连接的数据库类型、数据所处服务器、要访问的数据库和数据库访问的安全认证信息。比较专业的方法是在ConnectionString中直接提供以上信息，下面是访问不同类型数据源设置ConnectionString的标准：访问ODBC数据
"Provider=MSDASQL;DSN=dsnName;UID=userName;PWD=userPassWord;"
访问ORACLE数据库
"Provider=MSDAORA;Data Source=serverName;User ID=userName; Password=userPassword;"
访问MS SQL数据库
"Provider=SQLOLEDB;Data Source=serverName;Initial Catalog=databaseName; User ID=userName;Password=userPassword;"
访问Access 数据库
"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=databaseName;User ID=userName;Password=userPassword;"

上述的连接属性设置标准随着数据源的类型不同而变化，软件用户常常不习惯这种设置方式，都希望有可视化的数据源设置方法。为此Microsoft提供了通用数据连接文件（.UDL）来建立和测试ADO连接属性。ADO连接对象可以很方便地使用UDL文件来连接数据源，下面例子使用my_data1.udl来创建ADO连接。

_ConnectionPtr m_pDBConn;
m_pDBConn.CreateInstance(__uuidof(Connection));
m_pDBConn->ConnectionString ="File Name=c:\mydir\my_data1.udl";
m_pDBConn->Open("","","",NULL);

这样一来无论数据源如何变化，在软件中都可以用统一的方法编程。当数据源改变时，只要双击相应的udl文件即可可视化地设置数据源，无需更改软件。

因为ADO是COM接口，为了软件的可靠性，打开ADO连接时，可以加入异常处理代码。 try{
m_pDBConn->Open("","","",NULL);
}catch(_com_error &e){
//处理异常的代码
. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
m_pDBConn=NULL;
}

因为_ConnectionPtr m_pDBConn是智能指针，应在处理异常代码时将智能指针设为NULL后将自动将引用计数降为0.

如果不出现异常，只要在使用完m_pDBConn，只要引用Close方法即可。

2.创建你所需的UDL文件

在你所想创建UDL文件的目录中单击右键，选择从菜单新建Microsoft 数据连接，然后将新创建的UDL文件更改为你所希望的文件名（。UDL扩展名不能改变）。

注：如果操作系统是Window 2000，先创建一个文本文件，再将该文本文件的扩展名改为 "udl".

然后双击所创建的UDL文件，即可视化地完成数据源的设定。

使用UDL文件必须在系统中先安装Microsoft MDAC，Win 98第二版，Win 2000中都自动包含了该组件，需要该组件最新版本时可以到Microsoft网站去下载。

本文来自[Svn中文网]转发请保留本站地址：http://www.svn8.com/c/cc/2010020220112.html

Bomb 2010-08-04 13:22 发表评论

SQL Server字符集的研究（转）

Bomb — Tue, 03 Aug 2010 14:17:00 GMT

一、试验归类

　　测试SQL：

drop table a create table a(a varchar(2)) insert into a values('a') insert into a values(N'a') insert into a values('深圳') insert into a values(N'深圳') select a， len(a)， datalength(a) from a drop table #a create table a(a varchar(2)) insert into #a values('a') insert into #a values(N'a') insert into #a values('深圳') insert into #a values(N'深圳') select a， len(a)， datalength(a) from #a drop table a create table a(a varchar(8000)) insert into a select REPLICATE('a'， 8000) insert into a select REPLICATE('深'， 8000) insert into a select REPLICATE(N'a'， 8000) insert into a select REPLICATE(N'深'， 8000) select a， len(a)， datalength(a) from a

　　1. 字符集是支持双字节的字符集如中文字符集（Collation name为Chinese_PRC_CI_AS）

　　 <1>. 定义varchar(2)

　　(1) 正式表

　　总结：在中文字符集下，定义varchar(x)，不论使用不使用N''，英文字符都占1个字节，即可以存x个英文字符；不论使用不使用N''，中文字符都占2个字节，即可以存(x / 2)个中文，select结果为汉字本身，不是乱码。

　　(2) 临时表

　　总结：在中文字符集下，定义varchar(x)，和正式表表现一样；

　　<2>. 定义nvarchar(2)

　　(1) 正式表

　　总结：在中文字符集下，定义nvarchar(x)，不论使用不使用N''，英文字符都占2个字节，即可以存x个英文字符；不论使用不使用N''，中文字符都占2个字节，即可以存x个中文，select结果为汉字本身，不是乱码。

　　(2) 临时表

　　总结：在中文字符集下，定义nvarchar(x)，和正式表表现一样。

　　<3>. 类型为varchar时，长度 x 和 datalength()对应，都指字节大小；英文len() = datalength()；中文len() = datalength() / 2；类型为nvarchar时，长度 x 和 len()对应，都指字符长度。

　　2. 字符集是支持单字节的字符集如拉丁字符集（Collation name为Latin1_General_CI_AS）

　　<1>. 定义varchar(2)

　　(1) 正式表

　　总结：在英文字符集下，定义varchar(x)，不论使用不使用N''，英文字符都占1个字节，即可以存x个英文字符；不论使用不使用N''，中文字符都占1个字节，即可以存x个中文，但只保存前半截中文编码，所以select结果为乱码；（特殊：如果使用N''，此时插入的字符数最大为4000）

　　英文和中文 len() = datalength()；

　　(2) 临时表

　　总结：在英文字符集下，定义varchar(x)，不论使用不使用N''，英文字符都占1个字节，即可以存x个英文字符；不使用N''时，中文占1个字节，可以存x个汉字，但都只存入汉字前半截字符编码，显示为乱码；使用N''时，中文占2个字节，只可以存 x/2 个汉字，没有乱码，取出仍为汉字，说明在英文字符集下通过使用N''是可以保存汉字的；除用N''保存的中文外，其余英文和中文 len() = datalength()；用N''保存的中文字符len() = datalength() / 2；

　　<2>. 定义nvarchar(2)

　　(1) 正式表

　　总结：在英文字符集下，定义nvarchar(x)，不论使用不使用N''，英文字符都占2个字节，即可以存x个英文字符；（注意每个字符比varchar用的空间大）不论使用不使用N''，中文字符都占2个字节，即可以存x个中文字符，但不使用N''只保存前半截中文编码，所以select结果为乱码；使用N''则保存和取出都为汉字本身；

　　(2) 临时表

　　总结：在英文字符集下，定义nvarchar(x)，和正式表表现相同；

　　<3>. 类型为varchar时，长度 x 和 datalength()对应，都指字节大小；（临时表中N''中文字符长度比较特殊；）类型为nvarchar时，长度 x 和 len()对应，都指字符长度。

　　二、使用归类

　　抛开不常用的临时表不谈，只看正式表，再加上varchar和nvarchar类型的最大长度，得到以下经验：

　　<1> 最大长度问题

　　1. 在中文字符集下使用varchar，最大长度可定义8000，这个8000是指字节数（datalength()），即最大可以保存8000个英文字符，4000个中文字符。

　　特殊：若存入字符N'a'，则最大能保存4000个字符，但其所占空间为4000字节。

　　2. 在中文字符集下使用nvarchar，最大长度可定义4000，这个4000是指字符个数（len()），即最大可以保存4000个英文字符，4000个中文字符。

　　3. 在英文字符集下使用varchar，最大长度可定义8000，这个8000是指字节数（datalength()），由于中文英文都保存为1字节，故最大可以保存8000个英文、中文字符。

　　4. 在英文字符集下使用nvarchar，最大长度可定义4000，这个4000是指字符个数（len()），即最大可以保存4000个英文字符，4000个中文字符。

　　<2> 文字显示问题

　　1. N''要和数据类型nvarchar， nchar一起使用，如果对varchar， char字段类型强制使用N''，则会产生一些特殊现象，甚至无法控制。

　　2. 在英文字符集下，想要保存特殊符号字符、中文等双字节字符，在定义表结构时要使用nvarchar或者nchar，在保存时要用N''。

　　3. 在中文字符集下，数据库系统缺省已经可以保存特殊符号字符、中文等双字节字符。即使用不使用N''，都按双字节处理。但为了统一期间建议，在定义表结构时如果使用nvarchar或者nchar，在保存时要用N''，在定义表结构时如果使用varchar和char，此时不要使用N''操作。

　　4. SUBSTRING ( expression ， start ， length ) 。length：是一个整数，指定子串的长度（要返回的字符数或字节数）。中文字符集中按字符数取；英文字符集中，char， varchar按字节数取，nchar， nvarchar按字符数取；

　　三、其他参考

　　使用 Unicode 数据

　　unicode代码页、排序规则、SQL Server 排序规则基础知识、Windows 排序规则排序样式、选择 SQL 排序规则、 DBCS 字符

原文出自：http://tech.it168.com/oldarticle/2006-07-21/200607211444921.shtml

Bomb 2010-08-03 22:17 发表评论

0/1背包——非递归解法

Bomb — Sat, 15 May 2010 13:43:00 GMT

#include "iostream"

using namespace std;

#define  N 7
#define  W 15

int weight[N+1] = {9,1,4,3,4,5,7,8};

int flag[N+1] = {0,0,0,0,0,0,0,0};

int knap()
{
    int i=0;
    int m = 0;

    while (1)
    {
        if (m < W && i <=N)
        {
            m += weight[i];
            flag[i] = 1;
        }
        else
        {
            i--;
            while (flag[i]==0 && i>=0)
            {
                i--;
            }
            if (i<0)
            {
                cout<<"Not found"<<endl;
                return 0;
            }
            m -= weight[i];
            flag[i] = 0;
        }
        if (m == W)
        {
            for(int k=0; k<=N; k++)
            {
                if (flag[k] == 1)
                {
                    cout<<weight[k]<<" ";
                }
            }
            return 1;
        }
        i++;
    }
}

void main()
{
    knap();
    getchar();
}

Bomb 2010-05-15 21:43 发表评论

明确C++风格的类型转换的用法

Bomb — Sat, 15 May 2010 12:19:00 GMT

　仔细想想地位卑贱的类型转换功能（cast），其在程序设计中的地位就象goto语句一样令人鄙视。但是它还不是无法令人忍受，因为当在某些紧要的关头，类型转换还是必需的，这时它是一个必需品。

　　不过C风格的类型转换并不代表所有的类型转换功能。

　　一来它们过于粗鲁，能允许你在任何类型之间进行转换。不过如果要进行更精确的类型转换，这会是一个优点。在这些类型转换中存在着巨大的不同，例如把一个指向const对象的指针（pointer-to-const-object）转换成指向非const对象的指针（pointer-to-non-const-object）(即一个仅仅去除const的类型转换)，把一个指向基类的指针转换成指向子类的指针（即完全改变对象类型）。传统的C风格的类型转换不对上述两种转换进行区分。（这一点也不令人惊讶，因为C风格的类型转换是为C语言设计的，而不是为C++语言设计的）。

　　二来C风格的类型转换在程序语句中难以识别。在语法上，类型转换由圆括号和标识符组成，而这些可以用在C＋＋中的任何地方。这使得回答象这样一个最基本的有关类型转换的问题变得很困难：“在这个程序中是否使用了类型转换？”。这是因为人工阅读很可能忽略了类型转换的语句，而利用象grep的工具程序也不能从语句构成上区分出它们来。

　　C++通过引进四个新的类型转换操作符克服了C风格类型转换的缺点，这四个操作符是, static_cast, const_cast, dynamic_cast, 和reinterpret_cast。在大多数情况下，对于这些操作符你只需要知道原来你习惯于这样写，

(type) expression

　　而现在你总应该这样写：

static_cast(expression)

　　例如，假设你想把一个int转换成double，以便让包含int类型变量的表达式产生出浮点数值的结果。如果用C风格的类型转换，你能这样写：

int firstNumber, secondNumber;
...
double result = ((double)firstNumber)/secondNumber；

　　如果用上述新的类型转换方法，你应该这样写：

double result = static_cast(firstNumber)/secondNumber;

　　这样的类型转换不论是对人工还是对程序都很容易识别。

　　 static_cast在功能上基本上与C风格的类型转换一样强大，含义也一样。它也有功能上限制。例如，你不能用static_cast象用C风格的类型转换一样把struct转换成int类型或者把double类型转换成指针类型，另外，static_cast不能从表达式中去除const属性，因为另一个新的类型转换操作符const_cast有这样的功能。
其它新的C++类型转换操作符被用在需要更多限制的地方。const_cast用于类型转换掉表达式的const或volatileness属性。通过使用const_cast，你向人们和编译器强调你通过类型转换想做的只是改变一些东西的constness或者volatileness属性。这个含义被编译器所约束。如果你试图使用const_cast来完成修改constness 或者volatileness属性之外的事情，你的类型转换将被拒绝。下面是一些例子：

class Widget { ... };
class SpecialWidget: public Widget { ... };
void update(SpecialWidget *psw);
SpecialWidget sw; // sw 是一个非const 对象。
const SpecialWidget& csw = sw; // csw 是sw的一个引用
// 它是一个const 对象
update(&csw); // 错误!不能传递一个const SpecialWidget* 变量
// 给一个处理SpecialWidget*类型变量的函数
update(const_cast(&csw));
// 正确，csw的const被显示地转换掉（
// csw和sw两个变量值在update
//函数中能被更新）
update((SpecialWidget*)&csw);
// 同上，但用了一个更难识别
//的C风格的类型转换
Widget *pw = new SpecialWidget;
update(pw); // 错误！pw的类型是Widget*，但是
// update函数处理的是SpecialWidget*类型
update(const_cast(pw));
// 错误！const_cast仅能被用在影响
// constness or volatileness的地方上。,
// 不能用在向继承子类进行类型转换。

　　到目前为止，const_cast最普通的用途就是转换掉对象的const属性。

　　第二种特殊的类型转换符是dynamic_cast，它被用于安全地沿着类的继承关系向下进行类型转换。这就是说，你能用dynamic_cast把指向基类的指针或引用转换成指向其派生类或其兄弟类的指针或引用，而且你能知道转换是否成功。失败的转换将返回空指针（当对指针进行类型转换时）或者抛出异常（当对引用进行类型转换时）：

Widget *pw;
...
update(dynamic_cast(pw));
// 正确，传递给update函数一个指针
// 是指向变量类型为SpecialWidget的pw的指针
// 如果pw确实指向一个对象,
// 否则传递过去的将使空指针。
void updateViaRef(SpecialWidget& rsw);
updateViaRef(dynamic_cast(*pw));
//正确。传递给updateViaRef函数
// SpecialWidget pw 指针，如果pw
// 确实指向了某个对象
// 否则将抛出异常
dynamic_casts在帮助你浏览继承层次上是有限制的。它不能被用于缺乏虚函数的类型上（参见条款M24），也不能用它来转换掉constness：
int firstNumber, secondNumber;
...
double result = dynamic_cast(firstNumber)/secondNumber;
// 错误！没有继承关系
const SpecialWidget sw;
...
update(dynamic_cast(&sw));
// 错误! dynamic_cast不能转换
// 掉const。

　　如你想在没有继承关系的类型中进行转换，你可能想到static_cast。如果是为了去除const，你总得用const_cast。

　　这四个类型转换符中的最后一个是reinterpret_cast。使用这个操作符的类型转换，其的转换结果几乎都是执行期定义（implementation-defined）。因此，使用reinterpret_casts的代码很难移植。

　　reinterpret_casts的最普通的用途就是在函数指针类型之间进行转换。例如，假设你有一个函数指针数组：

typedef void (*FuncPtr)(); // FuncPtr is 一个指向函数
// 的指针，该函数没有参数
// 返回值类型为void
FuncPtr funcPtrArray[10]; // funcPtrArray 是一个能容纳
// 10个FuncPtrs指针的数组

　　让我们假设你希望（因为某些莫名其妙的原因）把一个指向下面函数的指针存入funcPtrArray数组：

int doSomething();

　　你不能不经过类型转换而直接去做，因为doSomething函数对于funcPtrArray数组来说有一个错误的类型。在FuncPtrArray数组里的函数返回值是void类型，而doSomething函数返回值是int类型。

funcPtrArray[0] = &doSomething; // 错误！类型不匹配
reinterpret_cast可以让你迫使编译器以你的方法去看待它们：
funcPtrArray[0] = // this compiles
reinterpret_cast(&doSomething);

　　转换函数指针的代码是不可移植的（C++不保证所有的函数指针都被用一样的方法表示），在一些情况下这样的转换会产生不正确的结果（参见条款M31），所以你应该避免转换函数指针类型，除非你处于着背水一战和尖刀架喉的危急时刻。一把锋利的刀。一把非常锋利的刀。

　　如果你使用的编译器缺乏对新的类型转换方式的支持，你可以用传统的类型转换方法代替static_cast, const_cast, 以及reinterpret_cast。也可以用下面的宏替换来模拟新的类型转换语法：

#define static_cast(TYPE,EXPR) ((TYPE)(EXPR))
#define const_cast(TYPE,EXPR) ((TYPE)(EXPR))
#define reinterpret_cast(TYPE,EXPR) ((TYPE)(EXPR))

　　你可以象这样使用使用：

double result = static_cast(double, firstNumber)/secondNumber;
update(const_cast(SpecialWidget*, &sw));
funcPtrArray[0] = reinterpret_cast(FuncPtr, &doSomething);

　　这些模拟不会象真实的操作符一样安全，但是当你的编译器可以支持新的的类型转换时，它们可以简化你把代码升级的过程。

　　没有一个容易的方法来模拟dynamic_cast的操作，但是很多函数库提供了函数，安全地在派生类与基类之间进行类型转换。如果你没有这些函数而你有必须进行这样的类型转换，你也可以回到C风格的类型转换方法上，但是这样的话你将不能获知类型转换是否失败。当然，你也可以定义一个宏来模拟dynamic_cast的功能，就象模拟其它的类型转换一样：

#define dynamic_cast(TYPE,EXPR) (TYPE)(EXPR)

　　请记住，这个模拟并不能完全实现dynamic_cast的功能，它没有办法知道转换是否失败。

　　我知道，是的，我知道，新的类型转换操作符不是很美观而且用键盘键入也很麻烦。如果你发现它们看上去实在令人讨厌，C风格的类型转换还可以继续使用并且合法。然而，正是因为新的类型转换符缺乏美感才能使它弥补了在含义精确性和可辨认性上的缺点。并且，使用新类型转换符的程序更容易被解析（不论是对人工还是对于工具程序），它们允许编译器检测出原来不能发现的错误。这些都是放弃C风格类型转换方法的强有力的理由。还有第三个理由：也许让类型转换符不美观和键入麻烦是一件好事。

转载自：http://www.yesky.com/462/1886962.shtml

Bomb 2010-05-15 20:19 发表评论

浅析C++中的this指针

Bomb — Wed, 12 May 2010 17:35:00 GMT

转自：[url]http://blog.csdn.net/starlee/archive/2008/01/24/2062586.aspx[/url]

有下面的一个简单的类：

class CNullPointCall
{
public:
    static void Test1();
    void Test2();
    void Test3(int iTest);
    void Test4();

private:
    static int m_iStatic;
    int m_iTest;
};

int CNullPointCall::m_iStatic = 0;

void CNullPointCall::Test1()
{
    cout << m_iStatic << endl;
}

void CNullPointCall::Test2()
{
    cout << "Very Cool!" << endl;
}

void CNullPointCall::Test3(int iTest)
{
    cout << iTest << endl;
}

void CNullPointCall::Test4()
{
    cout << m_iTest << endl;
}

那么下面的代码都正确吗？都会输出什么？

CNullPointCall *pNull = NULL; // 没错，就是给指针赋值为空
pNull->Test1(); // call 1
pNull->Test2(); // call 2
pNull->Test3(13); // call 3
pNull->Test4(); // call 4

    你肯定会很奇怪我为什么这么问。一个值为NULL的指针怎么可以用来调用类的成员函数呢？！可是实事却很让人吃惊：除了call 4那行代码以外，其余3个类成员函数的调用都是成功的，都能正确的输出结果，而且包含这3行代码的程序能非常好的运行。
    经过细心的比较就可以发现，call 4那行代码跟其他3行代码的本质区别：类CNullPointCall的成员函数中用到了this指针。
    对于类成员函数而言，并不是一个对象对应一个单独的成员函数体，而是此类的所有对象共用这个成员函数体。当程序被编译之后，此成员函数地址即已确定。而成员函数之所以能把属于此类的各个对象的数据区别开, 就是靠这个this指针。函数体内所有对类数据成员的访问，都会被转化为this->数据成员的方式。
    而一个对象的this指针并不是对象本身的一部分，不会影响sizeof（“对象”）的结果。this作用域是在类内部，当在类的非静态成员函数中访问类的非静态成员的时候，编译器会自动将对象本身的地址作为一个隐含参数传递给函数。也就是说，即使你没有写上this指针，编译器在编译的时候也是加上this的，它作为非静态成员函数的隐含形参，对各成员的访问均通过this进行。
    对于上面的例子来说，this的值也就是pNull的值。也就是说this的值为NULL。而Test1()是静态函数，编译器不会给它传递this指针，所以call 1那行代码可以正确调用（这里相当于CNullPointCall::Test1()）；对于Test2()和Test3()两个成员函数，虽然编译器会给这两个函数传递this指针，但是它们并没有通过this指针来访问类的成员变量，因此call 2和call 3两行代码可以正确调用；而对于成员函数Test4()要访问类的成员变量，因此要使用this指针，这个时候发现this指针的值为NULL，就会造成程序的崩溃。
    其实，我们可以想象编译器把Test4()转换成如下的形式：

void CNullPointCall::Test4(CNullPointCall *this)
{
cout << this->m_iTest << endl;
}

而把call 4那行代码转换成了下面的形式：

CNullPointCall::Test4(pNull);

    所以会在通过this指针访问m_iTest的时候造成程序的崩溃。
    下面通过查看上面代码用VC 2005编译后的汇编代码来详细解释一下神奇的this指针。
    上面的C++代码编译生成的汇编代码是下面的形式：

    CNullPointCall *pNull = NULL;
0041171E  mov         dword ptr [pNull],0
    pNull->Test1();
00411725  call        CNullPointCall::Test1 (411069h)
    pNull->Test2();
0041172A  mov         ecx,dword ptr [pNull]
0041172D  call        CNullPointCall::Test2 (4111E0h)
    pNull->Test3(13);
00411732  push        0Dh
00411734  mov         ecx,dword ptr [pNull]
00411737  call        CNullPointCall::Test3 (41105Ah)
    pNull->Test4();
0041173C  mov         ecx,dword ptr [pNull]
0041173F  call        CNullPointCall::Test4 (411032h)

    通过比较静态函数Test1()和其他3个非静态函数调用所生成的的汇编代码可以看出：非静态函数调用之前都会把指向对象的指针pNull（也就是this指针）放到ecx寄存器中（mov ecx,dword ptr [pNull]）。这就是this指针的特殊之处。看call 3那行C++代码的汇编代码就可以看到this指针跟一般的函数参数的区别：一般的函数参数是直接压入栈中（push 0Dh），而this指针却被放到了ecx寄存器中。在类的非成员函数中如果要用到类的成员变量，就可以通过访问ecx寄存器来得到指向对象的this指针，然后再通过this指针加上成员变量的偏移量来找到相应的成员变量。
    下面再通过另外一个例子来说明this指针是怎样被传递到成员函数中和如何使用this来访问成员变量的。
    依然是一个很简单的类：

class CTest
{
public:
    void SetValue();

private:
    int m_iValue1;
    int m_iValue2;
};

void CTest::SetValue()
{
    m_iValue1 = 13;
    m_iValue2 = 13;
}

用如下的代码调用成员函数：

CTest test;
test.SetValue();

上面的C++代码的汇编代码为：

    CTest test;
    test.SetValue();
004117DC  lea         ecx,[test]
004117DF  call        CTest::SetValue (4111CCh)

同样的，首先把指向对象的指针放到ecx寄存器中；然后调用类CTest的成员函数SetValue()。地址4111CCh那里存放的其实就是一个转跳指令，转跳到成员函数SetValue()内部。

004111CC jmp CTest::SetValue (411750h)

而411750h才是类CTest的成员函数SetValue()的地址。

void CTest::SetValue()
{
00411750  push        ebp
00411751  mov         ebp,esp
00411753  sub         esp,0CCh
00411759  push        ebx
0041175A  push        esi
0041175B  push        edi
0041175C  push        ecx // 1
0041175D  lea         edi,[ebp-0CCh]
00411763  mov         ecx,33h
00411768  mov         eax,0CCCCCCCCh
0041176D  rep stos    dword ptr es:[edi]
0041176F  pop         ecx // 2
00411770  mov         dword ptr [ebp-8],ecx // 3
    m_iValue1 = 13;
00411773  mov         eax,dword ptr [this] // 4
00411776  mov         dword ptr [eax],0Dh // 5
    m_iValue2 = 13;
0041177C  mov         eax,dword ptr [this] // 6
0041177F  mov         dword ptr [eax+4],0Dh // 7
}
00411786  pop         edi
00411787  pop         esi
00411788  pop         ebx
00411789  mov         esp,ebp
0041178B  pop         ebp
0041178C  ret

    下面对上面的汇编代码中的重点行进行分析：
    1、将ecx寄存器中的值压栈，也就是把this指针压栈。
    2、ecx寄存器出栈，也就是this指针出栈。
    3、将ecx的值放到指定的地方，也就是this指针放到[ebp-8]内。
    4、取this指针的值放入eax寄存器内。此时，this指针指向test对象，test对象只有两个int型的成员变量，在test对象内存中连续存放，也就是说this指针目前指向m_iValue1。
    5、给寄存器eax指向的地址赋值0Dh（十六进制的13）。其实就是给成员变量m_iValue1赋值13。
    6、同4。
    7、给寄存器eax指向的地址加4的地址赋值。在4中已经说明，eax寄存器内存放的是this指针，而this指针指向连续存放的int型的成员变量m_iValue1。this指针加4（sizeof(int)）也就是成员变量m_iValue2的地址。因此这一行就是给成员变量m_iValue2赋值。
    通过上面的分析，我们可以从底层了解了C++中this指针的实现方法。虽然不同的编译器会使用不同的处理方法，但是C++编译器必须遵守C++标准，因此对于this指针的实现应该都是差不多的。

Bomb 2010-05-13 01:35 发表评论

跳动的字符_多线程

Bomb — Tue, 13 Apr 2010 15:41:00 GMT

  1#include "windows.h"
  2#include "process.h"
  3#include "stddef.h"
  4#include "stdlib.h"
  5#include "conio.h"
  6#include "time.h"
  7
  8#define GetRandom(min, max) ( (rand()%(int)(((max)+1)-(min))) +(min))
  9void Bounce(void* ch);
10
11void CheckKey(void* dummy);
12
13
14BOOL repeat = TRUE;
15HANDLE hStdOut;                //Console handle
16CONSOLE_SCREEN_BUFFER_INFO    csbi;            //Console info struct
17
18void main()
19{
20    CHAR ch = 'A';
21
22    hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
23
24    //Get the size of screen
25    GetConsoleScreenBufferInfo(hStdOut,&csbi);
26
27    //
28    _beginthread(CheckKey,0,NULL);
29
30
31    while (repeat)
32    {
33        _beginthread(Bounce,0,(void*)(ch++));
34
35        Sleep(1000L);
36    }
37}
38
39void CheckKey(void* dummy)
40{
41    _getch();
42    repeat = FALSE;    //_endthread implied
43}
44
45void Bounce(void* ch)
46{
47    //select color according to the thread
48
49    char blankcell = 0x20;
50    char blockcell = (char)ch;
51    BOOL first = TRUE;
52    COORD oldCoord, newCoord;
53    DWORD result;
54
55    //
56    srand((unsigned)time(NULL));
57
58    newCoord.X = GetRandom(0,csbi.dwSize.X-1);
59    newCoord.Y = GetRandom(0,csbi.dwSize.Y-1);
60
63
64    while (repeat)
65    {
66        Sleep(100L);
67
68        //刷新老位置，在新位置绘制字符
69        if (first)
70        {
71            first = FALSE;
72        }
73        else
74        {
75            WriteConsoleOutputCharacter(hStdOut,&blankcell,1,oldCoord,&result);
76            WriteConsoleOutputCharacter(hStdOut,&blockcell,1,newCoord,&result);
77        }
78
79        oldCoord.X = newCoord.X;
80        oldCoord.Y = newCoord.Y;
81        newCoord.X += GetRandom(-1,1);
82        newCoord.Y += GetRandom(-1,1);
83
84        if (newCoord.X <0 || newCoord.X == csbi.dwSize.X || newCoord.Y <0 || newCoord.Y == csbi.dwSize.Y)
85        {
86            if (newCoord.X < 0)
87            {
88                newCoord.X = 1;
89            }
90            else if (newCoord.X == csbi.dwSize.X)
91            {
92                newCoord.X = csbi.dwSize.X-2;
93            }
94
95            if (newCoord.Y < 0)
96            {
97                newCoord.Y = 1;
98            }
99            else if (newCoord.Y == csbi.dwSize.Y)
100            {
101                newCoord.Y = csbi.dwSize.Y-2;
102            }
103        }
123        else
124            continue;
125
126        Beep(((char)ch-'A')*100,175);
127    }
128    _endthread();
129
130}

Bomb 2010-04-13 23:41 发表评论