进程通信

Win32应用程序中进程间通信方法分析与比较

posted @ 2009-10-23 09:01 深邃者 阅读(218) | 评论 (0) | 编辑 收藏

vs2005 调试

1，断点设置有技巧：

1）设置条件断点，比如i==10,变量改变时断点；

2）如何让断点在指定的命中次数或者大于某个次数时触发呢?方法是设定几个断点的HitCount,右键单击断点,在弹出菜单中选择Hit Count；

3）When Hit,这个选项可以让我们在命中断点后做一些事情,包括输出一些内容,或者调用宏,比如输出一个程序中变量的值；

4）利用断点的Filter功能,比如我希望断点只有被机器名为yizhu的机器访问才能触发；

具体参见：一篇介绍VS2005调试断点技巧的文章

2. 怎样判断加载的dll的正确性？

   调试时，打开Debug->Window->Modules，在窗口中显示的就是当前进程加载的所有dll及其详细信息，如果

断点无法击中，可以检查这里，看是否有匹配的pdb文件或者是加载了错误的dll

3. 已经开始调试的工程加入另外的进程并且调试

   如果你在调试客户端，但是服务器需要调试，那么使用菜单中的Tools-> Attach to process进行进程挂接，这种方法可以挂接所有windows下的程序，能否调试，就看其是否调试版和有调试用的PDB文件

4. 同时启动多进程进行调试

  在Solution的属性中的Common Properties->Startup Project。选择Multiple startup projects。这个选项是可以记忆的，下次打开可以直接调试，非常方便

5.调试Windows Service

 MSDN推荐的方法
1、调试windows服务的初始化、启动
　　另写一个程序控制服务的初始化和启动
　　注意：OnStart里写Log, OnStart里要在30秒返回. 不然启动就失败了! 所以OnStart里不要放太多代码! 可以用异步或线程.
2、调试windows服务的其他方面
1 ) 安装您的服务 : intallutils xx.exe
2) 可从“服务控制管理器”、“服务器资源管理器”或代码启动服务
3) vs: 设置相关断点，启动调试，再在工具栏中选择 调试->附加到进程..., 选择您的服务, 确定。
3、trace方法
1）添加调试方法

private static void DebugRun(string[] args)

2）改写程序入口为如下：

public static void Main(string[] args)
{
#if DEBUG
DebugRun(args);
#else
/*
初始化服务
*/
#endif
}

3）加入2种调试代码

EventLog.WriteEntry("...");
System.Diagnostics.Debug.WriteLine("...");

6，远程调试技术

    顾名思义，就是要调试的程序和调试器本身并不在一台机器上。由于虚拟机技术的盛行，在虚拟机里面运行待调试的程序，而在外面运行调试器，也是一种比较流行的做法。

1 为什么使用远程调试
   远程调试有如下好处：
    a. 能让产品运行在一个比较干净的环境。有的时候如果产品安装在一个装好集成环境的机器上，某些bug并不能显示出来。
    b. 易于部署调试环境。很多产品都非常复杂，比如很多都以service方式运行或者要load很复杂的resource，想在调试器里面直接按F5运行，越来越难。
    c. 对于游戏等全屏方式运行的程序，尤其有用。以前我对调试directx程序非常头疼。

2 怎样使用远程调试
   使用vs2005进行远程调试，详细的介绍参考：http://support.microsoft.com/kb/910448

   简单的来说，
   1)在被调试的机器上面运行Msvsmon.exe
   2)在调试机器上面运行vs2005,并attach到远程机器的某个进程

3 注意事项

   a. 设置好正确的权限
   被调试机器和调试机器需要互相信任的权限(two-way)。如果两台机器在同一个workgroup，让两台机器拥有一个相同的账号和密码，然后以这个账号运行。如果两台机器在一个域里面，比较简单，Msvsmon可以设置权限。如果一台机器在domain里面，另外一台不在，同样是让两台机器拥有一个相同的账号和密码，然后以这个账号运行。
   对于Windows XP要特别注意一下，设置匿名的访问权限才可以work , http://support.microsoft.com/kb/908099

   b.设置好symbol
   什么，你不知道什么是symbol？简单的来说,symbol file(*.pdb) is for source-level debugging. VS2005就是靠它来调试exe的。默认情况下debug版本生成的，而release版本不生成pdb.设置好 [Project proerties]-[C/C++]-[Debug Information Format]-Program Database就可以了。
   为了减少symbol方面的麻烦，最简单的做法是让被调试机器上的binary版本和本地compile出来保持一致。

posted @ 2009-10-23 08:59 深邃者 阅读(836) | 评论 (0) | 编辑 收藏

windbg调试器

WinDbg调试器

堆栈显示指令 

k [b|p|P|v] 

在内核调试的时候,k命令用来显示内核栈的内容 

先说说内核栈用来干嘛的 看了些资料个人理解是这样的 

