C++博客-Jacky Loves C++-随笔分类-IT

存储过程 stored procedure

小熊 — Tue, 06 Nov 2007 02:37:00 GMT

定义：
        将常用的或很复杂的工作，预先用SQL语句写好并用一个指定的名称存储起来,   那么以后要叫数据库提供与已定义好的存储过程的功能相同的服务时,只需调用execute,即可自动完成命令。
        讲到这里,可能有人要问：这么说存储过程就是一堆SQL语句而已啊？
        Microsoft公司为什么还要添加这个技术呢?
        那么存储过程与一般的SQL语句有什么区别呢?

        存储过程的优点：
          1.存储过程只在创造时进行编译，以后每次执行存储过程都不需再重新编译，而一般SQL语句每执行一次就编译一次,所以使用存储过程可提高数据库执行速度。
          2.当对数据库进行复杂操作时(如对多个表进行Update,Insert,Query,Delete时），可将此复杂操作用存储过程封装起来与数据库提供的事务处理结合一起使用。
          3.存储过程可以重复使用,可减少数据库开发人员的工作量
          4.安全性高,可设定只有某此用户才具有对指定存储过程的使用权
        存储过程的种类：
          1.系统存储过程：以sp_开头,用来进行系统的各项设定.取得信息.相关管理工作,
          如   sp_help就是取得指定对象的相关信息
          2.扩展存储过程   以XP_开头,用来调用操作系统提供的功能
          exec   master..xp_cmdshell   'ping   10.8.16.1'
          3.用户自定义的存储过程,这是我们所指的存储过程
          常用格式
          Create   procedure   procedue_name
          [@parameter   data_type][output]
          [with]{recompile|encryption}
          as
          sql_statement
        解释:
        output：表示此参数是可传回的
        with   {recompile|encryption}
        recompile:表示每次执行此存储过程时都重新编译一次
        encryption:所创建的存储过程的内容会被加密
        如:
          表book的内容如下
          编号   书名   价格
          001   C语言入门   $30
          002   PowerBuilder报表开发   $52
          实例1:查询表Book的内容的存储过程
          create   proc   query_book
          as
          select   *   from   book
          go
          exec   query_book
          实例2:加入一笔记录到表book,并查询此表中所有书籍的总金额
          Create   proc   insert_book
          @param1   char(10),@param2   varchar(20),@param3   money,@param4   money   output
          with   encryption   ---------加密
          as
          insert   book(编号,书名，价格）   Values(@param1,@param2,@param3)
          select   @param4=sum(价格)   from   book
          go
          执行例子:
          declare   @total_price   money
          exec   insert_book   '003','Delphi   控件开发指南',$100,@total_price
          print   '总金额为'+convert(varchar,@total_price)
          go
        存储过程的3种传回值:
          1.以Return传回整数
          2.以output格式传回参数
          3.Recordset
        传回值的区别:
          output和return都可在批次程式中用变量接收,而recordset则传回到执行批次的客户端中
        实例3：设有两个表为Product,Order,其表内容如下：
          Product
          产品编号   产品名称   客户订数
          001   钢笔   30
          002   毛笔   50
          003   铅笔   100
          Order
          产品编号   客户名   客户订金
          001   南山区   $30
          002   罗湖区   $50
          003   宝安区   $4
        请实现按编号为连接条件,将两个表连接成一个临时表,该表只含编号.产品名.客户名.订金.总金额,
        总金额=订金*订数,临时表放在存储过程中
        代码如下:
          Create   proc   temp_sale
          as
          select   a.产品编号,a.产品名称,b.客户名,b.客户订金,a.客户订数*   b.客户订金   as总金额
          into   #temptable   from   Product   a   inner   join   Order   b   on   a.产品编号=b.产品编号
          if   @@error=0
          print   'Good'
          else
          print   'Fail'
          go

--------------------------------------------------------------------------------------------------------------------

存储过程介绍

一、先介绍一下什么是存储过程
存储过程是利用SQL   Server所提供的Tranact-SQL语言所编写的程序。Tranact-SQL语言是SQL   Server提供专为设计数据库应用程序的语言，它是应用程序和SQL   Server数据库间的主要程序式设计界面。它好比Oracle数据库系统中的Pro-SQL和Informix的数据库系统能够中的Informix-4GL语言一样。这类语言主要提供以下功能，让用户可以设计出符合引用需求的程序：
1)、变量说明
2)、ANSI兼容的SQL命令(如Select,Update….)
3)、一般流程控制命令(if…else…、while….)
4)、内部函数

二、存储过程的书写格式

