我这里只是简单的丢了。

  1 //
  2 
  3 #include "stdafx.h"
  4 #include <windows.h>
  5 #include <time.h>
  6 #include <stdlib.h>
  7 
  8 #define MAX_BUF_LEN 20        // buf len // 必须要大于1
  9 int nRead = 0;                // read pos
 10 int nWrite = 0;                // write pos
 11 int buf[MAX_BUF_LEN] = {0}; // loop buf
 12 
 13 #define NN 20000
 14 __int64 sum = 0;
 15 __int64 lose = 0;
 16 __int64 total = (__int64)(1+NN)*(__int64)NN/2;
 17 bool bWriteFinished = false;
 18 
 19 void WriteBuf(int n)
 20 {
 21     int rpos = nRead;
 22     int wpos = nWrite;
 23     wpos++;
 24     // buf满（即write又追上了read）, 注为了避免与初始状态重复判断
 25     // 所以这里最后一个buf没有写就认为已经满了。所以MAX_BUF_LEN不能为1
 26     // 这里，直接丢弃该buf
 27     if (wpos % MAX_BUF_LEN == rpos % MAX_BUF_LEN)
 28     {
 29         lose += n;
 30         return;
 31     }
 32 
 33     buf[nWrite] = n;
 34     nWrite++;
 35     if (nWrite == MAX_BUF_LEN)
 36         nWrite = 0;
 37 }
 38 
 39 int ReadBuf()
 40 {
 41     if (nWrite == nRead)
 42         return -1;
 43 
 44     int n = buf[nRead];
 45     nRead++;
 46     if (nRead == MAX_BUF_LEN)
 47         nRead = 0;
 48     return n;
 49 }
 50 
 51 DWORD WINAPI ReadThread(LPVOID lpParameter)
 52 {
 53     int tmp = 0;
 54     int count = 0;
 55     while (true)
 56     {
 57         //printf("ReadThread = %d\n", ReadBuf());
 58         tmp = ReadBuf();
 59         if (-1 != tmp)
 60         {
 61             count++;
 62             sum += tmp;
 63             if (count == NN)
 64             {
 65                 printf ("ReadThread finished!\n");
 66                 break;
 67             }
 68         }
 69         else if (bWriteFinished)
 70         {
 71             printf ("ReadThread finished222!\n");
 72             break;
 73         }
 74 
 75         Sleep(rand() % 10);
 76     }
 77     return 0;
 78 }
 79 
 80 DWORD WINAPI WriteThread(LPVOID lpParameter)
 81 {
 82     int n = 0;
 83     while (true)
 84     {
 85         n++;
 86         WriteBuf(n);
 87         if (n == NN)
 88         {
 89             printf ("WriteThread finished!\n");
 90             bWriteFinished = true;
 91             break;
 92         }
 93 
 94         Sleep(rand() % 10);
 95     }
 96     return 0;
 97 }
 98 
 99 int main(int argc, char* argv[])
100 {
101     srand(time(NULL));
102 //     for (int i = 0; i < 10; i++)
103 //     {
104 //         printf ("rand = %d\n", rand() % 10);
105 //     }
106 
107     DWORD threadid[2] = {0};
108     HANDLE hThread[2] = {0};
109     int param = 0;
110     hThread[0] = CreateThread(NULL, 0, ReadThread, &param, CREATE_SUSPENDED, &threadid[0]);
111     ResumeThread(hThread[0]);
112     hThread[1] = CreateThread(NULL, 0, WriteThread, &param, CREATE_SUSPENDED, &threadid[1]);
113     ResumeThread(hThread[1]);
114 
115     getchar();
116 
117     printf ("total = %lld\n", total);
118     printf ("lose = %lld\n", lose);
119     printf ("sum = %lld\n", sum);
120 
121     if (total == lose + sum)
122     {
123         printf ("loop buf works well!\n");
124     }
125     else
126     {
127         printf ("loop buf works wrong!\n");
128     }
129 
130     return 0;
131 }
132 
上面是加了测试代码的，我测试了一下似乎没问题。

注意：这里只允许一个线程读，一个线程写。如果是多个线程读写的话，需要锁！

另外，很多细节都没考虑进去

定义：
        将常用的或很复杂的工作，预先用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为输出参数，用来承接我们所要的结果

一、汉字编码的种类

    汉字编码中现在主要用到的有三类，包括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 汉字编码范围

二、对汉字进行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;

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

通过上一次的教程后，大家都应该会使用boost.python了。把c++程序编译成pyd文件。由于c++有很多特性，所以，如果你的程

序用了很多的c++特性的话，那么你必须做很多工作了。像虚拟函数，函数重载，继承，默认值等等。具体如何转化，请参

boost.python的文档了。

这几天尝试着把c++程序库编译成python可调用的dll，不知道为什么一直不可用。。很是郁闷。老是显示如下的错误：

Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    import pydll
ImportError: No module named pydll

