C++博客-小明思考-随笔分类-C/C++

逆向三国群英2

小明 — Thu, 31 May 2012 13:53:00 GMT

闲来无事，搞搞逆向工程分析一下三国群英2，今天的目标是去掉光盘提示,并让游戏正常进行。因为我玩的是原版，所以每当直接运行sango2.exe会弹出如下对话框:

我使用的工具是大名鼎鼎的OllyDBG。

首先，打开OD,打开sango2.exe, 运行程序，当出现对话框时暂时程序，发现停在此处：

仔细看以下几行代码，可以看出在40B207处有一个判断，如果EAX=0，则不显示对话框，并跳转到40B21F，那如果我们把B207的“JE SHORT 0040B21F”改为“JNE SHORT 0040B21F”,是否就可以不显示对话框呢？经测试，确实不显示了，但是游戏也直接退出了，并没有达到我们要的效果。看来这个地方只是出错后的程序处理，我们要找到更深的源头，才能解决这个问题。

上断点！我们要结合单步调试来理解程序的运行逻辑才能发现真正的解决方案。

观察对话框出现的时候，程序的堆栈如下：

发现这个函数的入口在40B00A，我们在此设置断点开始单步调试，会发现在调用4300F0出现对话框，跟踪进去。

用这样的方法跟踪进去，保持耐心和清醒的头脑，最终会发现4302C8会进行错误处理，导致对话框的出现，只要跳过即可。我们修改4302C1的代码为"JZ short 004302D1"，即可跳过对话框，直接进行游戏。

最后一步，出补丁。使用右键功能【copy to executable】，然后另存为可执行文件就可以了。运行修改过后的sango2.exe，就会发现已经破解成功了。

小明 2012-05-31 21:53 发表评论

debug to fix crash

小明 — Fri, 27 Apr 2012 07:34:00 GMT

摘要: 最近遇到一个Windows Office Communicator 2007 崩溃的问题，有些意思，写下来跟大家分享。【现象】我们公司内部使用office communicator来做内部人员的IM工具，使用的是一个定制版本(plugin), 可以跟公司内部的组织架构做整合。我使用的OS是Windows 7 32bit,一开始使用并无问题，在某次windows update之后，发现没法添加好友，... 阅读全文

小明 2012-04-27 15:34 发表评论

那些leveldb使用的奇技淫巧1-内存管理

小明 — Wed, 28 Mar 2012 10:00:00 GMT

摘要: leveldb中内存管理的技巧阅读全文

小明 2012-03-28 18:00 发表评论

奇怪的g++的行为

小明 — Wed, 13 Aug 2008 08:56:00 GMT

摘要: 奇怪的g++的行为阅读全文

小明 2008-08-13 16:56 发表评论

printf的wrapper

小明 — Fri, 12 Oct 2007 06:13:00 GMT

摘要: 如何写printf的wrapper函数阅读全文

小明 2007-10-12 14:13 发表评论

如何写出专业的C头文件

小明 — Tue, 15 May 2007 05:38:00 GMT

摘要: 从lua源码中学到的一点小东西阅读全文

小明 2007-05-15 13:38 发表评论

C++源文件编码问题

小明 — Thu, 05 Apr 2007 07:30:00 GMT

摘要: C++源文件编码问题阅读全文

小明 2007-04-05 15:30 发表评论

{Just for fun} 如何让指针指向自己

小明 — Wed, 04 Apr 2007 04:16:00 GMT

摘要: 如何让指针指向自己阅读全文

小明 2007-04-04 12:16 发表评论

[STL] 循环中erase

小明 — Wed, 27 Dec 2006 10:01:00 GMT

摘要: [STL] loop & erase 阅读全文

小明 2006-12-27 18:01 发表评论

谈谈snprintf

小明 — Fri, 29 Sep 2006 02:27:00 GMT

摘要: snprintf的正确用法和错误用法阅读全文

小明 2006-09-29 10:27 发表评论

STL 备忘录

小明 — Wed, 12 Jul 2006 03:19:00 GMT

摘要: 使用标准库应该记住的一些东西(21条) 阅读全文

小明 2006-07-12 11:19 发表评论

G11N Developement (2) --- Linux Best Practice

小明 — Mon, 26 Jun 2006 08:57:00 GMT

在linux/Unix平台上面做G11N的开发，大抵都会用到gettext库/工具集( ftp://ftp.gnu.org/gnu/gettext/ ) 和libiconv(http://www.gnu.org/software/libiconv/) ,前者是用于实现Resource bundle,而后者用于各种编码转化。

(注:这里没有考虑cross-platform)

1. 实现方法

a . 使用po文件作为资源文件 (建议编码是utf-8)
一方面因为UTF-8兼容ANSI,另外一方面考虑到G11N的程序大部分使用utf-8输出，比如输出到database,web UI, file等等。

b. 使用getext从resource file ( mo文件)读到相应的L10N resource文件
注意这里需要先setlocale来设置locale

#include <stdio.h>
#include <locale.h>
#include <libintl.h>

#define _(string) gettext (string)

int main(int argc, char **argv)
{
    if (setlocale(LC_ALL, “”) == NULL) {
        fprintf(stderr, “setlocale() error.\n”);
        return -1;
}
if (bindtextdomain(package, “/usr/share/locale”) == NULL) {
    fprintf(stderr, “bindtextdomain() error.\n”);
    return –1;
}
    if (textdomain(package) == NULL) {
        fprintf(stderr, “textdomain() error.\n”);
        return –1;
}
    printf(“%s\n”, _(“Hello, world!”));
    return 0;
}

c.如果要输出到控制台(console),因为不是console都支持unicode output，所以推荐的方法是首先是把utf-8转化为本地编码，然后使用printf输出。不推荐使用wprintf进行输出，一方面是因为wchar_t的大小随编译器不同，不好控制。另外一方面，很多wprintf的实现也都是先把wchar_t[]转为本地编码，然后输出。转化编码使用libconv

d.如果要输出到web pages,database,file，编码推荐使用utf-8.

e.如果要输出本地化的日期和时间，使用API: strftime

#include <stdio.h>
#include <time.h>
int main(int argc, char **argv)
{
    time_t t;
    struct tm *ptm;
    char buffer[100];

    memset(buffer, 0, sizeof(buffer));
    if (time(&t) < 0) {
        fprintf(stderr, “time() error: %m\n”);
    }
    if ((ptm = localtime(&t)) == NULL) {
        fprintf(stderr, “localtime() error: %m\n”);
    }
    strftime(buffer, sizeof(buffer), “%x %X”, ptm);
    printf(“%s\n”, buffer);
    return 0;
}

f. 如果要输出本地化的数字和货币，使用API: strfmon

#include <stdio.h>
#include <monetary.h>

int main(int argc, char **argv)
{
    char buffer[100];
    strfmon(buffer, sizeof(buffer), “%=*i", 12345.67);
    printf(“%s\n”, buffer);
    return 0;
}

2.目录结构
/product
  /i18n
      /zh_TW
          your.mo
      /ja_JP
          your.mo

小明 2006-06-26 16:57 发表评论

深入 printf / wprintf / console下的unicode output

小明 — Wed, 21 Jun 2006 03:53:00 GMT

1. printf 只能提供ANSI/MB 的输出，不支持输出unicode stream.
例如:

wchar_t test[]=L"测试1234";
printf("%s",test);

是不会正确输出的

2.wprintf 同样不会提供unicode output,
但是他会把wchar_t的string转为locale的SB/MB字符编码，然后输出
例如：

wchar_t test[] = L"测试Test";
wprintf(L"%s",test);

会输出??1234之类的字符串，或者不输出任何结果
因为wprintf没有办法把L"测试Test"转为默认的ANSI,需要设置locale

setlocale(LC_ALL,"chs");
wchar_t test[] = L"测试Test";
wprintf(L"%s",test);

会有正确的输出
等同于printf("%ls",test);

综上: CRT I/O functions do not provide Unicode output.

3. Window console自从NT4就是一个真正的unicode console
不过输出unicode string,只有使用Windows API, WriteConsoleW
例如：

wchar_t test[] = L"测试1234";
DWORD ws;
WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE),test,wcslen(test),&ws,NULL);