比如我们的代码运行时,肯定会有函数函数然后还会调用函数 但是系统如何记录是哪个父函数调用了这个子函数,在子函数调用之前整个状态又是怎样的,其实系统是利用了堆栈记录的 栈这个东西好阿  先进后出  最近调用的函数记录在最顶层 函数执行完后就从栈内弹出之前记录的参数,如果调用函数 一样的把函数压进栈内就好了 这样一来 一旦子函数执行完,从栈内弹出的第一个函数肯定是该子函数的老爹  我们可以看上层堆栈的状态等等 功能大家慢慢去体会吧我也没用过  呵呵  不好说什么 下面说些细节的东西 

b 

显示传给函数的前三个参数 

p 

显示传给函数的全部参数 

P( 大写) 

跟上面那个一样 只不过是显示形式不同而已 

V 

外加显示一些额外的信息 

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

u [f] 

反汇编指令,嘿嘿 超级有用的指令哟虽然说内核很多东西很复杂 认识偶尔小小反下也是可以的 

u 

反汇编当前寄存器指向的代码 

uf 函数名(比如nt!ZwCreateFile) 

反汇编指定的函数 

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

t [r] 

单步跟踪 

r 打开指显示寄存器的详细信息,状态的开关(下面指令一样有效,在用1次就会关闭哦~) 

ta 地址 

让程序执行到指定地址 

tb 

让程序运行到分支语句时停止 

tc 

让程序运行到下一个函数调用停止 

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

p [r] 

单步执行一跳指令 

r 打开指显示寄存器的详细信息,状态的开关(下面指令一样有效,在用1次就会关闭哦~) 

pa 

让程序执行到指定地址 

pc 

让程序执行到函数调用就停止 

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

wt 

在想查看指定函数的信息而又不想单步通过该函数时很有用。可以到函数的起始地址并执行 wt 命令。(摘自翻译文档) 

这个感觉用处不是很大.不细细研究了 

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

Ps: 很多人不清楚到底p指令和t指令有什么区别 其实很简单 p指令执行到函数时把这个当做一个指令来执行也就是说不会进入函数执行,但是t指令会进入到函数里面执行  就这么简单~~呵呵

posted @ 2009-10-23 08:58 深邃者 阅读(2039) | 评论 (0) | 编辑 收藏

#pragma 预处理指令详解

#pragma 预处理指令详解

posted @ 2009-10-23 08:56 深邃者 阅读(101) | 评论 (0) | 编辑 收藏

c++内存布局

07年12月，我写了一篇《C++虚函数表解析》的文章，引起了大家的兴趣。有很多朋友对我的文章留了言，有鼓励我的，有批评我的，还有很多问问题的。我在这里一并对大家的留言表示感谢。这也是我为什么再写一篇续言的原因。因为，在上一篇文章中，我用了的示例都是非常简单的，主要是为了说明一些机理上的问题，也是为了图一些表达上方便和简单。不想，这篇文章成为了打开C++对象模型内存布局的一个引子，引发了大家对C++对象的更深层次的讨论。当然，我之前的文章还有很多方面没有涉及，从我个人感觉下来，在谈论虚函数表里，至少有以下这些内容没有涉及：

1）有成员变量的情况。

2）有重复继承的情况。

3）有虚拟继承的情况。

4）有钻石型虚拟继承的情况。

这些都是我本篇文章需要向大家说明的东西。所以，这篇文章将会是《C++虚函数表解析》的一个续篇，也是一篇高级进阶的文章。我希望大家在读这篇文章之前对C++有一定的基础和了解，并能先读我的上一篇文章。因为这篇文章的深度可能会比较深，而且会比较杂乱，我希望你在读本篇文章时不会有大脑思维紊乱导致大脑死机的情况。;-)

对象的影响因素

简而言之，我们一个类可能会有如下的影响因素：

1）成员变量

2）虚函数（产生虚函数表）

3）单一继承（只继承于一个类）

4）多重继承（继承多个类）

5）重复继承（继承的多个父类中其父类有相同的超类）

6）虚拟继承（使用virtual方式继承，为了保证继承后父类的内存布局只会存在一份）

上述的东西通常是C++这门语言在语义方面对对象内部的影响因素，当然，还会有编译器的影响（比如优化），还有字节对齐的影响。在这里我们都不讨论，我们只讨论C++语言上的影响。

本篇文章着重讨论下述几个情况下的C++对象的内存布局情况。

1）单一的一般继承（带成员变量、虚函数、虚函数覆盖）

2）单一的虚拟继承（带成员变量、虚函数、虚函数覆盖）

3）多重继承（带成员变量、虚函数、虚函数覆盖）

4）重复多重继承（带成员变量、虚函数、虚函数覆盖）

5）钻石型的虚拟多重继承（带成员变量、虚函数、虚函数覆盖）

我们的目标就是，让事情越来越复杂。

知识复习

我们简单地复习一下，我们可以通过对象的地址来取得虚函数表的地址，如：

          typedef void(*Fun)(void);

            Base b;

            Fun pFun = NULL;

            cout << "虚函数表地址：" << (int*)(&b) << endl;

            cout << "虚函数表 — 第一个函数地址：" << (int*)*(int*)(&b) << endl;

            // Invoke the first virtual function 

            pFun = (Fun)*((int*)*(int*)(&b));

            pFun();

我们同样可以用这种方式来取得整个对象实例的内存布局。因为这些东西在内存中都是连续分布的，我们只需要使用适当的地址偏移量，我们就可以获得整个内存对象的布局。