意思是说找不到dll。我把dll都copy到python/dlls下了还是不行，而且我确定python的sys.path包含了python/dlls目录了。

很是不解。网上也很难找到资料，google了很长时间找不到有用的资料，好像中文方面的资料很少的。今天尝试了一下google

英文资料，终于有了新的发现：
http://mail.python.org/pipermail/c++-sig/2007-February/011971.html
You are using Python2.5. In this version of Python you have to have
file extension
to be "pyd" - sge.pyd

--
Roman Yakovenko
C++ Python language binding
http://www.language-binding.net/

有人碰到的问题跟我的是一样的。后面那个Roman回答了一下，是文件扩展名的问题！！！为什么不支持dll呢？不解。回去试

了一下把后缀名改了就成功了。。。why???

下面来看一下我的那个简单的例子：
这个例子来自于网上，
http://www.vckbase.com/document/viewdoc/?id=1540
C++ 扩展和嵌入 Python
作者：胡金山
源码下载地址：http://www.vckbase.com/code/downcode.asp?id=2777

这是一个非常简单的dll工程。给python提供了一个函数static PyObject* Recognise(PyObject *self, PyObject *args)。

1、不使用boost.python库来直接构建dll
接下来，我们来用C++为Python编写扩展模块(动态链接库)，并在Python程序中调用C++开发的扩展功能函数。生成一个取名为

pyUtil的Win32 DLL工程，除了pyUtil.cpp文件以外，从工程中移除所有其它文件，并填入如下的代码：

// pyUtil.cpp
#ifdef PYUTIL_EXPORTS
#define PYUTIL_API __declspec(dllexport)
#else
#define PYUTIL_API __declspec(dllimport)
#endif

#include<windows.h>
#include<string>
#include<Python.h>
BOOL APIENTRY DllMain( HANDLE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
        )
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}
std::string Recognise_Img(const std::string url)
{
    //返回结果
    return "从dll中返回的数据... : " +url;
}
static PyObject* Recognise(PyObject *self, PyObject *args)
{
    const char *url;
    std::string sts;
    if (!PyArg_ParseTuple(args, "s", &url))
        return NULL;
    sts = Recognise_Img(url);
    return Py_BuildValue("s", sts.c_str() );
}
static PyMethodDef AllMyMethods[] = {
    {"Recognise",  Recognise, METH_VARARGS},//暴露给Python的函数
    {NULL,      NULL}        /* Sentinel */
};
extern "C" PYUTIL_API void initpyUtil()
{
    PyObject *m, *d;
    m = Py_InitModule("pyUtil", AllMyMethods); //初始化本模块，并暴露函数
    d = PyModule_GetDict(m);
}

在Python代码中调用这个动态链接库： (记得把dll的扩展名改为.pyd，另外dll的路径要能够被检索到)
import pyUtil
result = pyUtil.Recognise("input url of specific data")
print "the result is: "+ result

2、使用boost.python库来构建dll
用C++为Python写扩展时，如果您愿意使用Boost.Python库的话，开发过程会变得更开心J，要编写一个与上述pyUtil同样功能

的动态链接库，只需把文件内容替换为下面的代码。当然，编译需要boost_python.lib支持，运行需要boost_python.dll支持

。
#include<string>
#include <boost/python.hpp>
using namespace boost::python;
#pragma comment(lib, "boost_python.lib")
std::string strtmp;
char const* Recognise(const char* url)
{
    strtmp ="从dll中返回的数据... : ";
    strtmp+=url;
    return strtmp.c_str();
}
BOOST_PYTHON_MODULE(pyUtil)
{
    def("Recognise", Recognise);
}

可以非常明显地看到，用了boost.python库之后，简单了很多。因为boost.python为你做了很多的事情。。恩。

好像没有讲很多有用的东西，光顾着讲了，呵呵。。。我也还在继续学习之中。下次写点什么呢？继续学习了哦

有一段时间没写blog了。这几天都在研究怎么封装c++，让python可以用c++的库。在网上发现了boost.python这个好咚咚。不

过在使用过程中碰到一点问题。本文教大家如何把

char const* greet()
{
   return "hello, world";
}

封装成python。实际上这是python教程里面的咚咚。

首先下载Boost，www.boost.org。boost.python在boost里面了。在visual studio 2005 command prompt中navigation到

boost\boost_1_34_0\下。记得一定要用visual studio 2005 command prompt这个vs2005带的tools，不要用cmd.exe，否则会

碰到很多错误的。然后就是把bjam.exe拷贝到一个能被找到的目录下，或者直接也拷贝到boost\boost_1_34_0\下即可。然后，

设置python的根目录和python的版本，也可直接把它们加到坏境目录中，那样就不用每次都设置一下。
set PYTHON_ROOT=c:/python25
set PYTHON_VERSION=2.5