CREATE   PROCEDURE   [拥有者.]存储过程名[;程序编号]
[(参数#1,…参数#1024)]
[WITH
{RECOMPILE   |   ENCRYPTION   |   RECOMPILE,   ENCRYPTION}
]
[FOR   REPLICATION]
AS   程序行

其中存储过程名不能超过128个字。每个存储过程中最多设定1024个参数
(SQL   Server   7.0以上版本),参数的使用方法如下:

@参数名   数据类型   [VARYING]   [=内定值]   [OUTPUT]

每个参数名前要有一个“@”符号,每一个存储过程的参数仅为该程序内部使用,参数的类型除了IMAGE外，其他SQL   Server所支持的数据类型都可使用。
[=内定值]相当于我们在建立数据库时设定一个字段的默认值，这里是为这个参数设定默认值。[OUTPUT]是用来指定该参数是既有输入又有输出值的，也就是在调用了这个存储过程时，如果所指定的参数值是我们需要输入的参数，同时也需要在结果中输出的，则该项必须为OUTPUT，而如果只是做输出参数用，可以用CURSOR，同时在使用该参数时，必须指定VARYING和OUTPUT这两个语句。

例子:
CREATE   PROCEDURE   order_tot_amt   @o_id   int,@p_tot   int   output   AS
SELECT   @p_tot   =   sum(Unitprice*Quantity)
FROM   orderdetails
WHERE   ōrdered=@o_id

例子说明:
该例子是建立一个简单的存储过程order_tot_amt,这个存储过程根据用户输入的定单ID号码(@o_id),由定单明细表(orderdetails)中计算该定单销售总额[单价(Unitprice)*数量(Quantity)],这一金额通过@p_tot这一参数输出给调用这一存储过程的程序

三、在SQL   Server中执行存储过程

在SQL   Server的查询分析器中，输入以下代码:
declare   @tot_amt   int
execute   order_tot_amt   1,@tot_amt   output
select   @tot_amt

以上代码是执行order_tot_amt这一存储过程，以计算出定单编号为1的定单销售金额，我们定义@tot_amt为输出参数，用来承接我们所要的结果

小熊 2007-11-06 10:37 发表评论

汉字编码问题

小熊 — Thu, 01 Nov 2007 06:53:00 GMT

http://www.css8.cn/css8_document/gb2312.htm

由于常常要和汉字处理打交道，因此，我常常受到汉字编码问题的困扰。在不断的打击与坚持中，也积累了一点汉字编码方面的经验，想和大家一起分享。

一、汉字编码的种类

汉字编码中现在主要用到的有三类，包括GBK，GB2312和Big5。

1、GB2312又称国标码，由国家标准总局发布，1981年5月1日实施，通行于大陆。新加坡等地也使用此编码。它是一个简化字的编码规范，当然也包括其他的符号、字母、日文假名等，共7445个图形字符，其中汉字占6763个。我们平时说6768个汉字，实际上里边有5个编码为空白，所以总共有6763个汉字。

GB2312规定“对任意一个图形字符都采用两个字节表示，每个字节均采用七位编码表示”，习惯上称第一个字节为“高字节”，第二个字节为“低字节”。GB2312中汉字的编码范围为，第一字节0xB0-0xF7(对应十进制为176-247)，第二个字节0xA0-0xFE（对应十进制为160-254）。

GB2312将代码表分为94个区，对应第一字节（0xa1-0xfe）；每个区94个位（0xa1-0xfe），对应第二字节，两个字节的值分别为区号值和位号值加32（2OH），因此也称为区位码。01-09区为符号、数字区，16-87区为汉字区（0xb0-0xf7），10-15区、88-94区是有待进一步标准化的空白区。

2、Big5又称大五码，主要为香港与台湾使用，即是一个繁体字编码。每个汉字由两个字节构成，第一个字节的范围从0X81－0XFE（即129-255），共126种。第二个字节的范围不连续，分别为0X40－0X7E（即64-126），0XA1－0XFE（即161-254），共157种。

3、GBK是GB2312的扩展，是向上兼容的，因此GB2312中的汉字的编码与GBK中汉字的相同。另外，GBK中还包含繁体字的编码，它与Big5编码之间的关系我还没有弄明白，好像是不一致的。GBK中每个汉字仍然包含两个字节，第一个字节的范围是0x81-0xFE（即129-254），第二个字节的范围是0x40-0xFE（即64-254）。GBK中有码位23940个，包含汉字21003个。

表1 汉字编码范围

名称	第一字节	第二字节
GB2312	0xB0-0xF7(176-247)	0xA0-0xFE（160-254）
GBK	0x81-0xFE（129-254）	0x40-0xFE（64-254）
Big5	0x81-0xFE（129-255）	0x40-0x7E（64-126） 0xA1－0xFE（161-254）

二、对汉字进行hash

为了处理汉字的方便，在查找汉字的时候，我们通常会用到hash的方法，那怎么来确定一个汉字位置呢？这就和每种编码的排列有关了，这里主要给出一种hash函数的策略。

对于GB2312编码，设输入的汉字为GBword，我们可以采用公式(C1-176)*94 + (C2-161)确定GBindex。其中，C1表示第一字节，C2表示第二字节。具体如下：

GBindex = ((unsigned char)GBword.at(0)-176)*94 + (unsigned char)GBword.at(1) - 161;

之所以用unsigned char类型，是因为char是一个字节，如果用unsigend int，因为int是4个字节的，所以会造成扩展，导致错误。

对于GBK编码，设输入的汉字为GBKword，则可以采用公式 index=(ch1-0x81)*190+(ch2-0x40)-(ch2/128)，其中ch1是第一字节，ch2是第二字节。

具体的，

GBKindex = ((unsigned char)GBKword[0]-129)*190 +

((unsigned char)GBKword[1]-64) - (unsigned char)GBKword[1]/128;

三、怎样判断一个汉字的是什么编码

直接根据汉字的编码范围判断，对于GB2312和GBK可用下面两个程序实现。

1、判断是否是GB2312

bool isGBCode(const string& strIn)

{

unsigned char ch1;

unsigned char ch2;

if (strIn.size() >= 2)

{

ch1 = (unsigned char)strIn.at(0);

ch2 = (unsigned char)strIn.at(1);

if (ch1>=176 && ch1<=247 && ch2>=160 && ch2<=254)

return true;

else return false;

}

else return false;

}

2、判断是否是GBK编码

bool isGBKCode(const string& strIn)

{

unsigned char ch1;

unsigned char ch2;

if (strIn.size() >= 2)

{

ch1 = (unsigned char)strIn.at(0);

ch2 = (unsigned char)strIn.at(1);

if (ch1>=129 && ch1<=254 && ch2>=64 && ch2<=254)

return true;

else return false;

}

else return false;

}

3、对于Big5

它的范围为：高字节从0xA0到0xFE，低字节从0x40到0x7E，和0xA1到0xFE两部分。判断一个汉字是否是BIG5编码，可以如上对字符的编码范围判断即可。如何定位呢？那么也想象所有编码排列为一个二维坐标，纵坐标是高字节，横坐标是低字节。这样一行上的汉字个数：(0x7E-0x40+1)+(0xFE-0xA1+1)＝157。那么定位算法分两块，为:

if 0x40<=ch2<=0x7E: #is big5 char

index=((ch1-0xA1)*157+(ch2-0x40))*2

elif 0xA1<=ch2<=0xFE: #is big5 char

index=((ch1-0xA1)*157+(ch2-0xA1+63))*2

对于第二块，计算偏移量时因为有两块数值，所以在计算后面一段值时，不要忘了前面还有一段值。0x7E-0x40+1=63。

四、如果判断一个字符是西文字符还是中文字符

大家知道西文字符主要是指ASCII码，它用一个字节表示。且这个字符转换成数字之后，该数字是大于0的，而汉字是两个字节的，第一个字节的转化为数字之后应该是小于0的，因此可以根据每个字节转化为数字之后是否小于0，判断它是否是汉字。

例如，设输入字为strin，则，

If (strin.at(0) < 0)

cout << ”是汉字” << endl;

else cout << ”不是汉字” << endl;

小熊 2007-11-01 14:53 发表评论

常用数据类型使用转换详解

小熊 — Thu, 01 Nov 2007 01:30:00 GMT

http://www.vckbase.com/study/article/data_convert.htm

常用数据类型使用转换详解
作者：程佩君

读者层次：初学

刚接触VC编程的朋友往往对许多数据类型的转换感到迷惑不解，本文将介绍一些常用数据类型的使用。

我们先定义一些常见类型变量借以说明

int i = 100;
long l = 2001;
float f=300.2;
double d=12345.119;
char username[]="程佩君";
char temp[200];
char *buf;
CString str;
_variant_t v1;
_bstr_t v2;

一、其它数据类型转换为字符串

短整型(int)
itoa(i,temp,10);///将i转换为字符串放入temp中,最后一个数字表示十进制
itoa(i,temp,2); ///按二进制方式转换
长整型(long)
ltoa(l,temp,10);
浮点数(float,double)
用fcvt可以完成转换,这是MSDN中的例子:
int decimal, sign;
char *buffer;
double source = 3.1415926535;
buffer = _fcvt( source, 7, &decimal, &sign );
运行结果:source: 3.1415926535 buffer: '31415927' decimal: 1 sign: 0
decimal表示小数点的位置,sign表示符号:0为正数，1为负数
CString变量
str = "2008北京奥运";
buf = (LPSTR)(LPCTSTR)str;
BSTR变量
BSTR bstrValue = ::SysAllocString(L"程序员");
char * buf = _com_util::ConvertBSTRToString(bstrValue);
SysFreeString(bstrValue);
AfxMessageBox(buf);
delete(buf);
CComBSTR变量
CComBSTR bstrVar("test");
char *buf = _com_util::ConvertBSTRToString(bstrVar.m_str);
AfxMessageBox(buf);
delete(buf);
_bstr_t变量
_bstr_t类型是对BSTR的封装，因为已经重载了=操作符，所以很容易使用
_bstr_t bstrVar("test");
const char *buf = bstrVar;///不要修改buf中的内容
AfxMessageBox(buf);

通用方法(针对非COM数据类型)
用sprintf完成转换

char  buffer[200];
                char  c = '1';
                int   i = 35;
                long  j = 1000;
                float f = 1.7320534f;
                sprintf( buffer, "%c",c);
                sprintf( buffer, "%d",i);
                sprintf( buffer, "%d",j);
                sprintf( buffer, "%f",f);

二、字符串转换为其它数据类型
strcpy(temp,"123");

短整型(int)
i = atoi(temp);
长整型(long)
l = atol(temp);
浮点(double)
d = atof(temp);
CString变量
CString name = temp;
BSTR变量
BSTR bstrValue = ::SysAllocString(L"程序员");
...///完成对bstrValue的使用
SysFreeString(bstrValue);
CComBSTR变量
CComBSTR类型变量可以直接赋值
CComBSTR bstrVar1("test");
CComBSTR bstrVar2(temp);
_bstr_t变量
_bstr_t类型的变量可以直接赋值
_bstr_t bstrVar1("test");
_bstr_t bstrVar2(temp);

三、其它数据类型转换到CString
使用CString的成员函数Format来转换,例如:

整数(int)
str.Format("%d",i);
浮点数(float)
str.Format("%f",i);
字符串指针(char *)等已经被CString构造函数支持的数据类型可以直接赋值
str = username;
对于Format所不支持的数据类型，可以通过上面所说的关于其它数据类型转化到char *的方法先转到char *，然后赋值给CString变量。

四、BSTR、_bstr_t与CComBSTR

CComBSTR 是ATL对BSTR的封装，_bstr_t是C++对BSTR的封装,BSTR是32位指针,但并不直接指向字串的缓冲区。
char *转换到BSTR可以这样:
BSTR b=_com_util::ConvertStringToBSTR("数据");///使用前需要加上comutil.h和comsupp.lib
SysFreeString(bstrValue);
反之可以使用
char *p=_com_util::ConvertBSTRToString(b);
delete p;
具体可以参考一，二段落里的具体说明。

CComBSTR与_bstr_t对大量的操作符进行了重载，可以直接进行=,!=,==等操作，所以使用非常方便。
特别是_bstr_t,建议大家使用它。

五、VARIANT 、_variant_t 与 COleVariant

VARIANT的结构可以参考头文件VC98\Include\OAIDL.H中关于结构体tagVARIANT的定义。
对于VARIANT变量的赋值：首先给vt成员赋值，指明数据类型，再对联合结构中相同数据类型的变量赋值，举个例子：
VARIANT va;
int a=2001;
va.vt=VT_I4;///指明整型数据
va.lVal=a; ///赋值

对于不马上赋值的VARIANT，最好先用Void VariantInit(VARIANTARG FAR* pvarg);进行初始化,其本质是将vt设置为VT_EMPTY,下表我们列举vt与常用数据的对应关系:

Byte bVal;	// VT_UI1.
Short iVal;	// VT_I2.
long lVal;	// VT_I4.
float fltVal;	// VT_R4.
double dblVal;	// VT_R8.
VARIANT_BOOL boolVal;	// VT_BOOL.
SCODE scode;	// VT_ERROR.
CY cyVal;	// VT_CY.
DATE date;	// VT_DATE.
BSTR bstrVal;	// VT_BSTR.
DECIMAL FAR* pdecVal	// VT_BYREF\|VT_DECIMAL.
IUnknown FAR* punkVal;	// VT_UNKNOWN.
IDispatch FAR* pdispVal;	// VT_DISPATCH.
SAFEARRAY FAR* parray;	// VT_ARRAY\|*.
Byte FAR* pbVal;	// VT_BYREF\|VT_UI1.
short FAR* piVal;	// VT_BYREF\|VT_I2.
long FAR* plVal;	// VT_BYREF\|VT_I4.
float FAR* pfltVal;	// VT_BYREF\|VT_R4.
double FAR* pdblVal;	// VT_BYREF\|VT_R8.
VARIANT_BOOL FAR* pboolVal;	// VT_BYREF\|VT_BOOL.
SCODE FAR* pscode;	// VT_BYREF\|VT_ERROR.
CY FAR* pcyVal;	// VT_BYREF\|VT_CY.
DATE FAR* pdate;	// VT_BYREF\|VT_DATE.
BSTR FAR* pbstrVal;	// VT_BYREF\|VT_BSTR.
IUnknown FAR* FAR* ppunkVal;	// VT_BYREF\|VT_UNKNOWN.
IDispatch FAR* FAR* ppdispVal;	// VT_BYREF\|VT_DISPATCH.
SAFEARRAY FAR* FAR* pparray;	// VT_ARRAY\|*.
VARIANT FAR* pvarVal;	// VT_BYREF\|VT_VARIANT.
void FAR* byref;	// Generic ByRef.
char cVal;	// VT_I1.
unsigned short uiVal;	// VT_UI2.
unsigned long ulVal;	// VT_UI4.
int intVal;	// VT_INT.
unsigned int uintVal;	// VT_UINT.
char FAR * pcVal;	// VT_BYREF\|VT_I1.
unsigned short FAR * puiVal;	// VT_BYREF\|VT_UI2.
unsigned long FAR * pulVal;	// VT_BYREF\|VT_UI4.
int FAR * pintVal;	// VT_BYREF\|VT_INT.
unsigned int FAR * puintVal;	//VT_BYREF\|VT_UINT.

_variant_t是VARIANT的封装类，其赋值可以使用强制类型转换，其构造函数会自动处理这些数据类型。
使用时需加上#include
例如：
long l=222;
ing i=100;
_variant_t lVal(l);
lVal = (long)i;
COleVariant的使用与_variant_t的方法基本一样，请参考如下例子：
COleVariant v3 = "字符串", v4 = (long)1999;
CString str =(BSTR)v3.pbstrVal;
long i = v4.lVal;

六、其它一些COM数据类型

根据ProgID得到CLSID
HRESULT CLSIDFromProgID( LPCOLESTR lpszProgID,LPCLSID pclsid);
CLSID clsid;
CLSIDFromProgID( L"MAPI.Folder",&clsid);
根据CLSID得到ProgID
WINOLEAPI ProgIDFromCLSID( REFCLSID clsid,LPOLESTR * lplpszProgID);
例如我们已经定义了 CLSID_IApplication,下面的代码得到ProgID
LPOLESTR pProgID = 0;
ProgIDFromCLSID( CLSID_IApplication,&pProgID);
...///可以使用pProgID
CoTaskMemFree(pProgID);//不要忘记释放

七、ANSI与Unicode
Unicode称为宽字符型字串,COM里使用的都是Unicode字符串。

将ANSI转换到Unicode
(1)通过L这个宏来实现，例如: CLSIDFromProgID( L"MAPI.Folder",&clsid);
(2)通过MultiByteToWideChar函数实现转换,例如:
char *szProgID = "MAPI.Folder";
WCHAR szWideProgID[128];
CLSID clsid;
long lLen = MultiByteToWideChar(CP_ACP,0,szProgID,strlen(szProgID),szWideProgID,sizeof(szWideProgID));
szWideProgID[lLen] = '\0';
(3)通过A2W宏来实现,例如:
USES_CONVERSION;
CLSIDFromProgID( A2W(szProgID),&clsid);
将Unicode转换到ANSI
(1)使用WideCharToMultiByte,例如:
// 假设已经有了一个Unicode 串 wszSomeString...
char szANSIString [MAX_PATH];
WideCharToMultiByte ( CP_ACP, WC_COMPOSITECHECK, wszSomeString, -1, szANSIString, sizeof(szANSIString), NULL, NULL );
(2)使用W2A宏来实现,例如:
USES_CONVERSION;
pTemp=W2A(wszSomeString);

八、其它

对消息的处理中我们经常需要将WPARAM或LPARAM等32位数据（DWORD)分解成两个16位数据（WORD),例如：
LPARAM lParam;
WORD loValue = LOWORD(lParam);///取低16位
WORD hiValue = HIWORD(lParam);///取高16位
对于16位的数据(WORD)我们可以用同样的方法分解成高低两个8位数据(BYTE),例如:
WORD wValue;
BYTE loValue = LOBYTE(wValue);///取低8位
BYTE hiValue = HIBYTE(wValue);///取高8位
两个16位数据（WORD）合成32位数据(DWORD,LRESULT,LPARAM,或WPARAM)
LONG MAKELONG( WORD wLow, WORD wHigh );
WPARAM MAKEWPARAM( WORD wLow, WORD wHigh );
LPARAM MAKELPARAM( WORD wLow, WORD wHigh );
LRESULT MAKELRESULT( WORD wLow, WORD wHigh );
两个8位的数据(BYTE)合成16位的数据(WORD)
WORD MAKEWORD( BYTE bLow, BYTE bHigh );
从R(red),G(green),B(blue)三色得到COLORREF类型的颜色值
COLORREF RGB( BYTE byRed,BYTE byGreen,BYTE byBlue );
例如COLORREF bkcolor = RGB(0x22,0x98,0x34);
从COLORREF类型的颜色值得到RGB三个颜色值
BYTE Red = GetRValue(bkcolor); ///得到红颜色
BYTE Green = GetGValue(bkcolor); ///得到绿颜色
BYTE Blue = GetBValue(bkcolor); ///得到兰颜色