本篇文章中的例程或内存布局主要使用如下编译器和系统：

1）Windows XP 和 VC++ 2003

2）Cygwin 和 G++ 3.4.4

单一的一般继承

下面，我们假设有如下所示的一个继承关系：

请注意，在这个继承关系中，父类，子类，孙子类都有自己的一个成员变量。而了类覆盖了父类的f()方法，孙子类覆盖了子类的g_child()及其超类的f()。

我们的源程序如下所示：

class Parent {

public:

    int iparent;

    Parent ():iparent (10) {}

    virtual void f() { cout << " Parent::f()" << endl; }

    virtual void g() { cout << " Parent::g()" << endl; }

    virtual void h() { cout << " Parent::h()" << endl; }

};

class Child : public Parent {

public:

    int ichild;

    Child():ichild(100) {}

    virtual void f() { cout << "Child::f()" << endl; }

    virtual void g_child() { cout << "Child::g_child()" << endl; }

    virtual void h_child() { cout << "Child::h_child()" << endl; }

};

class GrandChild : public Child{

public:

    int igrandchild;

    GrandChild():igrandchild(1000) {}

    virtual void f() { cout << "GrandChild::f()" << endl; }

    virtual void g_child() { cout << "GrandChild::g_child()" << endl; }

    virtual void h_grandchild() { cout << "GrandChild::h_grandchild()" << endl; }

};

我们使用以下程序作为测试程序：（下面程序中，我使用了一个int** pVtab 来作为遍历对象内存布局的指针，这样，我就可以方便地像使用数组一样来遍历所有的成员包括其虚函数表了，在后面的程序中，我也是用这样的方法的，请不必感到奇怪，）

    typedef void(*Fun)(void);

    GrandChild gc;

    int** pVtab = (int**)&gc;

    cout << "[0] GrandChild::_vptr->" << endl;

    for (int i=0; (Fun)pVtab[0][i]!=NULL; i++){

                pFun = (Fun)pVtab[0][i];

                cout << "    ["<<i<<"] ";

                pFun();

    }

    cout << "[1] Parent.iparent = " << (int)pVtab[1] << endl;

    cout << "[2] Child.ichild = " << (int)pVtab[2] << endl;

    cout << "[3] GrandChild.igrandchild = " << (int)pVtab[3] << endl;

其运行结果如下所示：（在VC++ 2003和G++ 3.4.4下）

使用图片表示如下：

可见以下几个方面：

1）虚函数表在最前面的位置。

2）成员变量根据其继承和声明顺序依次放在后面。

3）在单一的继承中，被overwrite的虚函数在虚函数表中得到了更新。

多重继承

下面，再让我们来看看多重继承中的情况，假设有下面这样一个类的继承关系。注意：子类只overwrite了父类的f()函数，而还有一个是自己的函数（我们这样做的目的是为了用g1()作为一个标记来标明子类的虚函数表）。而且每个类中都有一个自己的成员变量：

我们的类继承的源代码如下所示：父类的成员初始为10，20，30，子类的为100

class Base1 {

public:

    int ibase1;

    Base1():ibase1(10) {}

    virtual void f() { cout << "Base1::f()" << endl; }

    virtual void g() { cout << "Base1::g()" << endl; }

    virtual void h() { cout << "Base1::h()" << endl; }

};

class Base2 {

public:

    int ibase2;

    Base2():ibase2(20) {}

    virtual void f() { cout << "Base2::f()" << endl; }

    virtual void g() { cout << "Base2::g()" << endl; }

    virtual void h() { cout << "Base2::h()" << endl; }

};

class Base3 {

public:

    int ibase3;

    Base3():ibase3(30) {}

    virtual void f() { cout << "Base3::f()" << endl; }

    virtual void g() { cout << "Base3::g()" << endl; }

    virtual void h() { cout << "Base3::h()" << endl; }

};

class Derive : public Base1, public Base2, public Base3 {

public:

    int iderive;

    Derive():iderive(100) {}

    virtual void f() { cout << "Derive::f()" << endl; }

    virtual void g1() { cout << "Derive::g1()" << endl; }

};