接着就可以直接运行了，bjam -sTOOLS=vc-8_0
整个编译过程要很长时间。。。

成功之后，就会有好多个boost_python-vc80-****.dll,.lib的，把他们都拷贝到一个能被系统找到的目录，不妨直接把他们都

扔到c:\windows\system32下。

接着，我们开始编译hello。navigation到boost\boost_1_34_0\libs\python\example\tutorial下，bjam -sTOOLS=vc-8_0运行

，在bin的目录下即会生成hello.pyd。这下就基本成功了，如果没成功的话，check一下上面boost_python的那些dll能否被系

统找到。另外，这里有python25的一个bug。。。我花了很长时间才在python的mail lists中找到了。寒。。。

错误如下所示：
D:\Learn\Python\boost\boost_1_34_0\libs\python\example\tutorial>bjam
Jamroot:17: in modules.load
rule python-extension unknown in module Jamfile</D:/Learn/Python/boost/boost_1_3
4_0/libs/python/example/tutorial>.
D:/Learn/Python/boost/boost_1_34_0/tools/build/v2/build\project.jam:312: in load
-jamfile
D:/Learn/Python/boost/boost_1_34_0/tools/build/v2/build\project.jam:68: in load
D:/Learn/Python/boost/boost_1_34_0/tools/build/v2/build\project.jam:170: in proj
ect.find
D:/Learn/Python/boost/boost_1_34_0/tools/build/v2\build-system.jam:237: in load
D:\Learn\Python\boost\boost_1_34_0\libs\python\example\..\..\..\tools\build\v2/k
ernel\modules.jam:261: in import
D:\Learn\Python\boost\boost_1_34_0\libs\python\example\..\..\..\tools\build\v2/k
ernel/bootstrap.jam:132: in boost-build
D:\Learn\Python\boost\boost_1_34_0\libs\python\example\boost-build.jam:7: in mod
ule scope

解决办法如下：
在boost\boost_1_34_0\tools\build\v2\目录下找到user-config.jam文件，打开在
import toolset : using ;
下面加一行代码：
using python ;
再重新编译一下boost，然后就没问题了。tutorial里面的hello能顺利编译通过。ps.这个问题困扰了我好长时间。。sigh。。

。

编译成功后会产生一个hello.pyd，在bin的目录下面。

有好多办法测试此hello.pyd是否可以用。
方法一，把它拷贝到python25\dlls下，打开IDLE，
>>> import hello
>>> hello.greet()
'hello, world'
>>>
方法二，直接在当前目录下写一个python文件，然后直接调用hello.pyd即可。总之，hello.pyd就是一个python文件了。。嗯

。操作hello.pyd根其他python文件是一样的。
这样就成功了。

如果碰到如下错误，是因为系统找不到boost_python的dll。强烈建议把他们都扔到system32下！。

>>> import hello

Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    import hello
ImportError: DLL load failed: 找不到指定的模块。
>>>

说明，hello.cpp在boost\boost_1_34_0\libs\python\example\tutorial目录下。里面的内容是：

//  Copyright Joel de Guzman 2002-2004. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt
//  or copy at http://www.boost.org/LICENSE_1_0.txt)
//  Hello World Example from the tutorial
//  [Joel de Guzman 10/9/2002]

char const* greet()
{
   return "hello, world";
}

#include <boost/python/module.hpp>
#include <boost/python/def.hpp>
using namespace boost::python;

BOOST_PYTHON_MODULE(hello)
{
    def("greet", greet);
}

其中
BOOST_PYTHON_MODULE(hello)
{
    def("greet", greet);
}
是对greet从c++向python的一个封装声明吧，装换就交给boost了。

先写到这里了。下次再写。。嗯

1. 首先讲讲元组的操作
由于参数是通过元组传进去的，所以我们不能老是通过Py_BuildValue这个函数来操作元组，那样太不方便了。
Python提供了元组相关的操作，下面这个例子演示了如何操作。主要是下面几个函数：
//new一个元组，传入size
pArgs = PyTuple_New(argc - 3); 
//set元组的直，第一个为元组，第二个为index（从0开始），第三个为value
PyTuple_SetItem(pArgs,0,Py_BuildValue("i",2000) );
PyTuple_SetItem(pArgs,1,Py_BuildValue("i",8) );

来自python doc的一个例子