可以正确的输出而不需要设置locale,因为是真正的unicode的输出，跟codepage无关

4. 如何实现跨平台的console output
不要使用wchar_t和wprintf,因为这些都依赖于编译器.
ICU是IBM的一个成熟的跨平台支持unicode的libary,推荐使用

以下是ICU的uprintf实现

void uprintf(const UnicodeString &str) {
    char *buf = 0;
    int32_t len = str.length();
    int32_t bufLen = len + 16;
    int32_t actualLen;
    buf = new char[bufLen + 1];
    actualLen = str.extract(0, len, buf/*, bufLen*/); // Default codepage conversion
    buf[actualLen] = 0;
    printf("%s", buf);
    delete buf;
}

它也是先把Unicode string转化为本地的codepage,然后printf，虽然也不是unicode output,但是跨平台，大多数情况会工作得很好。

小明 2006-06-21 11:53 发表评论

G11N Development(1) --- Unicode Basic && wxxx function

小明 — Mon, 19 Jun 2006 11:45:00 GMT

摘要: Globalization development 阅读全文

小明 2006-06-19 19:45 发表评论

漫谈函数的返回值

小明 — Tue, 25 Apr 2006 08:55:00 GMT

在windows的世界里面，很少有API没有返回值。但是到底返回什么代表成功，这个没有标准。我发现主要有三种模式

1 . 返回非0表示成功，返回0表示失败

大多数Win32 Platform API都是这样,比如

int result =MoveFileEx(szTempName,
                    "allcaps.txt",
                    MOVEFILE_REPLACE_EXISTING);

if(!result)
    {
        printf("Could not move file. error:%d",GetLastError());
        return 0;
    }

使用这种方法。你必须提供类似GetLastError的取错误的方法，而且你必须保证这个函数是thread-safe的，每个线程能维护自己的错误信息。

2. 返回大于等于0表示成功，返回-1表示失败
socket api大部分是这样设计的

while( bytesRecv != SOCKET_ERROR ) {
    bytesRecv = recv( ConnectSocket, recvbuf, 32, 0 );
    if ( bytesRecv == 0 || bytesRecv == WSAECONNRESET ) {
      printf( "Connection Closed.\n");
      break;
    }
    printf( "Bytes Recv: %ld\n", bytesRecv );
  }

这样的好处是返回值就可以用来表示成功和状态。比如这里的recv就可以返回收到的字节数。但是你还是要有一个查询错误的API,like WSAGetLastError().

3.返回0表示成功

COM的接口大部分是这样设计的

if( FAILED(lpdd->QueryInterface(IID_IDirectDraw7, (LPVOID *) &lpdd)))
    {
          //error handle and return
    }

其他的一些考虑

1.如何定义错误值？
简单的一点使用宏连续定义，like

#define E_NO_FILE 1
#define E_BAD_FILE 2

复杂的一点就像COM，严格的定义每一位的意义
这种情况下你可以提供一个宏来创建错误代码,like

#define MAKE_HRESULT(sev,fac,code)\

( (HRESULT) (((unsigned long)(sev)<<31) | ((unsigned long)(fac)<<16) \

| ((unsigned long)(code))) )

2.可以提供一个宏或者函数来帮助判断是否成功
比如COM提供了FAILED宏来帮助你判断COM的返回值

#define FAILED(Status) ((HRESULT)(Status)<0)

3.如果只有错误和成功两个返回值,考虑使用bool来返回
这个适用于C++,优点是意义很清晰.返回 true就是成功,false就是失败.

4.要使用异常来表示错误的状态么?
使用异常的好处就是返回值被省出来了，可以不返回或者返回其他信息，还有益于定义错误类型和简化程序流程。缺点就是C++对异常支持还不够好,没有finally,每一家编译器支持也不一样,实现可能大不同.

小明 2006-04-25 16:55 发表评论

Is it a vc6 bug?

小明 — Mon, 24 Apr 2006 10:08:00 GMT

#include < stdio.h >

int main()
{
     int a = 10 ,b = 20 ;

    a = (a + b) - (b = a);

    printf( " a=%d,b=%d\n " ,a,b);

     return 0 ;
}

很简单，交换a和b的值

在debug模式下，输出
a=20,b=10

在release模式下，输出
a=10,b=10

I think there is a bug in release version.

小明 2006-04-24 18:08 发表评论

C++代码静态分析工具-Prefast

小明 — Tue, 28 Mar 2006 05:59:00 GMT

1. 什么是Prefast

Prefast是一种代码分析工具，它能够帮助你找到编译器不能找到的错误或者缺陷。Prefast首次被微软集成到Visual Studio 2005 Team Suite中去，使用起来非常方便。

2.怎么使用Prefast
在vs2005 Team Suite中，使用Prefast非常简单。修改你的工程属性，设置Enable Code Analysis For C/C++为Yes.

效果:

注意到有可能错误的地方以浅灰色显示在编辑器中了。

3.Prefast能帮你找到哪些错误

1)没有初始化

// no initial
void defect1()
{
         int a;
         int b;

        b = a;
}

会报: d:\test\testcode\testcode.cpp(18) : warning C6001: Using uninitialized memory 'a': Lines: 15, 16, 18

2)空指针取值

// one path dereference NULL
void defect4( int b, int c)
{
         int * p = NULL;
         int a = 1 ;

         if (b == 1 ) {
                 if (c == 1 ) {
                        p = & a;
                }
                 else {

                }
        }
         else {
                 if (c == 1 ) {

                }
                 else {
                        p = & a;
                }
        }

         * p;

         return ;
}