我们通过下面的程序来查看子类实例的内存布局：下面程序中，注意我使用了一个s变量，其中用到了sizof(Base)来找下一个类的偏移量。（因为我声明的是int成员，所以是4个字节，所以没有对齐问题。关于内存的对齐问题，大家可以自行试验，我在这里就不多说了）

             typedef void(*Fun)(void);

               Derive d;

                int** pVtab = (int**)&d;

                cout << "[0] Base1::_vptr->" << endl;

                pFun = (Fun)pVtab[0][0];

                cout << "     [0] ";

                pFun();

                pFun = (Fun)pVtab[0][1];

                cout << "     [1] ";pFun();

                pFun = (Fun)pVtab[0][2];

                cout << "     [2] ";pFun();

                pFun = (Fun)pVtab[0][3];

                cout << "     [3] "; pFun();

                pFun = (Fun)pVtab[0][4];

                cout << "     [4] "; cout<<pFun<<endl;

                cout << "[1] Base1.ibase1 = " << (int)pVtab[1] << endl;

                int s = sizeof(Base1)/4;

                cout << "[" << s << "] Base2::_vptr->"<<endl;

                pFun = (Fun)pVtab[s][0];

                cout << "     [0] "; pFun();

                Fun = (Fun)pVtab[s][1];

                cout << "     [1] "; pFun();

                pFun = (Fun)pVtab[s][2];

                cout << "     [2] "; pFun();

                pFun = (Fun)pVtab[s][3];

                out << "     [3] ";

                cout<<pFun<<endl;

                cout << "["<< s+1 <<"] Base2.ibase2 = " << (int)pVtab[s+1] << endl;

                s = s + sizeof(Base2)/4;

                cout << "[" << s << "] Base3::_vptr->"<<endl;

                pFun = (Fun)pVtab[s][0];

                cout << "     [0] "; pFun();

                pFun = (Fun)pVtab[s][1];

                cout << "     [1] "; pFun();

                pFun = (Fun)pVtab[s][2];

                cout << "     [2] "; pFun();

                pFun = (Fun)pVtab[s][3];

                 cout << "     [3] ";

                cout<<pFun<<endl;

                s++;

                cout << "["<< s <<"] Base3.ibase3 = " << (int)pVtab[s] << endl;

                s++;

                cout << "["<< s <<"] Derive.iderive = " << (int)pVtab[s] << endl;

其运行结果如下所示：（在VC++ 2003和G++ 3.4.4下）

使用图片表示是下面这个样子：

我们可以看到：

1） 每个父类都有自己的虚表。

2） 子类的成员函数被放到了第一个父类的表中。

3） 内存布局中，其父类布局依次按声明顺序排列。

4） 每个父类的虚表中的f()函数都被overwrite成了子类的f()。这样做就是为了解决不同的父类类型的指针指向同一个子类实例，而能够调用到实际的函数。

posted @ 2008-10-18 17:31 深邃者 阅读(177) | 评论 (0) | 编辑 收藏

c++虚函数表解析

前言

C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。

关于虚函数的使用方法，我在这里不做过多的阐述。大家可以看看相关的C++的书籍。在这篇文章中，我只想从虚函数的实现机制上面为大家 一个清晰的剖析。

当然，相同的文章在网上也出现过一些了，但我总感觉这些文章不是很容易阅读，大段大段的代码，没有图片，没有详细的说明，没有比较，没有举一反三。不利于学习和阅读，所以这是我想写下这篇文章的原因。也希望大家多给我提意见。

言归正传，让我们一起进入虚函数的世界。

虚函数表

对C++ 了解的人都应该知道虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。简称为V-Table。在这个表中，主是要一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其容真实反应实际的函数。这样，在有虚函数的类的实例中这个表被分配在了这个实例的内存中，所以，当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得由为重要了，它就像一个地图一样，指明了实际所应该调用的函数。

这里我们着重看一下这张虚函数表。C++的编译器应该是保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证取到虚函数表的有最高的性能——如果有多层继承或是多重继承的情况下）。 这意味着我们通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。

听我扯了那么多，我可以感觉出来你现在可能比以前更加晕头转向了。 没关系，下面就是实际的例子，相信聪明的你一看就明白了。

假设我们有这样的一个类：

class Base {

     public:

            virtual void f() { cout << "Base::f" << endl; }

            virtual void g() { cout << "Base::g" << endl; }

            virtual void h() { cout << "Base::h" << endl; }

};

按照上面的说法，我们可以通过Base的实例来得到虚函数表。 下面是实际例程：

          typedef void(*Fun)(void);

            Base b;

            Fun pFun = NULL;

            cout << "虚函数表地址：" << (int*)(&b) << endl;

            cout << "虚函数表 — 第一个函数地址：" << (int*)*(int*)(&b) << endl;

            // Invoke the first virtual function 

            pFun = (Fun)*((int*)*(int*)(&b));

            pFun();

实际运行经果如下：(Windows XP+VS2003, Linux 2.6.22 + GCC 4.1.3)

虚函数表地址：0012FED4

虚函数表 — 第一个函数地址：0044F148

Base::f

通过这个示例，我们可以看到，我们可以通过强行把&b转成int *，取得虚函数表的地址，然后，再次取址就可以得到第一个虚函数的地址了，也就是Base::f()，这在上面的程序中得到了验证（把int* 强制转成了函数指针）。通过这个示例，我们就可以知道如果要调用Base::g()和Base::h()，其代码如下：

            (Fun)*((int*)*(int*)(&b)+0); // Base::f()

            (Fun)*((int*)*(int*)(&b)+1); // Base::g()

            (Fun)*((int*)*(int*)(&b)+2); // Base::h()

这个时候你应该懂了吧。什么？还是有点晕。也是，这样的代码看着太乱了。没问题，让我画个图解释一下。如下所示：

注意：在上面这个图中，我在虚函数表的最后多加了一个结点，这是虚函数表的结束结点，就像字符串的结束符“\0”一样，其标志了虚函数表的结束。这个结束标志的值在不同的编译器下是不同的。在WinXP+VS2003下，这个值是NULL。而在Ubuntu 7.10 + Linux 2.6.22 + GCC 4.1.3下，这个值是如果1，表示还有下一个虚函数表，如果值是0，表示是最后一个虚函数表。