#include <Python.h>
int
main(int argc, char *argv[])
{
    PyObject *pName, *pModule, *pDict, *pFunc;
    PyObject *pArgs, *pValue;
    int i;

    if (argc < 3) {
        fprintf(stderr,"Usage: call pythonfile funcname [args]\n");
        return 1;
    }

    Py_Initialize();
    pName = PyString_FromString(argv[1]);
    /* Error checking of pName left out */

    pModule = PyImport_Import(pName);
    Py_DECREF(pName);

    if (pModule != NULL) {
        pFunc = PyObject_GetAttrString(pModule, argv[2]);
        /* pFunc is a new reference */

        if (pFunc && PyCallable_Check(pFunc)) {
            pArgs = PyTuple_New(argc - 3);
            for (i = 0; i < argc - 3; ++i) {
                pValue = PyInt_FromLong(atoi(argv[i + 3]));
                if (!pValue) {
                    Py_DECREF(pArgs);
                    Py_DECREF(pModule);
                    fprintf(stderr, "Cannot convert argument\n");
                    return 1;
                }
                /* pValue reference stolen here: */
                PyTuple_SetItem(pArgs, i, pValue);
            }
            pValue = PyObject_CallObject(pFunc, pArgs);
            Py_DECREF(pArgs);
            if (pValue != NULL) {
                printf("Result of call: %ld\n", PyInt_AsLong(pValue));
                Py_DECREF(pValue);
            }
            else {
                Py_DECREF(pFunc);
                Py_DECREF(pModule);
                PyErr_Print();
                fprintf(stderr,"Call failed\n");
                return 1;
            }
        }
        else {
            if (PyErr_Occurred())
                PyErr_Print();
            fprintf(stderr, "Cannot find function \"%s\"\n", argv[2]);
        }
        Py_XDECREF(pFunc);
        Py_DECREF(pModule);
    }
    else {
        PyErr_Print();
        fprintf(stderr, "Failed to load \"%s\"\n", argv[1]);
        return 1;
    }
    Py_Finalize();
    return 0;
}

2. class操作
把下面加入到test2.py中去。定义了一个很简单的类，有一个name成员变量，一个printName成员函数
class TestClass:
    def __init__(self,name):
        self.name = name

    def printName(self):
        print self.name

cpp文件
#include <python.h>
int main()
{
 Py_Initialize();

 PyObject * pModule = NULL;
 PyObject * pFunc   = NULL;
 PyObject * pArg    = NULL;
 PyObject * pClass  = NULL;
 PyObject * pObject = NULL;

 pModule = PyImport_ImportModule("test2");
 pClass  = PyObject_GetAttrString(pModule, "TestClass");//得到那个类
 pArg = PyTuple_New(1);
 PyTuple_SetItem(pArg, 0, Py_BuildValue("s", "Jacky"));
 pObject = PyEval_CallObject(pClass, pArg);//生成一个对象，或者叫作实例

 pFunc = PyObject_GetAttrString(pObject, "printName");//得到该实例的成员函数
 PyEval_CallObject(pFunc, NULL);//执行该实例的成员函数

 Py_Finalize();

 return 0;
}

没有什么资料，就先写到这里了。下面介绍一下怎么build python25的源代码

3. 编译python源代码
为什么要编译呢？因为没有python25_d.lib！呵呵。顺便可以了解一下代码结构。
解压缩后，有好多目录，其中pcbuild和pcbuild8是我们要的。pcbuild对应着vc7.1的,pcbuild8对应着vc8.0的
因为在用vc7.1，也就是2003了。所以我就说说怎么用2003来编译吧。事实上是从一位牛人那里学来的

http://blog.donews.com/lemur/archive/2005/12/17/660973.aspx，那位大哥大概一年半前就在解剖python了，厉害

阿。看来我只能后来居上了，娃哈哈。我按照他说的试了一下，编译成功！

不过遇到一点小问题，用vc2003打开那个solution的时候，发现作者没有把source code control去掉，郁闷！害的我

们打开的时候一堆messagebox。不过不用管它就好了，一直确定。最后试了一下那个python25_d.lib，没问题。不过记

得把python25_d.dll copy到一个能被找到的目录，比如说c:\windows\system32\下面。python25.dll也在这个目录下

面。over。恩。

python文件
#Filename test2.py

def Hello(s):
    print "Hello, world!"
    print s

cpp文件
#include <python.h>
int main()
{
 Py_Initialize();

 PyObject * pModule = NULL;
 PyObject * pFunc   = NULL;
 PyObject * pArg    = NULL;

 pModule = PyImport_ImportModule("test2");
 pFunc   = PyObject_GetAttrString(pModule, "Hello");
 pArg    = Py_BuildValue("(s)", "function with argument");

 PyEval_CallObject(pFunc, pArg);

 Py_Finalize();

 return 0;
}

注意，参数要以tuple元组形式传入。因为这个函数只要一个参数，所以我们直接使用(s)构造一个元组了。

2. 一个有两个参数的例子

python文件中加入以下代码，一个加函数
def Add(a, b):
    print "a+b=", a+b