九、注意事项
假如需要使用到ConvertBSTRToString此类函数,需要加上头文件comutil.h,并在setting中加入comsupp.lib或者直接加上#pragma comment( lib, "comsupp.lib" )

后记：本文匆匆写成，错误之处在所难免，欢迎指正.

小熊 2007-11-01 09:30 发表评论

The difference between GetDC and GetWindowDC

小熊 — Sat, 21 Apr 2007 04:54:00 GMT

GetDC

The GetDC function retrieves a handle of a display device context (DC) for the client area of the specified window. The display device context can be used in subsequent GDI functions to draw in the client area of the window.

This function retrieves a common, class, or private device context depending on the class style specified for the specified window. For common device contexts, GetDC assigns default attributes to the device context each time it is retrieved. For class and private device contexts, GetDC leaves the previously assigned attributes unchanged.

HDC GetDC(

HWND hWnd // handle of window

);

Parameters

hWnd

Identifies the window whose device context is to be retrieved.

GetWindowDC

The GetWindowDC function retrieves the device context (DC) for the entire window, including title bar, menus, and scroll bars. A window device context permits painting anywhere in a window, because the origin of the device context is the upper-left corner of the window instead of the client area.

GetWindowDC assigns default attributes to the window device context each time it retrieves the device context. Previous attributes are lost.

HDC GetWindowDC(

HWND hWnd // handle of window

);

Parameters

hWnd

Identifies the window with a device context that is to be retrieved.

小熊 2007-04-21 12:54 发表评论

动态语言

小熊 — Mon, 16 Apr 2007 10:15:00 GMT

所谓动态语言，也叫脚本语言，就是说一种在执行期间才去发现数据类型的程序设计语言，主要创建一些需要经常更新的动态系统。常见的有Python, Lua, Perl, PHP等。

以往，我们所使用的语言，比如C，C++等等，都称为静态语言。什么是静态语言呢？就是说，在使用数据之前，我们必须首先定义数据类型，这些数据类型包括int, float, double等等。就相当于在使用它们之前，首先要为它们分配好内存空间；而动态语言就刚刚是相反的，它是在得到数据类型之后，再为它分配内存空间。

“脚本语言除了接近口语化的设计外，另加上简化后的语法。（除了内建的命令外，通常仅需简单的逻辑判断与数值计算即可胜任）因此用脚本语言制作游戏，不再是非程序员不可的工作（除了系统本身的修订），企画人员也可以很快地进入状态。另外，如果将来需要将游戏移植到其他平台时，比起程序与资料的盘根错节的设计，利用脚本语言来开发的游戏，只需要修改系统本身，脚本语言部分本身毋须更动，相形之下出现问题的机会与范围就缩小了很多。