下面，我将分别说明“无覆盖”和“有覆盖”时的虚函数表的样子。没有覆盖父类的虚函数是毫无意义的。我之所以要讲述没有覆盖的情况，主要目的是为了给一个对比。在比较之下，我们可以更加清楚地知道其内部的具体实现。

一般继承（无虚函数覆盖）

下面，再让我们来看看继承时的虚函数表是什么样的。假设有如下所示的一个继承关系：

请注意，在这个继承关系中，子类没有重载任何父类的函数。那么，在派生类的实例中，其虚函数表如下所示：

对于实例：Derive d; 的虚函数表如下：

我们可以看到下面几点：

1）虚函数按照其声明顺序放于表中。

2）父类的虚函数在子类的虚函数前面。

我相信聪明的你一定可以参考前面的那个程序，来编写一段程序来验证。

一般继承（有虚函数覆盖）

覆盖父类的虚函数是很显然的事情，不然，虚函数就变得毫无意义。下面，我们来看一下，如果子类中有虚函数重载了父类的虚函数，会是一个什么样子？假设，我们有下面这样的一个继承关系。

为了让大家看到被继承过后的效果，在这个类的设计中，我只覆盖了父类的一个函数：f()。那么，对于派生类的实例，其虚函数表会是下面的一个样子：

我们从表中可以看到下面几点，

1）覆盖的f()函数被放到了虚表中原来父类虚函数的位置。

2）没有被覆盖的函数依旧。

这样，我们就可以看到对于下面这样的程序，

            Base *b = new Derive();

            b->f();

由b所指的内存中的虚函数表的f()的位置已经被Derive::f()函数地址所取代，于是在实际调用发生时，是Derive::f()被调用了。这就实现了多态。

多重继承（无虚函数覆盖）

下面，再让我们来看看多重继承中的情况，假设有下面这样一个类的继承关系。注意：子类并没有覆盖父类的函数。

对于子类实例中的虚函数表，是下面这个样子：

我们可以看到：

1） 每个父类都有自己的虚表。

2） 子类的成员函数被放到了第一个父类的表中。（所谓的第一个父类是按照声明顺序来判断的）

这样做就是为了解决不同的父类类型的指针指向同一个子类实例，而能够调用到实际的函数。

多重继承（有虚函数覆盖）

下面我们再来看看，如果发生虚函数覆盖的情况。

下图中，我们在子类中覆盖了父类的f()函数。

下面是对于子类实例中的虚函数表的图：

我们可以看见，三个父类虚函数表中的f()的位置被替换成了子类的函数指针。这样，我们就可以任一静态类型的父类来指向子类，并调用子类的f()了。如：

            Derive d;

            Base1 *b1 = &d;

            Base2 *b2 = &d;

            Base3 *b3 = &d;

            b1->f(); //Derive::f()

            b2->f(); //Derive::f()

            b3->f(); //Derive::f()

            b1->g(); //Base1::g()

            b2->g(); //Base2::g()

            b3->g(); //Base3::g()

安全性

每次写C++的文章，总免不了要批判一下C++。这篇文章也不例外。通过上面的讲述，相信我们对虚函数表有一个比较细致的了解了。水可载舟，亦可覆舟。下面，让我们来看看我们可以用虚函数表来干点什么坏事吧。

一、通过父类型的指针访问子类自己的虚函数

我们知道，子类没有重载父类的虚函数是一件毫无意义的事情。因为多态也是要基于函数重载的。虽然在上面的图中我们可以看到Base1的虚表中有Derive的虚函数，但我们根本不可能使用下面的语句来调用子类的自有虚函数：

          Base1 *b1 = new Derive();

            b1->f1(); //编译出错

任何妄图使用父类指针想调用子类中的未覆盖父类的成员函数的行为都会被编译器视为非法，所以，这样的程序根本无法编译通过。但在运行时，我们可以通过指针的方式访问虚函数表来达到违反C++语义的行为。（关于这方面的尝试，通过阅读后面附录的代码，相信你可以做到这一点）

二、访问non-public的虚函数

另外，如果父类的虚函数是private或是protected的，但这些非public的虚函数同样会存在于虚函数表中，所以，我们同样可以使用访问虚函数表的方式来访问这些non-public的虚函数，这是很容易做到的。

如：

class Base {

    private:

            virtual void f() { cout << "Base::f" << endl; }

};

class Derive : public Base{

};

typedef void(*Fun)(void);

void main() {

    Derive d;

    Fun pFun = (Fun)*((int*)*(int*)(&d)+0);

    pFun();

}

结束语

C++这门语言是一门Magic的语言，对于程序员来说，我们似乎永远摸不清楚这门语言背着我们在干了什么。需要熟悉这门语言，我们就必需要了解C++里面的那些东西，需要去了解C++中那些危险的东西。不然，这是一种搬起石头砸自己脚的编程语言。