cpp文件，只改了两行，有注释的那两行
#include <python.h>
int main()
{
 Py_Initialize();

 PyObject * pModule = NULL;
 PyObject * pFunc   = NULL;
 PyObject * pArg    = NULL;

 pModule = PyImport_ImportModule("test2");
 pFunc   = PyObject_GetAttrString(pModule, "Add");//终于告别hello world了，开始使用新的函数
 pArg    = Py_BuildValue("(i,i)", 10, 15);//构造一个元组

 PyEval_CallObject(pFunc, pArg);

 Py_Finalize();

 return 0;
}

其它的就类似了。。。基本上，我们知道了怎么在c++中使用python中的函数。接下来学习一下如何使用python中的

class。

附：Py_BuildValue的使用例子，来自python documentation：

    Py_BuildValue("")                        None
    Py_BuildValue("i", 123)                  123
    Py_BuildValue("iii", 123, 456, 789)      (123, 456, 789)
    Py_BuildValue("s", "hello")              'hello'
    Py_BuildValue("ss", "hello", "world")    ('hello', 'world')
    Py_BuildValue("s#", "hello", 4)          'hell'
    Py_BuildValue("()")                      ()
    Py_BuildValue("(i)", 123)                (123,)
    Py_BuildValue("(ii)", 123, 456)          (123, 456)
    Py_BuildValue("(i,i)", 123, 456)         (123, 456)
    Py_BuildValue("[i,i]", 123, 456)         [123, 456]
    Py_BuildValue("{s:i,s:i}",
                  "abc", 123, "def", 456)    {'abc': 123, 'def': 456}
    Py_BuildValue("((ii)(ii)) (ii)",
                  1, 2, 3, 4, 5, 6)          (((1, 2), (3, 4)), (5, 6))

0. 坏境设置
把python的include/libs目录分别加到vc的include/lib directories中去。另外，由于python没有提供debug lib，体地说，就是没有提供python25_d.lib了。你可以自己编译python的源代码来得到python25_d.lib的，偶还没试过，呵呵。而且网上找了一下也没下载到。所以，如果你想要在debug下运行程序的话，你要把pyconfig.h（在python25/include/目录下）的大概是在283行，把pragma comment(lib,"python25_d.lib")改成pragma comment(lib,"python25.lib")，让python都使用非debug lib.

1. 开始编程了
#include <python.h>
第一步就是包含python的头文件

2. 看一个很简单的例子
1)python文件test.py，很简单的定义了一个函数

#Filename test.py
def Hello():
    print "Hello, world!"

这个应该能看懂的吧？否则的话，回去再练练python吧，呵呵。《简明Python教程》Swaroop, C. H. 著。沈洁元  译。

2)cpp文件

#include <python.h> //包含头文件，在c++中嵌入python，这是必须的
int main()
{
 Py_Initialize();

 PyObject * pModule = NULL;
 PyObject * pFunc   = NULL;

 pModule = PyImport_ImportModule("test");
 pFunc   = PyObject_GetAttrString(pModule, "Hello");
 PyEval_CallObject(pFunc, NULL);

 Py_Finalize();

 return 0;
}

第一步还是包含头文件

第二步，使用python之前，要调用Py_Initialize();这个函数进行初始化。
帮助文档中如是说：
The basic initialization function is Py_Initialize(). This initializes the table of loaded modules, and creates the fundamental modules __builtin__, __main__, sys, and exceptions. It also initializes the module search path (sys.path).

反正，一开始你一定要调用。

第三步，声明一些Python的变量，PyObject类型的。其实声明也可放在前面，这个倒是无所谓的。

第四步，import module，也就是你的脚本名字，不需要加后缀名，否则会出错的。

第五步，从你import进来的module中得到你要的函数
 pFunc   = PyObject_GetAttrString(pModule, "Hello");
上面的例子已经够清楚的了，最后一个是你要得到的函数的名字

第六步，调用PyEval_CallObject来执行你的函数，第二个参数为我们要调用的函数的函数，本例子不含参数，所以设置为NULL。

第七步，调用Py_Finalize，这个根Py_Initialize相对应的。一个在最前面，一个在最后面。

第一次写教程。这个例子非常简单，本人也还在学习当中阿，只能保证大家能够把这个例子运行起来。建议大家去看python的documentaion，里面有讲怎么embedding python的。先写到这里，其实目前也只学到这么多，呵呵。下次学了更多以后再写。Over。恩。

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.

首先，很容易想到的就是，求0的个数，就是求5的个数（如果这个你都想不明白的话，那就。。。再好好想想吧，呵呵）；

接下来，如何求5的个数呢？如果遍历一遍的话，那显然是太慢了！因为这种计算题太有规律了！想了好久，终于想出来了：

Result = 0; // 最后的结果

while ( N >= 5 )

{

 N /= 5;

 Result += N;

}

// 结束了。

没错，就是这么简单！下面简单说说为什么这样子做是对的（偶小试了一下，没问题，呵呵）：

第一次除以5表示5的倍数的个数，

第二次除以5表示5的平方的倍数的个数，（显然，5的平方暗含了两个0）

。。。依此类推