会报:d:\test\testcode\testcode.cpp(65) : warning C6011: Dereferencing NULL pointer 'p': Lines: 45, 46, 48, 57, 65

3)可能错误的运算符优先级

void defect5()
{
         int a = 1 ;
         int b = 1 ;
         int c = 1 ;

         if (a & b == c)
                 return ;
}

会报: d:\test\testcode\testcode.cpp(76) : warning C6281: Incorrect order of operations: relational operators have higher precedence than bitwise operators

4)可能的buffer overrun

void defect8()
{
         char buf[ 100 ];
         char buf2[ 200 ];
         int i = 100 ;

        sprintf(buf, " hello world %d " , i);
        strcpy(buf, buf2);
}

会报: d:\test\testcode\testcode.cpp(133) : warning C6202: Buffer overrun for 'buf', which is possibly stack allocated, in call to 'strcpy': length '200' exceeds buffer size '100'

5)可能的无穷循环

// infinite loop
void defect14()
{
        signed char i;

         for (i = 100 ; i >= 0 ; i ++ ) {
                ;
        }
}

会报: d:\test\testcode\testcode.cpp(198) : warning C6292: Ill-defined for-loop: counts up from maximum

6)格式字符串错误

// Format string mismatch
void defect21()
{
char buff[ 5 ];
sprintf(buff, " %s %s " , " a " );
}

会报: d:\test\testcode\testcode.cpp(277) : warning C6063: Missing string argument to 'sprintf' that corresponds to conversion specifier '2'

7)安全问题

void defect27()
{
        CreateProcess(NULL,
                " c:\\program files\\Project.exe arg1 " , // correct "\"c:\\program files\\Project.exe\" arg1",
               NULL,
               NULL,
                false ,
                0 ,
               NULL,
               NULL,
               NULL,
               NULL);
}

会报: d:\test\testcode\testcode.cpp(327) : warning C6277: NULL application name with an unquoted path in call to 'CreateProcessA': results in a security vulnerability if the path contains spaces

8)=和==误用

void defect32()
{
         int a = 1 ;

         if (a = 2 )
                 return ;
}

会报: d:\test\testcode\testcode.cpp(405) : warning C6282: Incorrect operator: assignment of constant in Boolean context. Consider using '==' instead

9)逻辑运算问题

// always false
void defect45()
{
         int x;

         if ( 0 && x ++ ) {
                ;
        }
}

会报: d:\test\testcode\testcode.cpp(564) : warning C6237: ( && ) is always zero. is never evaluated and might have side effects

10)其他

小明 2006-03-28 13:59 发表评论

C++跨平台开发方法/工具

小明 — Fri, 24 Mar 2006 08:45:00 GMT

摘要: 主要阐述linux/windows跨平台开发
阅读全文

小明 2006-03-24 16:45 发表评论

再谈从vc6迁移到vs2005

小明 — Mon, 13 Mar 2006 03:03:00 GMT

   作为C++编译器，从vc6到vc8最大的调整就是对C++标准的支持更好了。
   我发现的几点不同。

a. For 循环的声明

      Vc6: for(int i<0;i<100;++i){}; j = i;   (ok)

Vc8: for(int i<0;i<100;++i){}; j = i; (illegal)

int i; for(i<0;i<100;++i){}; j = i; (ok)

Vc8中的for循环中变量的有效期仅仅在for 循环的开始与结束期间有效。

b.string实现

Vc6: string s; char *p = s.begin(); (ok)

Vc8: string s; char *p = s.begin(); (illegal)

string s; char *p = const_cast(s.c_str()); (ok)

在vc6中,string::iterator被定义为char *,但是vc8中不是

c.更严格的typename声明的需要

Vc6:

template

class Test

{

public:

typedef map mymap;

mymap::iterator mymap_iter;

}; (ok)

Vc8:

template

class Test

{

public:

typedef map mymap;

mymap::iterator mymap_iter;

}; (illegal)

typename mymap::iterator mymap_iter;(ok)

vc8更加严格的要求程序员在类型前面加上typename以避免歧义

d.不允许默认的int类型

Vc6: fun() { return 0;} (ok)

Vc8: fun() { return 0;} (illegal)

int fun() { return 0;} (ok)

vc8不支持默认返回int类型

e.typedef必须是public才能被外界访问到

Vc6:

Class Test

{

typedef int iterator;

};

Test::iterator i; (ok)

Vc8:

Class Test

{

typedef int iterator;

};

Test::iterator i; (illegal)

Class Test

{

public:

typedef int iterator;

};

Test::iterator i; (ok)

附录：一些资源（From msdn)

Overviews:

Moving from 6.0 to 7.1:

ATL/MFC Breaking changes (6.0 to 7.0) (also seen here but the list isn't as long)
ATL/MFC Breaking changes (7.0 to 7.1)
Standard c++ Library changes and issues specific to upgrading
Compiler breaking changes
In-depth info on increased standards compliance
Project upgrading

Moving from 7.1 to 8.0:

Libraries breaking changes
ATL obsolete topics and deprecated functions with replacements
MFC obsolete topics
Compiler breaking changes
Deprecated compiler options
Some removed linker options (mentioned here and here)
Preprocessor changes

小明 2006-03-13 11:03 发表评论

Java中最值得C++借鉴的特性s

小明 — Wed, 25 Jan 2006 03:40:00 GMT

摘要: 讨论Java和C++ 阅读全文

小明 2006-01-25 11:40 发表评论

从全局变量到IOC模式

小明 — Fri, 20 Jan 2006 09:23:00 GMT

很早以前，在我初学c语言的时候，我的第一个象样的程序是一个五子棋程序，使用了TC2.0的图形库，纯面向过程的设计，由上到下的设计，而且只有一个c文件就搞定了，大概几百行，可惜代码已经失传，非常可惜。

为什么要全局变量?
List 1

int main()
{
int s1,s2,s3;
fun1(s1);
fun2(s1,s2);
fun3(s1,s2,s3);
return 0;
}

上面的s1,s2,s3如果改成全局变量，则变为
List 2

int s1,s2,s3;

int main()
{
    fun1();
    fun2();
    fun3();
}

似乎简洁了一些，而且没有了传递参数的开销。但是缺点也是很明显的，带了三个函数之间的耦合。

既然我们认识到全局变量的问题，怎么改进呢？
代码1中由于有三个变量，如果有更多的，就更麻烦，我们可以这样改进
List 3

typedef struct statusTag
{
    int s1,s2,s3;
}Status;

int main()
{
    Status s;
    fun1(&s);
    fun2(&s);
    fun3(&s);
    return 0;
}

这种技巧你可以在lua中看到，看lua的使用代码
List4

#include "lua.h"
#include "lauxlib.h"
#include "lualib.h"

int main(int argc, char *argv[])
{
    lua_State *L = lua_open();
    const char *buf = "var = 100";
    int var ;
    luaopen_base(L);
    luaopen_io(L);
    lua_dostring(L, buf);
    lua_getglobal(L, "var");
    var = lua_tonumber(L, -1);
    lua_close(L);

    return 0;
}

请注意到这里的lua_open方法，这其实是一种创建自己的工厂方法。不使用全局变量的好处就是，我们保留了可以创建多个对象的自由。

时代在发展，进入C++时代，但是全局变量仍然有人在用，存在就是合理的。GOF提出一种设计模式叫Singleton的模式，其核心思想就是不让全局变量漂浮在空中，把它放入class中，成为衣冠楚楚的C++公民。著名的Meyer Singleton像这样
List 5

class Status
{
private:
    Status(){};
public:
    static Status& getInstance()
    {
           static Status s;
           return s;
    }
};

class User
{
    void fun()
    {
        Status &s = Status::Instance();
        //. . .use s
    }
};

一切似乎很完美，使用private来防止client 创建它，保证了对象的唯一性(注意:Meyer singleton并不具有多线程安全，可能导致多次初始化对象)

但是随着针对接口编程和单元测试越来越流行，singleton带来的对单元测试不友好的特点日益体现，全局变量不能很好的被mock，所以难于测试。

这时候所谓的IOC思想(Inversion of Control，即反转模式)出来了，简单的来说，就是通过构造函数或者set方法实现注入

List6 - 构造函数注入

class Status{};

class User
{
   public:
      User(Status *s):m_ps(s){};
      void fun()
      {
           Status *s = m_ps;
      }
   private:
      Status *m_ps;
}

List7 - Set 注入

class Status{};

class User
{
   public:
      User(){}

      void setStaus(Status *s)
      {
           m_ps = s;
      }

      void fun()
      {
           Status *s = m_ps;
      }
   private:
      Status *m_ps;
}

使用IOC的好处是带来了更强大的灵活性，但是带来的问题就是调用者麻烦了(天下没有免费的午餐阿）

List8

int main()
{
   Status s;
   User u;
   u.setStatus(&s);
   u.fun();
   return 0;
}

好像一切又返朴归真，似乎并没有带来什么简单。有的时候简单和灵活性就是死对头。

为了简化用户进行手工注入，IOC容器出现，在Java世界里面，最著名的莫过于Spring了.IOC容器就像一个巨大的创建工厂，她可以使用xml来配置这些，这真的是一场革命。

<beans>
    <bean id="status" class="Status">
    bean>

    <bean id="user" class="User">
        <property name="status"><ref bean="status"/>property>
    bean>
beans>

Spring就是这样把注入的工作移到配置文件中去，提供了强大的灵活性和可配置性

但是由于c/c++ 不具备的java那么多运行期的类型识别和反射的功能，所以我目前还没有发现有在C++中使用的IOC容器，如果你知道，请告诉我

那么如果是C++怎么来使注入变得简单一点呢，可以使用工厂方法了

List9

User * createUser(Status &s,Status2 &s2)
{
   User *user = new User();
   user->setStatus(s);
   user->setStatus2(s2);
   return user;
}

总结:
其实软件的设计根本就没有所谓的黄金法则，没有免费的午餐，你在获得更强大的灵活性，往往都得到复杂性的附加效果。如果你就是写一个自己玩的小游戏，ok,你就是用全局变量。如果你要设计庞大的Office,那你就没有办法把代码写的很简单，因为你要考虑的东西多了，可维护性，可测试性。

小明 2006-01-20 17:23 发表评论

C++编译期Constraints设计

小明 — Tue, 17 Jan 2006 06:12:00 GMT

所谓的compile-time Constraints就是在编译期使用C++的语法规则对设计进行约束检查，尽量在编译期把程序的问题暴露出来，节省成本。

常用的规则:
1.大小为0的数组在编译期会报错

template<typename T1,typename T2>
void check_size()
{
int dmp[sizeof(T1)==sizeof(T2)];
}

比如
check_size();//ok
check_size();//compile error:cannot allocate an array of constant size 0

2.不同类型的指针需要强制转换
以此可以用来判断两个对象是否有继承关系

template<typename T1,typename T2>
void is_derived(T1 *pd =0 ,T2 *pb=0)
{
pb = pd;
}

比如:
is_derived() //compile failed

3.union的成员不能是非POD
union Test
{
std::string s; //illegal
};
这一点可以用来测试一个类型是否是POD

template<typename T>
void check_pod()
{
    union {
        T data;
    };
};

比如:
check_pod();//ok
check_pod();//failed

常用的技巧:

1.利用模板特化
Loki里面的例子

namespace Loki
{
    template<int> struct CompileTimeError;
    template<> struct CompileTimeError<true> {};
}

#define LOKI_STATIC_CHECK(expr, msg) \
    { Loki::CompileTimeError<((expr) != 0)> ERROR_##msg; (void)ERROR_##msg; }

利用特化来定制错误信息

2.利用空函数来实现0开销
编译器可能将空函数优化掉

3.利用enum无开销的取得编译期的所得到的整数值
Loki里面的例子:

template <class TList> struct Length;
        template <> struct Length<NullType>
        {
            enum { value = 0 };
        };

        template <class T, class U>
        struct Length< Typelist<T, U> >
        {
            enum { value = 1 + Length<U>::value };
        };

小明 2006-01-17 14:12 发表评论

什么才是多线程安全的

小明 — Thu, 12 Jan 2006 09:45:00 GMT

对于多线程编程，很多人概念不清，写代码的时候要么是处处加锁，影响性能不说，还容易莫名其妙的死锁，还有人对多线程敬而远之。

所以学习多线程编程最重要的不是学习API,而是理解什么才是多线程安全的代码

从例子说起

#include <windows.h>
#include <process.h>

long global1 = 0;
volatile long global2 = 0;

class MyClass
{
public:
    MyClass() : m(0)
    {
        ++m;
    }

    int fun(int v)
    {
        return m+v; //-----------9
    }

    void set(int v)
    {
        m = v;   //-------------10
    }
    int m;
};

MyClass global_object; //-------------8

unsigned int __stdcall thread_fun1(void *param)
{
    static int static2 = 0;
    static MyClass static_object; //--------6
    int local1 = 0;

    ++local1;     //-------1
    ++static2;    //-------2
    ++global1;    //-------3
    ++global2;    //-------4
    InterlockedIncrement(&global1); //--------5

    local1 = global_object.fun(local1); //----------7

    global_object.set(local1); //---------------11

    return 0;
}

unsigned int __stdcall thread_fun2(void *param)
{
    ++global1;    //-------3
    ++global2;    //-------4
    InterlockedIncrement(&global1); //--------5

    global_object.set(1); //-----------11
    return 0;
}

int main()
{
    HANDLE thread1 = (HANDLE)_beginthreadex(0,0,&thread_fun1,0,0,0); //thread 1
    HANDLE thread2 = (HANDLE)_beginthreadex(0,0,&thread_fun1,0,0,0); //thread 2
    HANDLE thread3 = (HANDLE)_beginthreadex(0,0,&thread_fun2,0,0,0); //thread 3

    WaitForSingleObject(thread1,INFINITE);
    WaitForSingleObject(thread2,INFINITE);
    WaitForSingleObject(thread3,INFINITE);

    return 0;
}

1.局部变量局部使用是安全的
为什么?因为每个thread 都有自己的运行堆栈，而局部变量是生存在堆栈中,大家不干扰。
所以代码1
int local1;
++local1;
是安全的

2.全局原生变量多线程读写是不安全的
全局变量是在堆(heap)中
long global1 = 0;
++global2;
++这个操作其实分为两部，一个是读，另外一个是写
mov         ecx,global
add         ecx,1
mov         global,ecx
所以代码3处是不安全的

3.函数静态变量多线程读写也是不安全的
道理同2
所以代码2处也是不安全的

4.volatile能保证全局整形变量是多线程安全的么
不能。
volatile仅仅是告诫compiler不要对这个变量作优化，每次都要从memory取数值，而不是从register
所以代码4也不是安全

5.InterlockedIncrement保证整型变量自增的原子性
所以代码5是安全的

6.function static object的初始化是多线程安全的么
不是。
著名的Meyer Singleton其实不是线程安全的
Object & getInstance()
{
     static Object o;
     return o;
}
可能会造成多次初始化对象
所以代码6处是不安全的

7.在32机器上，4字节整形一次assign是原子的
比如
i =10; //thread1
i=4; //thread2
不会导致i的值处于未知状态,要么是10要么是4

其它的大家自己去体会。

写好多线程安全的法宝就是封装，使数据有保护的被访问到
安全性：
局部变量>成员变量>全局变量

小明 2006-01-12 17:45 发表评论

诡异的C

小明 — Mon, 09 Jan 2006 06:04:00 GMT

1.无穷loop

int i,a[10];
for(i=0;i<=10;++i)
{
a[i] = 0 ;
}

why?
函数运行时堆栈：
a[0] a[1] ....a[9] i
a[10] = 0;改变i的值为0,造成无穷循环

2.八进制的误用

int i[] = {    012,
                   024,
                   125,
           };

为了对齐可能造成的错误，变成了八进制

3.如何调用地址为0的过程？
(*(void(*)())0)();
ps:在大多数现代操作系统，进程引用的地址为虚拟地址，所以这个调用可能合法

4.运算符的优先级

int i = 1;
i = i<<4 + 2;

这时i的值是多少？
不是18，是64，因为 i=i<<4+2; <==> i=i<<(4+2);

5.悬挂的if

if(x==0) //1
      if(y==0) error(); //2
else{ //3
       z=x+y;
       f(&z);
}

C中的else总是和最近的if匹配，所以3和2匹配，而不是和1匹配。等价于

if(x==0) //1
{
      if(y==0) error(); //2
      else{ //3
           z=x+y;
           f(&z);
      }
}

解决方法：总是使用{}和if配对

小明 2006-01-09 14:04 发表评论

C++性能优化实践2---选择合适的容器

小明 — Thu, 05 Jan 2006 05:07:00 GMT

有很多性能问题，在系统使用的初期，不大能看出来，因为使用量的很小。随着系统的不断深入使用，性能问题才出现，尤其是那种24*7都要不停运行的程序。

下面的一个例子，是经常在项目中都会用到的.ini配置文件生成和解析的过程
比如

[section1]
   key1 = value1 ;here is comment
   key2 = value2
[section2]
   key3 = value3
   key4 = value4

当然WinAPI也提供了WritePrivateProfileString,GetPrivateProfileString两个API来读写这种文件格式，但是
每次使用都会打开文件来读写，性能非常低，只适用于小规模的数据读写。

看我们的代码：

#define _TD_INI_H_

#include <list>
#include <fstream>
using namespace std;
class KEV_VALUE
{
public:
        KEV_VALUE(){m_bIsGarbage=FALSE;m_bSingleLine=FALSE;};
        virtual ~KEV_VALUE(){};
        string m_key;
        string m_value;
        BOOL m_bIsGarbage;
        BOOL m_bSingleLine;
};
typedef list<KEV_VALUE> LIST_KEY_VELUE;

class SECTION
{
public:
        SECTION(){};
        virtual ~SECTION(){};
        string m_section;
        LIST_KEY_VELUE m_listKeyValue;
};
typedef list<SECTION> LIST_SECTION;

class CTDIni
{
public:
        CTDIni( void );
        virtual ~CTDIni( void );
        BOOL UpdateData( BOOL bSave=true );
        void SetFileName( const CHAR *lpstrFileName );
        BOOL GetLastSectionName( string& str );
        BOOL AddSection( const CHAR *lpstrSection );
        BOOL DeleteSection( const CHAR *lpstrSection);
        BOOL ReadSection( const CHAR *lpszSection, string& str );
        BOOL SetKeyValue( const CHAR *lpstrSection, const CHAR *lpstrKey, const CHAR *lpstrValue );
        BOOL SetKeyValue( const CHAR *lpstrSection, const CHAR *lpstrKey, const INT32 nValue );
        BOOL GetKeyValue( const CHAR *lpstrSection, const CHAR *lpstrKey, CHAR *lpstrValue );
        BOOL DeleteKeyValue( const CHAR *lpstrSection, const CHAR *lpstrKey );
        BOOL ChangeKeyName( const CHAR *lpstrSection, const CHAR *lpstrKeyOld, const CHAR *lpstrKeyNew );
        BOOL ChangeSectionName( const CHAR *lpstrSectionOld, const CHAR *lpstrSectionNew );
private:
        LIST_SECTION m_sections;
        string m_strFileName;
        BOOL AddGarbage( const CHAR *lpstrSection, const CHAR *lpstrGarbage, BOOL bSingleLine=FALSE );
};

#endif // !defined(_TD_INI_H_)

这个是解析类的声明，重要的是它的数据结构，它采用了两级链表的结构，第一级是所有section的list,第二级是section下面的key-value的list.
下面是其中的实现代码片断

BOOL CTDIni::SetKeyValue( const CHAR *lpstrSection, const CHAR *lpstrKey, const CHAR *lpstrValue )
{
        LIST_SECTION::iterator i;
        for( i = m_sections.begin(); i != m_sections.end(); i++ )
        {
                if( (*i).m_section == lpstrSection )
                {
                        LIST_KEY_VELUE::iterator j;
                        for( j = (*i).m_listKeyValue.begin(); j != (*i).m_listKeyValue.end(); j++ )
                        {
                                if( (*j).m_key == lpstrKey )
                                {
                                        (*j).m_value = lpstrValue;
                                        return TRUE;
                                }
                        }

                        KEV_VALUE tmp;
                        tmp.m_key = lpstrKey;
                        tmp.m_value = lpstrValue;
                        (*i).m_listKeyValue.push_back( tmp );
                        return TRUE;
                }
        }
        return FALSE;
}

上面的一个方法是添加一个值到配置中去，它的算法是首先查找它所在的section,然后查找所在的key,
最后决定是insert还是update.

这样性能问题就来了，当数据不断增加，SetKeyValue所需要的时间呈N*N的方式增长。很可怕。CPU的占用率也会跑到很高。

最后，我们不得不进行优化，因为在我们的项目中，不存在相同的section，也没有相同的key,所以我们使用map，使得查找时间变成常数级别。(即使有相同的key§ion,也可以使用multimap)

优化后的数据结构是这样的

#include <string>
#include <stdio.h>
#include <list>
#include <map>
#include <fstream>

using namespace std;

struct VELUE
{
        string m_value;
        BOOL m_bIsGarbage;
        BOOL m_bSingleLine;
};

typedef std::map<std::string,VELUE> MAP_KEY_VELUE;

typedef std::map<std::string,MAP_KEY_VELUE>  MAP_SECTION;

class CTDIni
{
public:
        CTDIni( void );
        virtual ~CTDIni( void );

        BOOL UpdateData( BOOL bSave=true );

        void SetFileName( const CHAR *lpstrFileName );

        BOOL GetLastSectionName( string& str );

        BOOL AddSection( const CHAR *lpstrSection );
        BOOL DeleteSection( const CHAR *lpstrSection);
        BOOL ReadSection( const CHAR *lpszSection, string& str );
        BOOL IsExistSection( const CHAR *lpstrSection);

        BOOL SetKeyValue( const CHAR *lpstrSection, const CHAR *lpstrKey, const CHAR *lpstrValue );
        BOOL SetKeyValue( const CHAR *lpstrSection, const CHAR *lpstrKey, const INT32 nValue );
        BOOL GetKeyValue( const CHAR *lpstrSection, const CHAR *lpstrKey, CHAR *lpstrValue );
        BOOL DeleteKeyValue( const CHAR *lpstrSection, const CHAR *lpstrKey );
        BOOL ChangeKeyName( const CHAR *lpstrSection, const CHAR *lpstrKeyOld, const CHAR *lpstrKeyNew );
        BOOL ChangeSectionName( const CHAR *lpstrSectionOld, const CHAR *lpstrSectionNew );
private:
        MAP_SECTION m_sections;
        string m_strFileName;
        BOOL AddGarbage( const CHAR *lpstrSection, const CHAR *lpstrGarbage, BOOL bSingleLine=FALSE );
};

SetKeyValue那个方法的实现是这样：

BOOL CTDIni::SetKeyValue( const CHAR *lpstrSection, const CHAR *lpstrKey, const CHAR *lpstrValue )
{
        MAP_SECTION::iterator i;
        MAP_KEY_VELUE::iterator j;

        i = m_sections.find(lpstrSection);
        if ( i == m_sections.end())
        {
                return FALSE;
        }

        j = i->second.find(lpstrKey);
        if( j != i->second.end()) //update
        {
                j->second.m_value = lpstrValue;
        }
        else //insert
        {
                VELUE tmp;
                tmp.m_value = lpstrValue;
                tmp.m_bSingleLine = false;
                tmp.m_bIsGarbage = false;
                i->second[lpstrKey] = tmp;
        }
        return TRUE;
}

两者的性能差距有多大？超过你的想象

小明 2006-01-05 13:07 发表评论

利用boost::serialization来实现C++ RMI

小明 — Thu, 29 Dec 2005 06:42:00 GMT

当我第一次使用boost::serlization的时候，就意识到它在RMI(Remote method Invoke)的意义，因为JAVA RMI就是建立在java serlization的基础之上。

先来个boost::serlization使用的例子

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>
void test_serialization()
{
    boost::archive::text_oarchive to(cout , boost::archive::no_header);
    int i = 10;
    string s = "This is a test\n";
    to & i;
    to & s;

    ofstream f("test.xml");
    boost::archive::xml_oarchive xo(f);
    xo & BOOST_SERIALIZATION_NVP(i) & BOOST_SERIALIZATION_NVP(s);

    boost::archive::text_iarchive ti(cin , boost::archive::no_header);
    ti & i & s;
    cout <<"i="<< i << endl;
    cout <<"s="<< s << endl;
}

假如我们可以将object序列化以后通过socket传过去，就可以实现RMI了。
当然这种方法只能是在C++程序之间传递。

今天在codeproject上面发现已经有人已经这样做了，原来早就有人跟我有一样的想法
看看作者封装的结果吧

server端:

#include <RCF/RCF.hpp>

RCF_BEGIN(I_Echo, "I_Echo")
  RCF_METHOD_R1(std::string, echo, const std::string &);
RCF_END(I_Echo);

class Echo
{
public:
  std::string echo(const std::string &msg) { return msg; }
};

int main()
{
  int port = 50001;
  RCF::RcfServer server(port);
  server.bind<I_Echo, Echo>();
  server.start();
  return 0;
}

client端：

#include <RCF/RCF.hpp>

RCF_BEGIN(I_Echo, "I_Echo")
  RCF_METHOD_R1(std::string, echo, const std::string &);
RCF_END(I_Echo);

int main()
{
  std::cout << RcfClient<I_Echo>("localhost",
                               50001).echo("my message");
  return 0;
}

比较简洁,利用了boost强大的function,thread,serlization

RCF下载地址: http://www.codeproject.com/threads/RMI_For_Cpp/RCF.zip

介绍： http://www.codeproject.com/threads/RMI_For_Cpp.asp

小明 2005-12-29 14:42 发表评论

C++性能优化实践1---设计数据结构

小明 — Thu, 22 Dec 2005 12:42:00 GMT

对于性能优化，相信喜欢C++的人都是比较重视效率。我准备写一个系列，主要是基于我的一些实践，至于理论上的东西，不是我的重点。我也讲不出来一堆道理:-)。我所说的例子，都将是我以前所遇到的一些案例，记录一下思路，拿出来跟大家share。

在C++程序中，自从有了STL,很少有人去自己去设计数据结构，当然大部分情况STL的效率都是可以的。万事都有例外。

我接触到一个需求，是根据手机号码的号段表(位数不定，一般是七八位）来查出手机号码所在的地区。
比如
1315156 南京
13812345 北京
1366789 上海
025 南京

一种可能的方案是设计多个hashmap
map seg8; map seg7; map seg3; ...
每个map分别对应不同的位数。对于一个phone,分别在这些map中查找
但是效率不行。

这里面有个关键，因为手机号码都是数字，我们可以设计出一棵树，每个节点都是0-9，他可以有10个节点，叶子节点我们就可以储存数据。迅速在大脑里想象一个这样的模型。

还是看代码比较明了。 十叉树

#if !defined __TREE10__
#define __TREE10__

#pragma warning(disable:4786)

namespace sandy
{
    namespace Private
    {
        template<class VALUE>
            struct __Node10  //节点struct
        {
            typedef __Node10<VALUE>* POINTER;
            VALUE * data; //数据
            POINTER ptr[10]; //子节点

            __Node10():data(0)
            {
                memset(ptr,0,sizeof(POINTER)*10);
            }
        };
    }

    template<typename VALUE>
        class CTree10
    {
        typedef Private::__Node10<VALUE> NODE;
    private:
        long                    m_lcount;          //插入的数据数量
        long                    m_lnodecount;      //节点数
        NODE*                    m_proot;           //根结点指针

    public:
        CTree10():m_lcount(0),m_lnodecount(0),m_proot(CreateNode()) //notice:Keep order with their declare
        {
        }
        ~CTree10()
        {
            DestroyAll();
        }

        void DestroyAll()
        {
            for(short i =0;i<10;++i)
            {
                if(m_proot->ptr[i]!=0)
                {
                    Remove(m_proot->ptr[i]);
                    m_proot->ptr[i] = 0;
                }
            }
        }

        bool Insert(const char*pKey,const VALUE &data) //插入节点
        {
            assert(pKey!=0);
            NODE * pNode = m_proot;
            NODE * pChildNode =0;
            char c = 0;

            for(unsigned int i=0;i<strlen(pKey);++i)
            {
                c = pKey[i];    if(c<'0' || c>'9') return false;
                pChildNode = pNode->ptr[(c-'0')];
                if(pChildNode == 0) //not build
                {
                    pChildNode = pNode->ptr[(c-'0')] = CreateNode();//create a new child
                }
                pNode = pChildNode ;//change node to child node
            }

            if(pNode->data == 0) //empty
            {
                pNode->data = new VALUE(data);
                ++m_lcount;
                return true;
            }
            else//already inserted
            {
                return false;
            }
        }

        bool Lookup(const char*pKey,VALUE &data,bool strick = true)
        {
            assert(pKey!=0);
            NODE * pNode = m_proot;
            NODE * pChildNode =0;
            char c = 0;

            for(unsigned int i=0;i<strlen(pKey);++i)
            {
                c = pKey[i]; if(c<'0' || c>'9') return false;
                pChildNode = pNode->ptr[(c-'0')];
                if(pChildNode!=0)
                {
                    pNode = pChildNode;
                }
                else // can't find
                {
                    if(!strick)
                    {
                        break;
                    }
                    return false;
                }
            }

            if(pNode->data != 0) //already inserted
            {
                data = *(pNode->data);
                return true;
            }
            else  // no inserted
            {
                return false;
            }
        }

    private:
        NODE *CreateNode()
        {
            NODE *pNewNode = new NODE();
            assert(pNewNode!= 0);
            ++m_lnodecount;
            return pNewNode;
        }

        void Remove(NODE *pNode)
        {
            assert(pNode!=0);
            for( short i = 0 ; i < 10 ; i ++ )
            {
                if( pNode -> ptr[ i ] )
                    Remove( pNode -> ptr[ i ] );
            }
            if(pNode->data!=0)
            {
                delete pNode->data;
                --m_lcount;
            }
            --m_lnodecount;
            delete pNode;
        }
    };
}

#endif

这个Tree10我在vc6下测试的结果：
插入速度比std::map快3倍，查询速度则是std::map的10倍

小明 2005-12-22 20:42 发表评论

vc6函数调用浅析

小明 — Wed, 14 Dec 2005 08:53:00 GMT

今天研究了一下vc6函数调用，看看vc6调用函数时候都做了什么。有些意思。

我写下了如下代码：

int fun(int a,int b)
{
    int i = 3;
    return a+b+i;
}

int main()
{
    int a = 1,b=2;
    int result ;
    result = fun(1,2);
    return result;
}

非常简单。反汇编后(Debug版)变成这样

1:    int fun(int a,int b)
2:    {
00401020   push        ebp
00401021   mov         ebp,esp
00401023   sub         esp,44h
00401026   push        ebx
00401027   push        esi
00401028   push        edi
00401029   lea         edi,[ebp-44h]
0040102C   mov         ecx,11h
00401031   mov         eax,0CCCCCCCCh
00401036   rep stos    dword ptr [edi]
3:        int i = 3;
00401038   mov         dword ptr [ebp-4],3
4:        return a+b+i;
0040103F   mov         eax,dword ptr [ebp+8]
00401042   add         eax,dword ptr [ebp+0Ch]
00401045   add         eax,dword ptr [ebp-4]
5:    }
00401048   pop         edi
00401049   pop         esi
0040104A   pop         ebx
0040104B   mov         esp,ebp
0040104D   pop         ebp
0040104E   ret

7:    int main()
8:    {
00401060   push        ebp
00401061   mov         ebp,esp
00401063   sub         esp,4Ch
00401066   push        ebx
00401067   push        esi
00401068   push        edi
00401069   lea         edi,[ebp-4Ch]
0040106C   mov         ecx,13h
00401071   mov         eax,0CCCCCCCCh
00401076   rep stos    dword ptr [edi]
9:        int a = 1,b=2;
00401078   mov         dword ptr [ebp-4],1
0040107F   mov         dword ptr [ebp-8],2
10:       int result ;
11:       result = fun(1,2);
00401086   push        2
00401088   push        1
0040108A   call        @ILT+5(fun) (0040100a)
0040108F   add         esp,8
00401092   mov         dword ptr [ebp-0Ch],eax
12:       return result;
00401095   mov         eax,dword ptr [ebp-0Ch]
13:   }
00401098   pop         edi
00401099   pop         esi
0040109A   pop         ebx
0040109B   add         esp,4Ch
0040109E   cmp         ebp,esp
004010A0   call        __chkesp (004010c0)
004010A5   mov         esp,ebp
004010A7   pop         ebp
004010A8   ret

我们主要来看看函数调用部分

1.参数压栈
push 2
push 1
参数从右向左压栈(__cdcel),esp递减

2.调用函数
call        @ILT+5(fun) (0040100a)
这条指令会把下一行代码的地址压栈，也就是函数返回地址。同时跳转到函数入口处

3.进入函数体
push        ebp
mov         ebp,esp
首先保存ebp的地址，然后把esp保存到ebp中去
00401023   sub         esp,44h
00401026   push        ebx
00401027   push        esi
00401028   push        edi
减小stack的指针(注意，stack是从内存的高端向低端生长的)，为局部变量保留一些空间，这里的44h不是固定的，由编译器计算得来
00401029   lea         edi,[ebp-44h]
0040102C   mov         ecx,11h
00401031   mov         eax,0CCCCCCCCh
00401036   rep stos    dword ptr [edi]
用0xCC填充局部变量空间。这是Debug模式特有的，如果是字符串，你就看到被初始化成"烫烫烫烫烫烫"
至此，整个堆栈变成
|-----------------|
|    局部变量2   |
|-----------------|
|    局部变量1    |<----ebp-4
|-----------------|
|    old ebp          |<----ebp
|-----------------|
| 函数返回地址| <----ebp+4
|-----------------|
|      参数1        | <----ebp+8
|-----------------|
|      参数2         |
|-----------------|

Next:
int i = 3;
00401038   mov         dword ptr [ebp-4],3
这里你看到[ebp-4]就是第一个局部变量i了
0040103F   mov         eax,dword ptr [ebp+8]
00401042   add         eax,dword ptr [ebp+0Ch]
00401045   add         eax,dword ptr [ebp-4]
[ebp+8],[ebp+0Ch]分别是a和b了

4.函数返回
函数的结果都是放在eax中(ps:你可以在vc的watch窗口输入@EAX，就可以直接看到函数返回值了）
00401048   pop         edi
00401049   pop         esi
0040104A   pop         ebx
0040104B   mov         esp,ebp
0040104D   pop         ebp
0040104E   ret
把edi,esi,ebx恢复，然后恢复esp,ebp,这时函数的返回地址就在栈顶，调用ret就可以返回了。

那如果改变函数的返回地址会怎样？
ok,我们修改一下代码：

#include <stdio.h>
void fun2()
{
    printf("fun2() called");
}

int fun(int a,int b)
{
    int i = 3;
    printf("return address:0x%x\n",&i+2);
    printf("fun2 address:0x%x\n",&fun2);
    /*int *p = (int*)&fun2;
    __asm
    {
        mov ebx,p
        mov dword ptr[ebp+4],ebx
    }*/
    *(&i+2)=(int)&fun2; //modify return address
    return a+b+i;
}

int main()
{
    int a = 1,b=2;
    int result ;
    result = fun(1,2);
    return result;
}

Wow,这时，我们就会发现fun2被调用了。这就是Buffer overrun(缓冲溢出)所做的事情吧。

5.最后一步，调用者调整堆栈指针
call        @ILT+5(fun) (0040100a)
add         esp,8
为什么要调整呢，因为调用之前push两个参数进入栈，现在要恢复它
mov         dword ptr [ebp-0Ch],eax
这句话就是享用函数调用的果实了(EAX保存了函数的返回值)

------end--------

小明 2005-12-14 16:53 发表评论

考考你对C++对象模型的理解

小明 — Tue, 06 Dec 2005 01:34:00 GMT

这是小明我自编的题目。

1.请在不运行程序的情况下，说出下面的程序运行后会崩溃么？如果是，在哪一行。

1 #include <stdio.h>
2 #include <memory.h>
3 class Test
4 {
5 public:
6         Test()
7         {
8                 memset(this,0,sizeof(*this));
9         }
10         int s;
11         void test()
12         {
13                 printf("test()\n");
14         }
15         void test1()
16         {
17                 printf("test1():%d\n",this->s);
18         }
19         virtual void test2()
20         {
21                 printf("test2()\n");
22         }
23 };
24
25 int main()
26 {
27         Test *s;
28         s->test();
29         s->test2();
30         s->test1();
31         return 0;
32 }

2 .修改一下，又是在哪一行呢？

1 #include <stdio.h>
2 #include <memory.h>
3 class Test
4 {
5 public:
6         Test()
7         {
8                 memset(this,0,sizeof(*this));
9         }
10         int s;
11         void test()
12         {
13                 printf("test()\n");
14         }
15         void test1()
16         {
17                 printf("test1():%d\n",this->s);
18         }
19         virtual void test2()
20         {
21                 printf("test2()\n");
22         }
23 };
24
25 int main()
26 {
27         Test *s = new Test();
28         s->test();
29         s->test1();
30         s->test2();
31         return 0;
32 }

3.再修改一下，情况会如何呢？

1 #include <stdio.h>
2 #include <memory.h>
3 class Test
4 {
5 public:
6         Test()
7         {
8                 memset(this,0,sizeof(*this));
9         }
10         int s;
11         void test()
12         {
13                 printf("test()\n");
14         }
15         void test1()
16         {
17                 printf("test1():%d\n",this->s);
18         }
19         virtual void test2()
20         {
21                 printf("test2()\n");
22         }
23 };
24
25 int main()
26 {
27         Test s ;
28         s.test();
29         s.test1();
30         s.test2();
31         return 0;
32 }

最后说一下答案吧
第一题是在29行，第二题在30行，最后一题不报错。
如果你不知道为什么，建议看看<c++ Object Model>>

小明 2005-12-06 09:34 发表评论

Just for fun:能输出自身代码的程序

小明 — Fri, 02 Dec 2005 02:58:00 GMT

条件：不借助任何文件操作，输出程序的source code.

程序：

#include <stdio.h>
char c[] = {0x7d,0x3b,0xa,0x69,0x6e,0x74,0x20,0x6d,0x61,0x69,0x6e,0x28,0x29,0xa,0x7b,0xa,0x20,0x20,0x20,0x20,0x70,0x72,0x69,0x6e,0x74,0x66,0x28,0x22,0x23,0x69,0x6e,0x63,0x6c,0x75,0x64,0x65,0x20,0x3c,0x73,0x74,0x64,0x69,0x6f,0x2e,0x68,0x3e,0x5c,0x6e,0x63,0x68,0x61,0x72,0x20,0x63,0x5b,0x5d,0x20,0x3d,0x20,0x7b,0x22,0x29,0x3b,0xa,0x20,0x20,0x20,0x20,0x66,0x6f,0x72,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x30,0x3b,0x69,0x3c,0x73,0x69,0x7a,0x65,0x6f,0x66,0x28,0x63,0x29,0x3b,0x2b,0x2b,0x69,0x29,0xa,0x20,0x20,0x20,0x20,0x7b,0xa,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x70,0x72,0x69,0x6e,0x74,0x66,0x28,0x22,0x30,0x78,0x25,0x78,0x2c,0x22,0x2c,0x63,0x5b,0x69,0x5d,0x29,0x3b,0xa,0x20,0x20,0x20,0x20,0x7d,0xa,0x20,0x20,0x20,0x20,0x70,0x72,0x69,0x6e,0x74,0x66,0x28,0x22,0x25,0x73,0x22,0x2c,0x63,0x29,0x3b,0xa,0x20,0x20,0x20,0x20,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x30,0x3b,0xa,0x7d,};
int main()
{
    printf("#include \nchar c[] = {");
    for(int i=0;i<sizeof(c);++i)
    {
        printf("0x%x,",c[i]);
    }
    printf("%s",c);
    return 0;
}

至于怎么做到的，大家可以自己琢磨

不过不要以为只有C能做到，java也可以哦

小明 2005-12-02 10:58 发表评论