在文章束之前还是介绍一下自己吧。我从事软件研发有十个年头了，目前是软件开发技术主管，技术方面，主攻Unix/C/C++，比较喜欢网络上的技术，比如分布式计算，网格计算，P2P，Ajax等一切和互联网相关的东西。管理方面比较擅长于团队建设，技术趋势分析，项目管理。欢迎大家和我交流，我的MSN和Email是：haoel@hotmail.com 

附录一：VC中查看虚函数表

我们可以在VC的IDE环境中的Debug状态下展开类的实例就可以看到虚函数表了（并不是很完整的）

附录 二：例程

下面是一个关于多重继承的虚函数表访问的例程：

#include <iostream>

using namespace std;

class Base1 {

public:

            virtual void f() { cout << "Base1::f" << endl; }

            virtual void g() { cout << "Base1::g" << endl; }

            virtual void h() { cout << "Base1::h" << endl; }

};

class Base2 {

public:

            virtual void f() { cout << "Base2::f" << endl; }

            virtual void g() { cout << "Base2::g" << endl; }

            virtual void h() { cout << "Base2::h" << endl; }

};

class Base3 {

public:

            virtual void f() { cout << "Base3::f" << endl; }

            virtual void g() { cout << "Base3::g" << endl; }

            virtual void h() { cout << "Base3::h" << endl; }

};

class Derive : public Base1, public Base2, public Base3 {

public:

            virtual void f() { cout << "Derive::f" << endl; }

            virtual void g1() { cout << "Derive::g1" << endl; }

};

typedef void(*Fun)(void);

int main()

{

            Fun pFun = NULL;

            Derive d;

            int** pVtab = (int**)&d;

            //Base1's vtable

            //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+0);

            pFun = (Fun)pVtab[0][0];

            pFun();

            //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+1);

            pFun = (Fun)pVtab[0][1];

            pFun();

            //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+2);

            pFun = (Fun)pVtab[0][2];

            pFun();

            //Derive's vtable

            //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+3);

            pFun = (Fun)pVtab[0][3];

            pFun();

            //The tail of the vtable

            pFun = (Fun)pVtab[0][4];

            cout<<pFun<<endl;

            //Base2's vtable

            //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);

            pFun = (Fun)pVtab[1][0];

            pFun();

            //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);

            pFun = (Fun)pVtab[1][1];

            pFun();

            pFun = (Fun)pVtab[1][2];

            pFun();

            //The tail of the vtable

            pFun = (Fun)pVtab[1][3];

            cout<<pFun<<endl;

            //Base3's vtable

            //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);

            pFun = (Fun)pVtab[2][0];

            pFun();

            //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);

            pFun = (Fun)pVtab[2][1];

            pFun();

            pFun = (Fun)pVtab[2][2];

            pFun();

            //The tail of the vtable

            pFun = (Fun)pVtab[2][3];

            cout<<pFun<<endl;

            return 0;

}

posted @ 2008-10-18 17:29 深邃者 阅读(107) | 评论 (0) | 编辑 收藏

如何用 Win32 APIs 枚举应用程序窗口和进程

如何用 Win32 APIs 枚举应用程序窗口和进程

编译：NorthTibet

下载源代码

摘要

　　我们在编写程序时，常常遇到的一件事情就是要准确列出系统中所有正在运行的程序或者进程。Windows 任务管理器就是这样的一个程序。它既能列出运行的桌面应用程序，又能列出系统中所有运行的进程。那么，我们在程序中如何实现这样的任务呢？本文下面将详细讨论这个问题。


枚举顶层（top-level）窗口

　　枚举桌面顶层窗口相对于枚举进程来说可能要容易一些。枚举桌面顶层窗口的方法是用 EnumWindows() 函数。不要用 GetWindow()来创建窗口列表，因为窗口之间复杂的父子及同胞关系（Z-Order）容易造成混乱而使得枚举结果不准确。
　　EnumWindows()有两个参数，一个是指向回调函数的指针，一个是用户定义的 LPARAM 值， 针对每个桌面窗口（或者顶层窗口）它调用回调函数一次。然后回调函数用该窗口句柄做一些处理，比如将它添加到列表中。这个方法保证枚举结果不会被窗口复杂的层次关系搞乱，因此，一旦有了窗口句柄，我们就可以通过 GetWindowText() 得到窗口标题。


枚举进程

　　建立系统进程列表比枚举窗口稍微复杂一些。这主要是因为所用的 API 函数对于不同的 Win32 操作系统有依赖性。在 Windows 9x、Windows Me、Windows 2000 Professional 以及 Windows XP 中，我们可以用 ToolHelp32 库中的 APIs 函数。但是在 Windows NT 里，我们必须用 PSAPI 库中的 APIs 函数， PSAPI 库是 SDK 的一部分。本文我们将讨论上述所有平台中的实现。附带的例子程序将对上述库中的 APIs 进行包装，以便包装后的函数能支持所有 Win32 操作系统。


使用 ToolHelp32 库枚举进程