最后当N<5了，结束。

小小的验证一下：

26！

26/5 = 5， 5/5 = 1，那么最后0的个数就是6了。用Google算了一下，结果G大叔直接用有效数字表示了，@$%$%@$%。。。不过应该是没错了。恩。

Sigh，知道结果后才知道原来这么简单的阿，偶土了。

The same thing happens in life. We set goals and make plans - and sometimes discover that we're on "the wrong train."

Bi-vinat ha-lave literally means "understanding the heart." The heart is the seat of emotions. We say: "My heart is heavy, my heart is lifted, my heart is broken," etc. To understand your heart is to understand your true inner self.

Many people go through life making assumptions about who they are. They never take time to "meet" themselves. Don't be afraid of discovering that the "real you" may be different than the "current you."

Often a crisis hits at midlife when people ask: "What's my life about? Is this all worth it?" We've heard stories of people who suddenly change direction, quitting their job and getting divorced. You know, like the successful doctor who decides he never wanted to go into medicine in the first place -- so he drops it and becomes an artist.

Knowing yourself is the essence of being alive. If you don't know yourself, you are not living. If you don't know what makes you tick, you're a robot, a puppet, a zombie.

So don't wait for a crisis. Life is too short to take wrong trains.

GETTING STARTED

Think of someone you'd be fascinated to meet, someone you'd really like to find out what makes him tick.

Now realize the most fascinating person you could ever meet is ... yourself.

Sit down, say hello, and introduce yourself to yourself. Become familiar with yourself as if you'd just met a long-lost cousin. Interview yourself. Ask questions about your life and the direction you're going. Search out your dreams -- both the ones you're fulfilling and the ones you've pushed to the back of your mind.

Get down to basics. You want to be rich. You want to be famous. You want to be good. You want to accomplish. You want meaning. You want to be creative. But why do you want all this? What's driving you? What you really want out of life?

The process of self-discovery involves asking a series of questions, always probing deeper until the underlying truth emerges. Ask yourself 10 questions that you would ask an intimate friend. Then wait for answers. Don't worry, no one is going to poke fun at you.

1. What is the purpose of life?
2. What is my goal in life?
3. Why did I choose this career?
4. How do I spend my spare time?
5. What is my motivation for doing what I do?
6. What really makes me happy?
7. Am I as happy as I want to be?
8. Is it more important to be rich or to be happy?
9. What are my future plans? Why?
10. What are my secret dreams and ambitions?

Don't be surprised if the answers aren't immediate. This process can take many months. Stick with it and find out what makes you tick. The answers are hiding in there. After all, you have a fascinating partner.

Finally, the most important question to ask is:

"What am I living for?"

It sounds like a simple question, but many are embarrassed to ask it. A voice inside us says, "Nah, why ask such a basic question?" We're resistant because we know this requires a lot of difficult soul-searching. And when you thoroughly know yourself, then you have changed. You've changed your relationship with yourself and the world.

CONFIDENCE IN DECISION-MAKING

People often avoid making decisions out of fear of making a mistake.

Actually, the failure to make decisions is one of life's biggest mistakes.

Imagine the beggar who receives a letter saying that he's inherited a million dollars. If he doesn't read the letter, is he rich ... or not?

Similarly, God gave us the free will to make choices in life and achieve greatness. But if we're not aware of our free will, then we don't really have it. And then we wind up blaming others when things go wrong -- even though we know the decision is really up to us.

If you're not using your potential, it wears away at your confidence. Do you know what your potential is? Have you tried to use it? You have to tackle life. You haven't given up yet, have you? Let's get on with the game, with the business of really living, of not just "going through the motions."

Know the difference between "making decisions" and just floating, falling into place. Did you choose to go to college? Or perhaps you had nothing to do with the decision. Was it something you just did because you graduated high school and everybody else was doing it? Did you think it through and actually make a decision?

Imagine this private conversation of a college student:

Why am I going to college?
To get a degree.
Why?
Because I want to get into a good graduate school.
Why?
So I'll get a good job.
Why?
So I can pay back my college loans!

Through the process of questioning, he reveals a logical fault in his motivation. Really, the primary reason for going to college should be to acquire wisdom, knowledge and information. In other words, to get an education!

Now try the process yourself, using this example:

Why do I want to get married?

Don't accept pat answers. Keep asking "Why, why why?" Be frank. It's yourself. Ask any question you like. Be patient and persistent. Eventually you'll get an answer.

When you thoroughly analyze an issue, then you can make wise decisions with confidence.

Identify where you lack confidence. What makes you nervous? What situations inhibit you from being yourself? Why can't you make decisions? Is it that you don't know how to make decisions? Or that you doubt your decisions after they're made? Or you just don't feel like making decisions?

Enjoy making decisions. Deal with the world you live in. That's loving the dynamics of life.

ISOLATE YOUR BLOCKS