小熊 2007-04-16 18:15 发表评论

Intel.VTune.Performance.Analyzer.v8.0.014.ISO下载

小熊 — Fri, 13 Apr 2007 08:07:00 GMT

http://down.gogobox.com.tw/kisser/7ir3
下载的时候要安装一个ActiveX插件的。

小熊 2007-04-13 16:07 发表评论

Finding crash information using the MAP file 2

小熊 — Tue, 10 Apr 2007 03:27:00 GMT

很奇怪，cppblog居然不能发表评论了，哭。。。所以就在发一篇了哦，呵呵。
Finding crash information using the MAP file
http://www.cppblog.com/jacky2019/archive/2007/04/09/21527.html
上文中的关于小说明的第2点是有问题的

偶又试了一次，发现lines number可能是有问题的，而且也不是我的那种算法。不过函数名肯定是对的

在vckbase中又发现一篇好文，所以就又贴过来了。不过可惜的是，还是没能解决dll的地址映射问题，无法track到dll内的信息，可惜了。

对“仅通过崩溃地址找出源代码的出错行”一文的补充与改进

作者：上海伟功通信 roc

下载源代码

　　读了老罗的“仅通过崩溃地址找出源代码的出错行”(下称"罗文")一文后，感觉该文还是可以学到不少东西的。不过文中尚存在有些说法不妥，以及有些操作太繁琐的地方。为此，本人在学习了此文后，在多次实验实践基础上，把该文中的一些内容进行补充与改进，希望对大家调试程序，尤其是release版本的程序有帮助。欢迎各位朋友批评指正。

一、该方法适用的范围
　　在windows程序中造成程序崩溃的原因很多，而文中所述的方法仅适用与:由一条语句当即引起的程序崩溃。如原文中举的除数为零的崩溃例子。而笔者在实际工作中碰到更多的情况是:指针指向一非法地址，然后对指针的内容进行了，读或写的操作。例如：

void Crash1()
{
char * p =(char*)100;
*p=100;
}

　　这些原因造成的崩溃，无论是debug版本，还是release版本的程序，使用该方法都可找到造成崩溃的函数或子程序中的语句行，具体方法的下面还会补充说明。另外，实践中另一种常见的造成程序崩溃的原因:函数或子程序中局部变量数组越界付值，造成函数或子程序返回地址遭覆盖，从而造成函数或子程序返回时崩溃。例如:

#include 
void Crash2();
int main(int argc,char* argv[])
{
Crash2();
return 0;
}
void Crash2()
{
char p[1];
strcpy(p,"0123456789");
}

在vc中编译运行此程序的release版本，会跳出如下的出错提示框。

图一上面例子运行结果

　　这里显示的崩溃地址为:0x34333231。这种由前面语句造成的崩溃根源，在后续程序中方才显现出来的情况，显然用该文所述的方法就无能为力了。不过在此例中多少还有些蛛丝马迹可寻找到崩溃的原因:函数Crash2中的局部数组p只有一个字节大小，显然拷贝"0123456789"这个字符串会把超出长度的字符串拷贝到数组p的后面，即*(p+1)=''1''，*(p+2)=''2''，*(p+3)=''3''，*(p+4)=4。。。。。。而字符''1''的ASC码的值为0x31，''2''为0x32，''3''为0x33，''4''为0x34。。。。。，由于intel的cpu中int型数据是低字节保存在低地址中，所以保存字符串''1234''的内存，显示为一个4字节的int型数时就是0x34333231。显然拷贝"0123456789"这个字符串时，"1234"这几个字符把函数Crash2的返回地址给覆盖，从而造成程序崩溃。对于类似的这种造成程序崩溃的错误朋友们还有其他方法排错的话，欢迎一起交流讨论。

二、设置编译产生map文件的方法
　　该文中产生map文件的方法是手工添加编译参数来产生map文件。其实在vc6的IDE中有产生map文件的配置选项的。操作如下:先点击菜单"Project"->"Settings。。。"，弹出的属性页中选中"Link"页，确保在"category"中选中"General"，最后选中"Generate mapfile"的可选项。若要在在map文件中显示Line numbers的信息的话，还需在project options 中加入/mapinfo:lines 。Line numbers信息对于"罗文"所用的方法来定位出错源代码行很重要，但笔者后面会介绍更加好的方法来定位出错代码行，那种方法不需要Line numbers信息。

图二设置产生MAP文件

三、定位崩溃语句位置的方法
　　"罗文"所述的定位方法中，找到产生崩溃的函数位置的方法是正确的，即在map文件列出的每个函数的起始地址中，最近的且不大于崩溃地址的地址即为包含崩溃语句的函数的地址。但之后的再进一步的定位出错语句行的方法不是最妥当，因为那种方法前提是，假设基地址的值是 0x00400000 ，以及一般的 PE 文件的代码段都是从 0x1000偏移开始的。虽然这种情况很普遍，但在vc中还是可以基地址设置为其他数，比如设置为0x00500000，这时仍旧套用

 崩溃行偏移 = 崩溃地址 - 0x00400000 - 0x1000

的公式显然无法找到崩溃行偏移。其实上述公式若改为

崩溃行偏移 = 崩溃地址 - 崩溃函数绝对地址 + 函数相对偏移

即可通用了。仍以"罗文"中的例子为例:"罗文"中提到的在其崩溃程序的对应map文件中，崩溃函数的编译结果为

0001:00000020 ?Crash@@YAXXZ 00401020 f CrashDemo。obj

对与上述结果，在使用我的公式时，"崩溃函数绝对地址"指00401020，函数相对偏移指 00000020，当崩溃地址= 0x0040104a时，则崩溃行偏移 = 崩溃地址 - 崩溃函数起始地址+ 函数相对偏移 = 0x0040104a - 0x00401020 + 0x00000020= 0x4a，结果与"罗文"计算结果相同。但这个公式更通用。

四、更好的定位崩溃语句位置的方法。
　　其实除了依靠map文件中的Line numbers信息最终定位出错语句行外，在vc6中我们还可以通过编译程序产生的对应的汇编语句，二进制码，以及对应c/c++语句为一体的"cod"文件来定位出错语句行。先介绍一下产生这种包含了三种信息的"cod"文件的设置方法:先点击菜单"Project"->"Settings。。。"，弹出的属性页中选中"C/C++"页，然后在"Category"中选则"Listing Files"，再在"Listing file type"的组合框中选择"Assembly，Machine code， and source"。接下去再通过一个具体的例子来说明这种方法的具体操作。

图三设置产生"cod"文件

准备步骤1)产生崩溃的程序如下:

01 //****************************************************************
02 //文件名称：crash。cpp
03 //作用:    演示通过崩溃地址找出源代码的出错行新方法
04 //作者：   伟功通信 roc
05 //日期：   2005-5-16
06//****************************************************************
07 void Crash1();
08 int main(int argc,char* argv[])
09 {
10 Crash1();
11 return 0;
12 }
13
14 void Crash1()
15 {
16  char * p =(char*)100;
17  *p=100;
18 }

准备步骤2)按本文所述设置产生map文件(不需要产生Line numbers信息)。
准备步骤3)按本文所述设置产生cod文件。
准备步骤4)编译。这里以debug版本为例(若是release版本需要将编译选项改为不进行任何优化的选项，否则上述代码会因为优化时看作废代码而不被编译，从而看不到崩溃的结果)，编译后产生一个"exe"文件，一个"map"文件，一个"cod"文件。
运行此程序，产生如下如下崩溃提示:

图四上面例子运行结果

排错步骤1)定位崩溃函数。可以查询map文件获得。我的机器编译产生的map文件的部分如下:

 Crash
Timestamp is 42881a01 (Mon May 16 11:56:49 2005)
Preferred load address is 00400000
Start Length Name Class
0001:00000000 0000ddf1H .text CODE
0001:0000ddf1 0001000fH .textbss CODE
0002:00000000 00001346H .rdata DATA
0002:00001346 00000000H .edata DATA
0003:00000000 00000104H .CRT$XCA DATA
0003:00000104 00000104H .CRT$XCZ DATA
0003:00000208 00000104H .CRT$XIA DATA
0003:0000030c 00000109H .CRT$XIC DATA
0003:00000418 00000104H .CRT$XIZ DATA
0003:0000051c 00000104H .CRT$XPA DATA
0003:00000620 00000104H .CRT$XPX DATA
0003:00000724 00000104H .CRT$XPZ DATA
0003:00000828 00000104H .CRT$XTA DATA
0003:0000092c 00000104H .CRT$XTZ DATA
0003:00000a30 00000b93H .data DATA
0003:000015c4 00001974H .bss DATA
0004:00000000 00000014H .idata$2 DATA
0004:00000014 00000014H .idata$3 DATA
0004:00000028 00000110H .idata$4 DATA
0004:00000138 00000110H .idata$5 DATA
0004:00000248 000004afH .idata$6 DATA
Address Publics by Value Rva+Base Lib:Object
0001:00000020 _main 00401020 f Crash.obj
0001:00000060 ?Crash1@@YAXXZ 00401060 f Crash.obj
0001:000000a0 __chkesp 004010a0 f LIBCD:chkesp.obj
0001:000000e0 _mainCRTStartup 004010e0 f LIBCD:crt0.obj
0001:00000210 __amsg_exit 00401210 f LIBCD:crt0.obj
0001:00000270 __CrtDbgBreak 00401270 f LIBCD:dbgrpt.obj
...