　　ToolHelp32 库函数在 KERNEL32.dll 中，它们都是标准的 API 函数。但是 Windows NT 4.0 不提供这些函。
　　ToolHelp32 库中有各种各样的函数可以用来枚举系统中的进程、线程以及获取内存和模块信息。其中枚举进程 只需用如下三个的函数：CreateToolhelp32Snapshot()、Process32First()和 Process32Next()。
　　使用 ToolHelp32 函数的第一步是用 CreateToolhelp32Snapshot() 函数创建系统信息“快照”。这个函数可以让你选择存储在快照中的信息类型。如果你只是对进程信息感兴趣，那么只要包含 TH32CS_SNAPPROCESS 标志即可。 CreateToolhelp32Snapshot() 函数返回一个 HANDLE，完成调用之后，必须将此 HANDLE 传给 CloseHandle()。
　　接下来是调用一次 Process32First 函数，从快照中获取进程列表，然后重复调用 Process32Next，直到函数返回 FALSE 为止。这样将遍历快照中进程列表。这两个函数都带两个参数，它们分别是快照句柄和一个   PROCESSENTRY32 结构。
　　调用完 Process32First 或 Process32Next 之后，PROCESSENTRY32 中将包含系统中某个进程的关键信息。其中进程 ID 就存储在此结构的 th32ProcessID。此 ID 可以被传给 OpenProcess() API 以获得该进程的句柄。对应的可执行文件名及其存放路径存放在 szExeFile  结构成员中。在该结构中还可以找到其它一些有用的信息。
　　注意：在调用 Process32First() 之前，一定要记住将 PROCESSENTRY32  结构的 dwSize 成员设置成 sizeof(PROCESSENTRY32)。


使用 PSAPI 库枚举进程

　　在 Windows NT 中，创建进程列表使用 PSAPI 函数，这些函数在 PSAPI.DLL 中。这个文件是随 Platform SDK 一起分发的，最新版本的 Platform SDK 可以从这里下载：

使用这个库所需的 PSAPI.h 和 PSAPI.lib 文件也在该 Platform SDK 中。
　　为了使用 PSAPI 库中的函数，需将 PSAPI.lib 添加到代码项目中，同时在所有调用 PSAPI API 的模块中包含 PSAPI.h 文件。记住一定要随可执行文件一起分发 PSAPI.DLL，因为它不随 Windows NT 一起分发。你可以点击这里单独下载 PSAPI.DLL 的可分发版本（不用完全下载 Platform SDK）。
　　与 ToolHelp32 一样，PSAPI 库也包含各种各样有用的函数。由于篇幅所限，本文只讨论与枚举进程有关函数：EnumProcesses()、 EnumProcessModules()、GetModuleFileNameEx()和 GetModuleBaseName()。
　　创建进程列表的第一步是调用 EnumProcesses()。该函数的声明如下：

BOOL EnumProcesses( DWORD *lpidProcess, DWORD cb, DWORD *cbNeeded );

EnumProcessModules( hProcess, &hModule, sizeof(hModule), &cbReturned );

INT WINAPI VDMEnumTaskWOWEx( DWORD dwProcessId, TASKENUMPROCEX fp,LPARAM lparam );

　　此处 dwProcessId 是 NTVDM 中拟枚举的16位任务进程标示符。参数 fp 是回调枚举函数的指针。参数 lparam 是用户定义的值，它被传递到枚举函数。枚举函数应该被定义成如下这样：

BOOL WINAPI Enum16( DWORD dwThreadId, 
                    WORD hMod16, 
                    WORD hTask16, 
                    PSZ pszModName, 
                    PSZ pszFileName, 
                    LPARAM lpUserDefined );

BOOL WINAPI EnumProcs( PROCENUMPROC lpProc, LPARAM lParam );

使用该函数时，要象下面这样声明回调函数：

BOOL CALLBACK Proc( DWORD dw, WORD w16, LPCSTR lpstr, LPARAM lParam );

posted @ 2008-09-22 18:34 深邃者 阅读(214) | 评论 (0) | 编辑 收藏