Anytime you find it difficult to achieve a goal, figure out what's holding you back.

Everyone has problems. Being aware of these problems is the key to getting in touch with yourself. Because as long as you don't face problems, they fester and bug you from behind.

Write your "blocks" on a piece of paper. That's a good step in the right direction. By isolating specific obstacles, you turn them into concrete challenges that require solutions.

Ask yourself:

• Am I lazy? Why?
• Am I disorganized? Why?
• Do I get angry? When?
• Why do ever I get defensive? About what?
• What makes me jealous?
• What makes me arrogant?
• Do I have trouble making decisions? Why?
• Do I lack self-discipline?
• Do I lack self-confidence?
• Why don't I take more initiative?

Negative character traits are the roots of our problems. Make a list of your negative traits, and identify when they affect you the most. Then analyze what triggers these reactions in you. Finally, formulate an effective counter-approach.

Working through this takes time. But do you have anything better to be doing right now?

READ YOUR EMOTIONS

Get in touch with your emotional state. Take a reading of how you feel. Happy? Angry? Tense? Sad? Emotions are a measuring stick for what's going on below the surface. It's like taking your temperature. If you're sick, you need to be aware so you can fix the problem.

Find out why you're upset. Who or what is pressuring you? Is it an internal or an external problem? Identify it.

Let's say you are irritated. Why?

Because the boss chewed me out.
So why am I irritated?
Because I resent him.
So what? Why does that bother me?
Because I feel I am no good.
I'm no good? He's nuts!

Get out of yourself and track it down. If you don't, it's just irritation. And the next thing you know, you'll go home and yell at your kids.

Once you've identified what causes negative feelings, adjust yourself to minimize the impact. Either avoid these situations, or prepare yourself to handle them when they arise.

Further, root out negative motivations that corrupt your behavior. Let's say that you give charity. Why? One motivation is to help humanity. Another is the pleasure of being constructive. A third is the desire to do the right thing. These are all positive motivations. A negative motivation for giving charity is: "I want people to admire me." That's corruptive.

The next time you give charity, do so anonymously. Eliminate the wrong reasons. They are destructive.

The same goes with the positive emotions. Be aware of how your emotional state affects decisions. For example, don't buy a new stereo when you're in a euphoric mood. Wait. Think it over. You are susceptible.

Pinpoint what makes you happy. You can have more joy on a daily basis by formulating some practical applications. You got up in the morning, it's a gorgeous day and you feet great. You're energized. Now take that feeling and teach yourself how to get up on the right side -- every day!

Another example: You did a good job and got the boss's compliment. Now focus: Do you need the boss to tell you did a good job? No! Create your own pleasure out of doing a good job.

GET IN TOUCH WITH YOUR TWO SIDES

Everyone has an urge for greatness. We want self respect, power, fame. We want to accomplish, to be strong, to do the right thing, to even save the world.

Yet at the same time, we have a counter-urge to run away from responsibility, to get into bed and crawl under the covers.

Someone may say, "Life is beautiful," but he doesn't feel it. His emotions hold him back and he walks around going, "Ugh, life is a burden."

Recognize the volcano of conflict within you: What you truly "want," versus what you "feel" like. This is the conflict between body and soul.

Once you appreciate the dichotomy, you can identify at any moment whether your body or soul is talking. This makes it possible to live with sanity and choose the right thing.

The next step is to make peace between your two sides. The easiest way is to squash your drive to be great. But life is not about taking the easy way out. Just because you feel uncomfortable about an idea doesn't mean it's wrong for you. It's hard to break habits, and growth can be frightening.

For example, would you rather be happy or rich? Okay, you'd rather be happy. Now imagine this exchange:

"Come on, I'll teach you how to be happy. All it requires is effort and change."

"Oh, I'd love to, but I can't right now. It's impossible. I've got a flight to catch."

"Really? I'll pay you $10,000 a week to work on happiness."

"Sure! Where do I sign up?"

"Oh, but I thought you can't right now..."

We conceal our problems with rationalization: "I'll wreck my mind thinking about what life is about! Nobody really knows what life is about. It's not going to work. Nothing can be done about it anyway. I don't really care. It's not worth the time!"

The Sages say that a person only makes a mistake when overcome by a moment of insanity. So realize that you are fighting "insanity." It is not logical. You've got to be on guard. Because if you get off track, you'll pay for it down the road.

So ... do you want to change? What have you got against it? Feel the antipathy of the body. We are so darn lazy. The body just wants to sleep. "Aaaah ... I don't want to change. I'm happy enough. I'm comfortable in my niche of misery." Are you rich enough? No! So are you happy enough?

You see the importance of tracking that down? You have to identify the animal you are fighting. "The dread of change."

If you're alert, you see the enemy. You can fight it. You may lose a struggle with the body, but at least you have your confidence. "I know what I am doing."