对于崩溃地址0x00401082而言，小于此地址中最接近的地址(Rva+Base中的地址)为00401060，其对应的函数名为?Crash1@@YAXXZ，由于所有以问号开头的函数名称都是 C++ 修饰的名称，"@@YAXXZ"则为区别重载函数而加的后缀，所以?Crash1@@YAXXZ就是我们的源程序中，Crash1() 这个函数。
排错步骤2)定位出错行。打开编译生成的"cod"文件，我机器上生成的文件内容如下:

 TITLE E:\Crash\Crash。cpp
.386P
include listing.inc
if @Version gt 510
.model FLAT
else
_TEXT SEGMENT PARA USE32 PUBLIC ''CODE''
_TEXT ENDS
_DATA SEGMENT DWORD USE32 PUBLIC ''DATA''
_DATA ENDS
CONST SEGMENT DWORD USE32 PUBLIC ''CONST''
CONST ENDS
_BSS SEGMENT DWORD USE32 PUBLIC ''BSS''
_BSS ENDS
$$SYMBOLS SEGMENT BYTE USE32 ''DEBSYM''
$$SYMBOLS ENDS
$$TYPES SEGMENT BYTE USE32 ''DEBTYP''
$$TYPES ENDS
_TLS SEGMENT DWORD USE32 PUBLIC ''TLS''
_TLS ENDS
; COMDAT _main
_TEXT SEGMENT PARA USE32 PUBLIC ''CODE''
_TEXT ENDS
; COMDAT ?Crash1@@YAXXZ
_TEXT SEGMENT PARA USE32 PUBLIC ''CODE''
_TEXT ENDS
FLAT GROUP _DATA， CONST, _BSS
ASSUME CS: FLAT, DS: FLAT, SS: FLAT
endif
PUBLIC ?Crash1@@YAXXZ     ; Crash1
PUBLIC _main
EXTRN __chkesp:NEAR
; COMDAT _main
_TEXT SEGMENT
_main PROC NEAR     ; COMDAT
; 9    : {
00000 55   push  ebp
00001 8b ec   mov  ebp， esp
00003 83 ec 40  sub  esp, 64   ; 00000040H
00006 53   push  ebx
00007 56   push  esi
00008 57   push  edi
00009 8d 7d c0  lea  edi, DWORD PTR [ebp-64]
0000c b9 10 00 00 00  mov  ecx， 16   ; 00000010H
00011 b8 cc cc cc cc  mov  eax， -858993460  ; ccccccccH
00016 f3 ab   rep stosd
; 10   :  Crash1();
00018 e8 00 00 00 00  call  ?Crash1@@YAXXZ  ; Crash1
; 11   :  return 0;
0001d 33 c0   xor  eax， eax
; 12   : }
0001f 5f   pop  edi
00020 5e   pop  esi
00021 5b   pop  ebx
00022 83 c4 40  add  esp, 64   ; 00000040H
00025 3b ec   cmp  ebp, esp
00027 e8 00 00 00 00  call  __chkesp
0002c 8b e5   mov  esp, ebp
0002e 5d   pop  ebp
0002f c3   ret  0
_main ENDP
_TEXT ENDS
; COMDAT ?Crash1@@YAXXZ
_TEXT SEGMENT
_p$ = -4
?Crash1@@YAXXZ PROC NEAR    ; Crash1, COMDAT
; 15   : {
00000 55   push  ebp
00001 8b ec   mov  ebp, esp
00003 83 ec 44  sub  esp, 68   ; 00000044H
00006 53   push  ebx
00007 56   push  esi
00008 57   push  edi
00009 8d 7d bc  lea  edi, DWORD PTR [ebp-68]
0000c b9 11 00 00 00  mov  ecx, 17   ; 00000011H
00011 b8 cc cc cc cc  mov  eax, -858993460  ; ccccccccH
00016 f3 ab   rep stosd
; 16   :  char * p =(char*)100;
00018 c7 45 fc 64 00
00 00   mov  DWORD PTR _p$[ebp], 100 ; 00000064H
; 17   :  *p=100;
0001f 8b 45 fc  mov  eax, DWORD PTR _p$[ebp]
00022 c6 00 64  mov  BYTE PTR [eax], 100 ; 00000064H
; 18   : }
00025 5f   pop  edi
00026 5e   pop  esi
00027 5b   pop  ebx
00028 8b e5   mov  esp, ebp
0002a 5d   pop  ebp
0002b c3   ret  0
?Crash1@@YAXXZ ENDP     ; Crash1
_TEXT ENDS
END

其中

?Crash1@@YAXXZ PROC NEAR    ; Crash1, COMDAT

为Crash1汇编代码的起始行。产生崩溃的代码便在其后的某个位置。接下去的一行为:

; 15   : {

冒号后的"{"表示源文件中的语句，冒号前的"15"表示该语句在源文件中的行数。这之后显示该语句汇编后的偏移地址，二进制码，汇编代码。如

00000 55   push  ebp

其中"0000"表示相对于函数开始地址后的偏移，"55"为编译后的机器代码，" push ebp"为汇编代码。从"cod"文件中我们可以看出，一条(c/c++)语句通常需要编译成数条汇编语句。此外有些汇编语句太长则会分两行显示如:

00018 c7 45 fc 64 00
00 00   mov  DWORD PTR _p$[ebp], 100 ; 00000064H

其中"0018"表示相对偏移，在debug版本中，这个数据为相对于函数起始地址的偏移(此时每个函数第一条语句相对偏移为0000)；release版本中为相对于代码段第一条语句的偏移(即代码段第一条语句相对偏移为0000，而以后的每个函数第一条语句相对偏移就不为0000了)。"c7 45 fc 64 00 00 00 "为编译后的机器代码，"mov DWORD PTR _p$[ebp]， 100"为汇编代码，汇编语言中";"后的内容为注释，所以";00000064H"，是个注释这里用来说明100转换成16进制时为"00000064H"。
接下去，我们开始来定位产生崩溃的语句。
第一步，计算崩溃地址相对于崩溃函数的偏移，在本例中已经知道了崩溃语句的地址(0x00401082)，和对应函数的起始地址(0x00401060)，所以崩溃地址相对函数起始地址的偏移就很容易计算了:

  崩溃偏移地址 = 崩溃语句地址 - 崩溃函数的起始地址 = 0x00401082 - 0x00401060 = 0x22。

第二步，计算出错的汇编语句在cod文件中的相对偏移。我们可以看到函数Crash1()在cod文件中的相对偏移地址为0000，则

崩溃语句在cod文件中的相对偏移 =  崩溃函数在cod文件中相对偏移 + 崩溃偏移地址 = 0x0000 + 0x22 = 0x22

第三步，我们看Crash1函数偏移0x22除的代码是什么?结果如下

 00022 c6 00 64  mov  BYTE PTR [eax], 100 ; 00000064H

这句汇编语句表示将100这个数保存到寄存器eax所指的内存单元中去，保存空间大小为1个字节(byte)。程序正是执行这条命令时产生了崩溃，显然这里eax中的为一个非法地址，所以程序崩溃了!
第四步，再查看该汇编语句在其前面几行的其对应的源代码，结果如下:

; 17   :  *p=100;

其中17表示该语句位于源文件中第17行，而“*p=100;”这正是源文件中产生崩溃的语句。
至此我们仅从崩溃地址就查找出了造成崩溃的源代码语句和该语句所在源文件中的确切位置，甚至查找到了造成崩溃的编译后的确切汇编代码!
怎么样，是不是感觉更爽啊?

五、小节

1、新方法同样要注意可以适用的范围，即程序由一条语句当即引起的崩溃。另外我不知道除了VC6外，是否还有其他的编译器能够产生类似的"cod"文件。
2、我们可以通过比较新方法产生的debug和releae版本的"cod"文件，查找那些仅release版本(或debug版本)有另一个版本没有的bug(或其他性状)。例如"罗文"中所举的那个用例，只要打开release版本的"cod"文件，就明白了为啥debug版本会产生崩溃而release版本却没有:原来release版本中产生崩溃的语句其实根本都没有编译。同样本例中的release版本要看到崩溃的效果，需要将编译选项改为为不优化的配置。

小熊 2007-04-10 11:27 发表评论

DeinoMPI

小熊 — Tue, 10 Apr 2007 02:57:00 GMT

DeinoMPI is an implementation of MPI-2 for Microsoft Windows.

DeinoMPI是微软windows下MPI-2的一个实现。

注：MPI-2是Message Passing Interface, http://www.mpi-forum.org/。What is MPI? MPI is a library of functions and macros which is intended for use in programs that exploit the existence of multiple processors by message-passing. 也就是说，MPI是一套规范，定义了一些函数和宏，它被用来在程序中通过消息传递来发挥多处理器的处理能力。

DeinoMPI is an implementation of the MPI-2 standard for parallel computing or more generally it is system level middle-ware for high performance parallel computing on Microsoft Windows systems. It supports Win32 and Win64 machines.

DeinoMPI是MPI-2的一个实现，MPI-2是for并行计算的。更通用地说，DeinoMPI是windows系统上的一个高性能并行计算的系统level中间件。它有两个版本，分别是for win32和for win64的。

1) DeinoMPI provides the libraries necessary for software developers to write parallel applications that conform to the MPI-2 standard for parallel computing. Software developers who wish to develop new parallel applications or wish to add parallel capabilities to existing software would benefit from using DeinoMPI. The libraries provided support a wide range of C, C++ and Fortran compilers.