如何“干净地”终止 Win32 中的应用程序

   //******************

   // 头文件 TermApp.h

   //******************

   #include <windows.h>

   #define TA_FAILED 0

   #define TA_SUCCESS_CLEAN 1

   #define TA_SUCCESS_KILL 2

   #define TA_SUCCESS_16 3


   DWORD WINAPI TerminateApp( DWORD dwPID, DWORD dwTimeout ) ;

   DWORD WINAPI Terminate16App( DWORD dwPID, DWORD dwThread,

                        WORD w16Task, DWORD dwTimeout );



   //*********************

   // 实现代码 TermApp.cpp

   //*********************

   #include "TermApp.h"

   #include <vdmdbg.h>

   typedef struct

   {

      DWORD   dwID ;

      DWORD   dwThread ;

   } TERMINFO ;

   // 声明回调枚举函数.

   BOOL CALLBACK TerminateAppEnum( HWND hwnd, LPARAM lParam ) ;

   BOOL CALLBACK Terminate16AppEnum( HWND hwnd, LPARAM lParam ) ;

   /*----------------------------------------------------------------

   DWORD WINAPI TerminateApp( DWORD dwPID, DWORD dwTimeout )

   功能:

      关闭 32-位进程(或  Windows 95 下的 16-位进程)

   参数:

      dwPID

         要关闭之进程的进程 ID.

      dwTimeout

         进程关闭前等待的毫秒时间.

   返回值:

      TA_FAILED —— 如果关闭失败.

      TA_SUCCESS_CLEAN —— 如果使用 WM_CLOSE 关闭了进程.

      TA_SUCCESS_KILL —— 如果使用 TerminateProcess() 关闭了进程.

      返回值的定义参见头文件.

   ----------------------------------------------------------------*/

   DWORD WINAPI TerminateApp( DWORD dwPID, DWORD dwTimeout )

   {

      HANDLE   hProc ;

      DWORD   dwRet ;

      // 如果无法用 PROCESS_TERMINATE 权限打开进程，那么立即放弃。

      hProc = OpenProcess(SYNCHRONIZE|PROCESS_TERMINATE, FALSE,dwPID);

      if(hProc == NULL)

      {
         return TA_FAILED ;
      }


      // TerminateAppEnum() 将 WM_CLOSE 消息发到所有其进程ID 与你所提供的进程ID 匹配的窗口.

      EnumWindows((WNDENUMPROC)TerminateAppEnum, (LPARAM) dwPID) ;


      // 等待处理，如果成功，OK。如果超时，则干掉它.

      if(WaitForSingleObject(hProc, dwTimeout)!=WAIT_OBJECT_0)

         dwRet=(TerminateProcess(hProc,0)?TA_SUCCESS_KILL:TA_FAILED);

      else

         dwRet = TA_SUCCESS_CLEAN ;

      CloseHandle(hProc) ;

      return dwRet ;

   }


   /*----------------------------------------------------------------

   DWORD WINAPI Terminate16App( DWORD dwPID, DWORD dwThread,

                        WORD w16Task, DWORD dwTimeout )

   功能:

      关闭 Win16 应用程序.

   参数:

      dwPID

         16-位程序运行其中的 NTVDM 进程 ID.

      dwThread

         16-位程序中执行线程的线程 ID.

      w16Task

         应用程序的 16-位任务句柄.

      dwTimeout

         任务关闭前等待的毫秒时间.



   返回值:

      如果成功, 返回 TA_SUCCESS_16

      如果不成功, 返回 TA_FAILED.      

       返回值的定义参见该函数的头文件.

   注意:

      你可以通过 VDMEnumTaskWOW() 或 VDMEnumTaskWOWEx() 函数获得 Win16 和线程 ID.

   ----------------------------------------------------------------*/

   DWORD WINAPI Terminate16App( DWORD dwPID, DWORD dwThread,

                        WORD w16Task, DWORD dwTimeout )

   {

      HINSTANCE      hInstLib ;

      TERMINFO      info ;

      // 你必须通过外部链接调用函数，以便代码在所有  Win32 平台上都兼容。

      BOOL (WINAPI *lpfVDMTerminateTaskWOW)(DWORD dwProcessId,WORD htask) ;

      hInstLib = LoadLibraryA( "VDMDBG.DLL" ) ;

      if( hInstLib == NULL )
         return TA_FAILED ;

      // 获得函数过程地址.

      lpfVDMTerminateTaskWOW = (BOOL (WINAPI *)(DWORD, WORD ))

         GetProcAddress( hInstLib, "VDMTerminateTaskWOW" ) ;

      if( lpfVDMTerminateTaskWOW == NULL )

      {

         FreeLibrary( hInstLib ) ;

         return TA_FAILED ;

      }

      // 向所有匹配进程 ID 和线程的窗口发送 WM_CLOSE 消息.

      info.dwID = dwPID ;

      info.dwThread = dwThread ;

      EnumWindows((WNDENUMPROC)Terminate16AppEnum, (LPARAM) &info) ;

      // 等待.

      Sleep( dwTimeout ) ;

      // 然后终止.

      lpfVDMTerminateTaskWOW(dwPID, w16Task) ;

      FreeLibrary( hInstLib ) ;

      return TA_SUCCESS_16 ;

   }



   BOOL CALLBACK TerminateAppEnum( HWND hwnd, LPARAM lParam )

   {

      DWORD dwID ;

      GetWindowThreadProcessId(hwnd, &dwID) ;

      if(dwID == (DWORD)lParam)

      {

         PostMessage(hwnd, WM_CLOSE, 0, 0) ;

      }

      return TRUE ;
   }



   BOOL CALLBACK Terminate16AppEnum( HWND hwnd, LPARAM lParam )

   {

      DWORD      dwID ;

      DWORD      dwThread ;

      TERMINFO   *termInfo ;

      termInfo = (TERMINFO *)lParam ;

      dwThread = GetWindowThreadProcessId(hwnd, &dwID) ;

      if(dwID == termInfo->dwID && termInfo->dwThread == dwThread )

      {

         PostMessage(hwnd, WM_CLOSE, 0, 0) ;

      }

      return TRUE ;

   }

posted @ 2008-09-22 18:33 深邃者 阅读(215) | 评论 (0) | 编辑 收藏

SQL

posted @ 2008-09-17 09:45 深邃者 阅读(105) | 评论 (0) | 编辑 收藏

LIST控件

CListCtrl使用技巧

posted @ 2008-09-16 16:24 深邃者 阅读(393) | 评论 (0) | 编辑 收藏