COAX THE BODY

Get in touch with your spiritual core. Know what is driving you. Don't let free will be a subconscious thing. You want greatness. But the body says that's too much effort.

To try to convince the body, try to identify the tangible benefit. "Why is it necessary? What will it do for me?" You have to bring it home to emotional realization. "What do I lose?" What do I gain?" Only then will the idea have power. And you'll get out there and do it.

Here's the secret formula: Identify with your intellect, and coax your heart along. For example, if you're emotionally convinced of the benefit of getting into shape, then even when you break out in a cold sweat and your heart is doing palpitations, you will keep going. Because you have decided, "I want this," you know it is important.

To avoid negative backlash, your emotions have to feel comfortable with the changes you make. Learn to relax and reassure the body. Cajole the body and say, "It won't be so bad. Remember the last time you made an effort, how great you felt!" Be encouraging and reward yourself for success.

Don't say it doesn't work. You haven't made the effort. Don't give up on your intuition and perception. Just realize you haven't yet brought it home to actualization.

Consider how the basic human drives affect you: security, self-respect, honor, passions, social pressure, and possessions. Pay particularly close attention to how you accept responsibility. Let's say that you made a mistake. You want to apologize in a full and forthright manner. Yet you feel like forgetting the whole thing, hiding, running away and saying "it's not my fault."

This is the volcano. We want to be tough, dedicated and powerful -- yet we feel like being marshmallows. Choosing the path of the soul doesn't come naturally. It takes a lot of time and hard work.

KNOW WHAT YOU KNOW

Don't think that just because you understand something, you are living with it. It is possible to believe one way, and yet act another. It happens to us all the time. You can believe it's important to eat healthy food, yet gorge yourself on French fries and chocolate cake.

Our actions are determined by our level of clarity. If we understand an idea on just a superficial level, then we'll have difficulty sticking to it when the going gets tough.

Next time you go to a funeral, watch carefully. When they remove the body from the chapel, the mourners start to cry. Are they crying because they want to body to stay there?! No. All of a sudden there is a realization of death, that he won't be coming back. At the cemetery, they lower the casket into the ground and the mourners cry again. It's the emotional realization that death is final now.

Until you align your feelings with reality, you are in dreamland. Growth begins in the mind, but your heart has to buy into everything your mind discovers. Only then will you integrate these ideas into day-to-day life.

A lot of people believe in God. There are very few people who live with God. Does that make sense? You have to assimilate something that you've accepted as true. It has to become part of you.

FIVE-FINGER CLARITY

You've got to know yourself cold, just like you know your hand has five fingers. How do you know you are on the right path? How do you know you're not making a mistake right now?

To develop this clarity, articulate the important principles that guide your life. For example, in Judaism we say that love is an obligation. Is this reasonable? Work the issue through with yourself:

"Ridiculous. You can't obligate me to love."
"But if I have children, will I love them?"
"Of course I'm going to love my kids!"
"How do I know? I don't know what kind of kids I'm going to have. Maybe they'll be brats and I won't love them."
"I will. I'm obligated to love my children."

Do you see the contradiction? On an intuitive level, you know that love is an obligation. But the concept is not so clear that you can articulate it.

Take your time. Sort out the basic aspects of living. Ask yourself important questions about life's global and spiritual issues.

--?What is the meaning of existence?
--?What's good about living?
--?How do I feel about humanity?
--?What is the afterlife?
--?How do I understand good versus evil?
--?Do I have free will? How do I activate it?
--?What makes me sad? Is it okay to be sad?
--?How do I feel about God?
--?Am I proud to be a Jew?
--?How do I understand the Holocaust?

Some of these topics may be unpleasant to think about. If so, why is it unpleasant? Track it down.

Don't just use slogans to parrot things that you heard. Know why you are doing what you are doing. Otherwise, it's just society talking. You may have adopted part of society without analyzing its validity. Check it out.

Work through all the issues until you have "five-finger clarity." A human being who knows what he wants will get there. By hook or by crook. It's like a homing mechanism on a missile. If you program it right, you will get there.

WHY IS "KNOWING YOURSELF" AN INGREDIENT IN WISDOM?

• You can know truth if you look honestly into yourself.
• Emotions are powerful forces of greatness. Know them. Harness them.
• Identify your problems. It's the beginning of solving them.
• If you don't get it straight now, you're bound to make some bad mistakes.
• Don't be afraid of finding out who you really are.
• Use your free will as a conscious tool for better living.
• If you're angry or upset, track it down. What's the root?
• If you're acting illogically, at least acknowledge that to yourself!
• The key to sanity is letting truth into the body.
• You can't afford to wait too long to get to know yourself. Because you are the most fascinating person you'll ever meet.

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

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

偶又试了一次，发现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版本要看到崩溃的效果，需要将编译选项改为为不优化的配置。

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.

以下再用图来表示:

在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.