2) DeinoMPI also provides a process manager used to start processes on multiple machines in a cluster remotely. Microsoft Windows does not provide native capability to start user applications on remote machines. DeinoMPI provides a secure mechanism to do just that. The primary purpose of the DeinoMPI process manager is to set up the environment and launch processes used in MPI jobs but it is not restricted to this functionality. It can launch any application remotely on behalf of the user.

The following users will benefit from DeinoMPI: Businesses that develop software and wish to add parallel capabilities to increase the performance of their software. Research institutions that have parallel software codes that they want to run on their Windows machines. Universities or other educational institutions that teach courses on parallel computing. University or research labs that run computationally intensive software and wish to use parallel versions of their software to better utilize their computer resources. Students or hobbyists that wish to write parallel programs.

小熊 2007-04-10 10:57 发表评论

可变参数研究

小熊 — Tue, 10 Apr 2007 02:38:00 GMT

一．何谓可变参数
int printf( const char* format, ...);
这是使用过C语言的人所再熟悉不过的printf函数原型，它的参数中就有固定参数format和可变参数（用”…”表示）. 而我们又可以用各种方式来调用printf,如:
printf("%d",value);
printf("%s",str);
printf("the number is %d ,string is:%s", value, str);
二.实现原理
C 语言用宏来处理这些可变参数。这些宏看起来很复杂，其实原理挺简单，就是根据参数入栈的特点从最靠近第一个可变参数的固定参数开始，依次获取每个可变参数的地址。下面我们来分析这些宏。在VC中的stdarg.h头文件中，针对不同平台有不同的宏定义，我们选取X86平台下的宏定义：
typedef char *va_list;
/*把va_list被定义成char*，这是因为在我们目前所用的PC机上，字符指针类型可以用来存储内存单元地址。而在有的机器上va_list是被定义成void*的*/
#define _INTSIZEOF(n) ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )
/*_INTSIZEOF (n)宏是为了考虑那些内存地址需要对齐的系统，从宏的名字来应该是跟sizeof(int)对齐。一般的sizeof(int)=4，也就是参数在内存中的地址都为4的倍数。比如，如果sizeof(n)在1－4之间，那么_INTSIZEOF(n)＝4；如果sizeof(n)在5－8之间，那么 _INTSIZEOF(n)=8。*/
#define va_start(ap,v)( ap = (va_list)&v + _INTSIZEOF(v) )
/*va_start 的定义为 &v+_INTSIZEOF(v) ,这里&v是最后一个固定参数的起始地址，再加上其实际占用大小后，就得到了第一个可变参数的起始内存地址。所以我们运行va_start (ap, v)以后,ap指向第一个可变参数在的内存地址*/
#define va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
/*这个宏做了两个事情，
①用用户输入的类型名对参数地址进行强制类型转换，得到用户所需要的值
②计算出本参数的实际大小，将指针调到本参数的结尾，也就是下一个参数的首地址，以便后续处理。*/
　　#define va_end(ap) ( ap = (va_list)0 )
/*x86 平台定义为ap=(char*)0;使ap不再指向堆栈,而是跟NULL一样.有些直接定义为((void*)0),这样编译器不会为va_end产生代码,例如gcc在linux的x86平台就是这样定义的. 在这里大家要注意一个问题:由于参数的地址用于va_start宏,所以参数不能声明为寄存器变量或作为函数或数组类型. */

以下再用图来表示:

在VC等绝大多数C编译器中，默认情况下，参数进栈的顺序是由右向左的，因此，参数进栈以后的内存模型如下图所示：最后一个固定参数的地址位于第一个可变参数之下，并且是连续存储的。
|——————————————————————————|
|最后一个可变参数 | ->高内存地址处
|——————————————————————————|
...................
|——————————————————————————|
|第N个可变参数 | ->va_arg(arg_ptr,int)后arg_ptr所指的地方,
| | 即第N个可变参数的地址。
|——————————————— |
………………………….
|——————————————————————————|
|第一个可变参数 | ->va_start(arg_ptr,start)后arg_ptr所指的地方
| | 即第一个可变参数的地址
|——————————————— |
|———————————————————————— ——|
| |
|最后一个固定参数 | -> start的起始地址
|—————————————— —| .................
|—————————————————————————— |
| |
|——————————————— |-> 低内存地址处

三.printf研究

下面是一个简单的printf函数的实现，参考了中的156页的例子，读者可以结合书上的代码与本文参照。
#include "stdio.h"
#include "stdlib.h"
void myprintf(char* fmt, ...) //一个简单的类似于printf的实现，//参数必须都是int 类型
{
char* pArg=NULL; //等价于原来的va_list
char c;

pArg = (char*) &fmt; //注意不要写成p = fmt !!因为这里要对//参数取址，而不是取值
pArg += sizeof(fmt); //等价于原来的va_start

do
{
c =*fmt;
if (c != '%')
{
putchar(c); //照原样输出字符
}
else
{
//按格式字符输出数据
switch(*++fmt)
{
case 'd':
printf("%d",*((int*)pArg));
break;
case 'x':
printf("%#x",*((int*)pArg));
break;
default:
break;
}
pArg += sizeof(int); //等价于原来的va_arg
}
++fmt;
}while (*fmt != '\0');
pArg = NULL; //等价于va_end
return;
}
int main(int argc, char* argv[])
{
int i = 1234;
int j = 5678;

myprintf("the first test:i=%d",i,j);
myprintf("the secend test:i=%d; %x;j=%d;",i,0xabcd,j);
system("pause");
return 0;
}
在intel+win2k+vc6的机器执行结果如下：
the first test:i=1234
the secend test:i=1234; 0xabcd;j=5678;

四.应用
求最大值:
#include //不定数目参数需要的宏
int max(int n,int num,...)
{
va_list x;//说明变量x
va_start(x,num);//x被初始化为指向num后的第一个参数
int m=num;
for(int i=1;i {
//将变量x所指向的int类型的值赋给y,同时使x指向下一个参数
int y=va_arg(x,int);
if(y>m)m=y;
}
va_end(x);//清除变量x
return m;
}
main()
{
printf("%d,%d",max(3,5,56),max(6,0,4,32,45,533));
}

本文转载自网上，本来是要注明出处的，结果别人也都是转载的，呵呵。不过此文讲的很不错，很清楚，特别是把可变参数实现的那几个宏！偶也是冲着这几个宏去的。

#define _INTSIZEOF(n) ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )
这个宏，一开始我就是想不明白！不知道是老了，还是笨了，或者是生锈了。想了好一会还是没搞明白，不过看了一下本文的分析，一下子就明白了，那是相当的恍然大悟啊。

#define va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )

这个宏，一开始也是没有明白。多看了好几遍才发现了奥秘所在啊，为什么要加一个，然后再减一个呢？因为第一个加直接加到ap上去了，而后一个减只是减了一下括号内的值，也就是当前值了。

宏真是厉害啊！或者说它应用真广！这不禁让我想起以前看过的宏，怎么判断是win还是linux平台的，怎么判断是32位的还是64位的。宏是一门学问啊。

本文的另一大优点是，有非常简单的例子，看了就懂。恩。看了保管你就会用了。不过这年头指针也是个好东西啊，需要什么，传个指针就是传了一切想要的东西啊，只要让指针指向你需要的东西，可以是任意多的参数（不过这样子的话，具体到哪个参数结束就要我们自己来定了，不像这里，所有的参数都已经压栈了，编译器可以帮我们决定具体有多少个参数，到什么时候结束）。

Have fun.

小熊 2007-04-10 10:38 发表评论

Rational Rose 2003下载地址

小熊 — Tue, 10 Apr 2007 01:22:00 GMT

http://www.21php.com/Rational Rose 2003.rar

昨晚下的，速度100K左右

小熊 2007-04-10 09:22 发表评论

谈谈面向对象

小熊 — Mon, 09 Apr 2007 12:52:00 GMT

面向对象是当前计算机界关心的重点，它是90年代软件开发方法的主流。面向对象的概念和应用已超越了程序设计和软件开发，扩展到很宽的范围。如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。

不过我想上面说的应该是国外吧！不知道国内的90年代OO是否风靡啊。偶是21世纪才开始接触电脑的。记得那时候老师在给我们上C++课的时候，拼命说什么C++好啊，面向对象啊，大说了一通。总之，给我的感觉是，OO才开始风靡。后来，学校里又开了一门课，叫着面向对象×××什么什么的，忘了，反正就是在讲面向对象。老师也是一个劲的给我们灌输OO思想，叫我们区别好OO与OP的差别。不知道为什么会有这么一段，可能想说国内的技术比国外的慢太多了。很多时候，其实，语言也是一种原因！毕竟国内好的翻译太少了！而且不能总是等侯杰大叔叔来翻译啊。记得以前在论坛上看到一句“名言”啊：不要看国内作者写的书，不要看国内译者翻译的书，括弧（侯杰除外）。看起来似乎有点偏激，不过却不无道理啊！很多的作者和译者都是垃圾啊！！！！偶深受其害，因为偶很爱买书（看书就。。。呵呵）。记得我去年看重构的时候，我觉得这个名词还是很新的啊，看了那本书之后才发现原来这本书写于上个世纪，昏迷啊，国内的技术太落后了。偶的e文也太落后了！要多关注关注国外的新技术。

扯远了。回来再谈OO。

OO，很早就已经学过了，很早以前就以为自己懂了，今天突然发现自己还不懂什么是OO，为什么要OO？以前的想法可能太简单了一点，认为只要是全都是对象就是OO了。

没错，在OO的思想中，所有一切东西都是O！但是，我发现在实际编程中，我连这一点都无法保证！而且，我也无法做到理论联系实际，把理论应用到实际。在实际运用中，几乎没有考虑过O的问题。更多的时候是在考虑什么模块怎么划分，一个模块应该有几个类阿，每个类都有些什么功能阿。但是我没有把那个类作为一个对象来考虑，或者说没有把那个类作为一类抽象的对象来考虑。需要什么东西就直接往里面加。不管加的东西跟那个类有没有关系，都往里面塞！行为相当恶劣。简直就是OP啊，每个类都成了一组function的wrapper了，相当悲哀！不管function是否应该属于该类（或者说该对象）。搞不好什么时候就设计出个：一个人有爬的行为！（结果肯定会被一群人狂揍哦）。

OO有什么优点呢？为什么要OO？

OO使人们得变成与实际的世界更加接近，所有的对象被赋予属性和方法，结果编程就更加富有人性化。

维护简单，模块化是面向对象编程中的一个特征。实体被表示为类和同一名字空间中具有相同功能的类，我们可以在名字空间中添加一个类而不会影响该名字空间的其他成员。

可扩充性，面向对象编程从本质上支持扩充性。如果有一个具有某种功能的类，就可以很快地扩充这个类，创建一个具有扩充的功能的类。

代码重用，由于功能是被封装在类中的，并且类是作为一个独立实体而存在的，提供一个类库就非常简单了。事实上，任何一个.NET Framework编程语言的程序员都可以使用.NET Framework类库，.NET Framework类库提供了很多的功能。更令人高兴的是，我们可以通过提供符合需求的类来扩充这些功能。

在实际的编程中你有考虑过这些问题吗？Sorry，偶是没有考虑过。基本上是，维护很难！扩充相对较容易，因为直接拷贝过来，在修改（这有算是OO吗？显然否）。这种根本就是没有利用到面向对象中的重用性。扩充起来也不容易，需要什么功能就胡乱继承一通，搞得类的层次太多了，无形之中给后人维护带来了极大的困难。出现这些情况的原因是什么呢？前面的代码设计的不够好。面向对象的三大特点：封装，继承和多态有没有都考虑进来？面向对象是一种思想，是我们考虑事情的方法，通常表现为我们是将问题的解决按照过程方式来解决呢，还是将问题抽象为一个对象来解决它。很多情况下，我们会不知不觉的按照过程方式来解决它，而不是考虑将要解决问题抽象为对象去解决它。有些人打着面向对象的幌子，干着过程编程的勾当。

OOA呢？OO对A有什么帮助呢？

OOA的主要优点

· 加强了对问题域和系统责任的理解；

· 改进与分析有关的各类人员之间的交流；

· 对需求的变化具有较强的适应性；

· 支持软件复用。

· 贯穿软件生命周期全过程的一致性。

· 实用性；

· 有利于用户参与。

OOA方法的基本步骤

在用OOA具体地分析一个事物时，大致上遵循如下五个基本步骤：
第一步，确定对象和类。这里所说的对象是对数据及其处理方式的抽象，它反映了系统保存和处理现实世界中某些事物的信息的能力。类是多个对象的共同属性和方法集合的描述，它包括如何在一个类中建立一个新对象的描述。

第二步，确定结构（structure）。结构是指问题域的复杂性和连接关系。类成员结构反映了泛化-特化关系，整体-部分结构反映整体和局部之间的关系。

第三步，确定主题（subject）。主题是指事物的总体概貌和总体分析模型。

第四步，确定属性（attribute）。属性就是数据元素，可用来描述对象或分类结构的实例，可在图中给出，并在对象的存储中指定。

第五步，确定方法（method）。方法是在收到消息后必须进行的一些处理方法：方法要在图中定义，并在对象的存储中指定。对于每个对象和结构来说，那些用来增加、修改、删除和选择一个方法本身都是隐含的（虽然它们是要在对象的存储中定义的，但并不在图上给出），而有些则是显示的。

OO是个好东西啊。要理解OO的思想，并能够在实际中运用它。不过OO现在已经不是最热的了，在现在web2.0的年代，基于网页上的应用会更火啊。你开发个软件，如果是单机版的，你都不好意思说！如果是C/S架构的，你也是会被BS的。呵呵。现在什么SOA，AJAX那个火啊！SOA是service oriented architecture，AJAX是什么东东？中间件、CRP、CPM等等，现在也是牛一B啊。学无止尽，学不能晒网啊；跟上时代的脚步，对新技术保持必要的触觉。恩。

以上纯属胡言乱语，部分摘自网上。如果有兴趣，偶欢迎大家一起来讨论啊。

小熊 2007-04-09 20:52 发表评论

Finding crash information using the MAP file

小熊 — Mon, 09 Apr 2007 05:45:00 GMT

非常好的一篇文章，from: http://www.codeproject.com/debug/mapfile.asp, by Wouter Dhondt

几点小说明
1、该文是针对vc6.0的，不过vs2003同样适用
In the C/C++ tab, select "Line Numbers Only" for Debug Info
对应于 Release-->C/C++ tab-->调试信息格式-->仅限行号(/Zd)

type the switches /MAPINFO:LINES and /MAPINFO:EXPORTS in the Project Options edit box.
对应于 Release-->链接器-->命令行-->附加选项(D): /MAPINFO:LINES /MAPINFO:EXPORTS

2、该文举的例子在查找行号的时候正好有一个与之对应的
119 0001:000001a1
不过我在试的时候，没有一个地址正好一致的。比如说我要找的是00000049，但是上面的信息只有
25 0001:00000042
27 0001:0000004a
是第25行呢？还是第27行？结果都不对，正确的似乎是49-42+25=32(32正好是源代码中出错的那一行，不知是不是巧合，未严格验证过！)

3、Line numbers信息有很多
Line numbers for .\release\main.obj(d:\main.cpp) segment .text
Line numbers for C:\Program Files\Microsoft Visual Studio .NET 2003\Vc7\lib\LIBC.lib(F:\VS70Builds\3077\vc\crtbld\crt\src\intel\strncpy.asm) segment .text
...
不过地址都是不一样的了（这个我也未严格验证）

4、既然都是可以算出来的，那是不是可以写一个软件来自动算出crash在哪一行呢？有现成的吗？有空研究一下。恩。

Have fun.

Introduction

Programming neat applications is one thing. But when a user informs you your software has crashed, you know it's best to fix this before adding other features. If you're lucky enough, the user will have a crash address. This will go a long way in solving the problem. But how can you determine what went wrong, using this crash address?

Creating a MAP file

Well first of all, you'll need a MAP file. If you don't have one, it will be nearly impossible to find where your application crashed using the crash address. So first, I'll show you how to create a good MAP file. For this, I will create a new project (MAPFILE). You can do the same, or adjust your own project. I create a new project using the Win32 Application option in VC++ 6.0, selecting the 'typical "Hello Word!" application' to keep the size of the MAP file reasonable for explanation.

Once created we need to adjust the project settings for the release version. In the C/C++ tab, select "Line Numbers Only" for Debug Info.

Many people forget this, but you'll need this option if you want a good MAP file. This will not affect your release in any way. Next is the Link tab. Here you need to select the "Generate mapfile" option. Also, type the switches /MAPINFO:LINES and /MAPINFO:EXPORTS in the Project Options edit box.

Now, you're ready to compile and link your project. After linking, you will find a .map file in your intermediate directory (together with your exe).

Reading the MAP file

After all this dull work, now comes the neat part: how to read the MAP file. We'll do this by using a crash example. So first: how to crash your application. I did this by adding these two lines at the end of the InitInstance() function:

char* pEmpty = NULL;
*pEmpty = 'x'; // This is line 119

I'm sure you can find other instructions which will crash your application. Now recompile and link. If you start the application, it will crash and you'll get a message like this: 'The instruction at "0x004011a1" referenced memory at "0x00000000". The memory could not be "Written".' .

Now, it's time to open the MAP file with notepad or something similar. You MAP file will look like this:

The top of the MAP file contains the module name, the timestamp indicating the link of the project, and the preferred load address (which will probably be 0x00400000 unless you're using a dll). After the header comes the section information that shows which sections the linker brought in from the various OBJ and LIB files.

Collapse

MAPFILE
Timestamp is 3df6394d (Tue Dec 10 19:58:21 2002)
Preferred load address is 00400000
Start         Length     Name                   Class
0001:00000000 000038feH .text                   CODE
0002:00000000 000000f4H .idata$5                DATA
0002:000000f8 00000394H .rdata                  DATA
0002:0000048c 00000028H .idata$2                DATA
0002:000004b4 00000014H .idata$3                DATA
0002:000004c8 000000f4H .idata$4                DATA
0002:000005bc 0000040aH .idata$6                DATA
0002:000009c6 00000000H .edata                  DATA
0003:00000000 00000004H .CRT$XCA                DATA
0003:00000004 00000004H .CRT$XCZ                DATA
0003:00000008 00000004H .CRT$XIA                DATA
0003:0000000c 00000004H .CRT$XIC                DATA
0003:00000010 00000004H .CRT$XIZ                DATA
0003:00000014 00000004H .CRT$XPA                DATA
0003:00000018 00000004H .CRT$XPZ                DATA
0003:0000001c 00000004H .CRT$XTA                DATA
0003:00000020 00000004H .CRT$XTZ                DATA
0003:00000030 00002490H .data                   DATA
0003:000024c0 000005fcH .bss                    DATA
0004:00000000 00000250H .rsrc$01                DATA
0004:00000250 00000720H .rsrc$02                DATA

After the section information, you get the public function information. Notice the "public" part. If you have static-declared C functions, they won't show up in the MAP file. Fortunately, the line numbers will still reflect the static functions. The important parts of the public function information are the function names and the information in the Rva+Base column, which is the starting address of the function.

Collapse

  Address         Publics by Value              Rva+Base     Lib:Object
0001:00000000       _WinMain@16                00401000 f   MAPFILE.obj
0001:000000c0       ?MyRegisterClass@@YAGPAUHINSTANCE__@@@Z 004010c0 f   MAPFILE.obj
0001:00000150       ?InitInstance@@YAHPAUHINSTANCE__@@H@Z 00401150 f   MAPFILE.obj
0001:000001b0       ?WndProc@@YGJPAUHWND__@@IIJ@Z 004011b0 f   MAPFILE.obj
0001:00000310       ?About@@YGJPAUHWND__@@IIJ@Z 00401310 f   MAPFILE.obj
0001:00000350       _WinMainCRTStartup         00401350 f   LIBC:wincrt0.obj
0001:00000446       __amsg_exit                00401446 f   LIBC:wincrt0.obj
0001:0000048f       __cinit                    0040148f f   LIBC:crt0dat.obj
0001:000004bc       _exit                      004014bc f   LIBC:crt0dat.obj
0001:000004cd       __exit                     004014cd f   LIBC:crt0dat.obj
0001:00000591       __XcptFilter               00401591 f   LIBC:winxfltr.obj
0001:00000715       __wincmdln                 00401715 f   LIBC:wincmdln.obj
//SNIPPED FOR BETTER READING
0003:00002ab4       __FPinit                   00408ab4     
0003:00002ab8       __acmdln                   00408ab8     
entry point at        0001:00000350
Static symbols
0001:000035d0       LeadUp1                    004045d0 f   LIBC:memmove.obj
0001:000035fc       LeadUp2                    004045fc f   LIBC:memmove.obj
//SNIPPED FOR BETTER READING
0001:00000577       __initterm                 00401577 f   LIBC:crt0dat.obj
0001:0000046b       _fast_error_exit           0040146b f   LIBC:wincrt0.obj

The public function part is followed by the line information (you got this if you used the /MAPINFO:LINES in the Link tab and selected the "Line numbers" in the C/C++ tab). After this, you will get the export information if your project contains exported functions and you included /MAPINFO:EXPORTS in the link tab.

Collapse

Line numbers for .\Release\MAPFILE.obj(F:\MAPFILE\MAPFILE.cpp) segment .text
24 0001:00000000    30 0001:00000004    31 0001:0000001b    32 0001:00000027
35 0001:0000002d    53 0001:00000041    40 0001:00000047    43 0001:00000050
45 0001:00000077    47 0001:00000088    48 0001:0000008f    52 0001:000000ad
53 0001:000000b3    71 0001:000000c0    80 0001:000000c3    81 0001:000000c8
82 0001:000000ff    86 0001:00000114    88 0001:00000135    89 0001:00000145
102 0001:00000150   108 0001:00000155   110 0001:00000188   122 0001:0000018d
115 0001:0000018e   116 0001:0000019a   119 0001:000001a1   121 0001:000001a8
122 0001:000001ae   135 0001:000001b0   143 0001:000001cc   172 0001:000001ee
175 0001:0000020d   149 0001:00000216   157 0001:0000022c   175 0001:00000248
154 0001:00000251   174 0001:0000025f   175 0001:00000261   151 0001:0000026a
174 0001:00000287   175 0001:00000289   161 0001:00000294   164 0001:000002a8
165 0001:000002b6   166 0001:000002d8   174 0001:000002e7   175 0001:000002e9
169 0001:000002f2   174 0001:000002fa   175 0001:000002fc   179 0001:00000310
186 0001:0000031e   193 0001:0000032e   194 0001:00000330   188 0001:00000333
183 0001:00000344   194 0001:00000349

Now we will look up where the crash occurred. First, we'll determine which function contains the crash address. Look in the "Rva+Base" column and search the first function with an address bigger than the crash address. The preceding entry in the MAP file is the function that had the crash. In our example our crash address is 0x004011a1. This is between 0x00401150 and 0x004011b0 so we know the crash function is ?InitInstance@@YAHPAUHINSTANCE__@@H@Z . Any function name that starts with a question mark is a C++ decorated name. To translate the name, pass it as a command-line parameter to the Platform SDK program UNDNAME.EXE (in the bin dir). You won't need to do this most of the time as you might figure it out just by looking at it (here: InitInstance() in MAPFILE.obj).

This is a big step for bug tracking. But it gets even better: we can find out on which line the crash occurred! We need to do some basic hexadecimal mathematics, so people whom can't do this without a calculator: now is the time to use it. The first step is the following calculation: crash_address - preferred_load_address - 0x1000
Addresses are offsets from the beginning of the first code section, se we need to do this calculation. Subtracting the preferred load address is logical, but why do we need to substract another 0x1000? The crash address is an offset from the beginning of the code section, but the first part of the binary isn't the code section! The first part of the binary is the Portable Executable (PE), which is 0x1000 bytes long. Mystery solved. In our example, this is: 0x004011a1 - 0x00400000 - 0x1000 = 0x1a1

Now it's time to look in the line information section of the MAP file. The lines are shown like this: 30 0001:00000004. The first number is the line number, the second number is the offset from the beginning of the code section in which this line occurred. If we want to look for our line number, we just have to do the same thing we did for the function: determine the first occurrence of a bigger offset than the one we just calculated. The crash occurred in the preceding entry. In our example: 0x1a1 is before 0x1a8. So our crash occurred on line 119 in MAPFILE.CPP.

Keeping track of MAP files

Each release had it's own MAP file. It's not a bad idea to include the MAP file with the exe distribution. This way, you can be certain you have the correct MAP file for this exe. You could keep every MAP file with every exe on your system, but we all know this might give some troubles later on. The MAP file doesn't contain any information you wouldn't want the user to see (unless maybe class and function names ?) . A user would have no use with it, but at least you can ask for the MAP file if you don't have a copy yourself.

小熊 2007-04-09 13:45 发表评论