ATL技术内幕 第二部分

最新推荐文章于 2025-04-23 17:29:15 发布
最新推荐文章于 2025-04-23 17:29:15 发布
阅读量3.1k 收藏 3
点赞数 1
分类专栏： windows 文章标签： fun class function 设计模式 c 编译器

题目：ATL Under the Hood - Part 2

原文链接：http://www.codeproject.com/Articles/1846/ATL-Under-the-Hood-Part-2

介绍

这个系列我们将讨论ATL的内部工作机制以及技术实现。这是第二部分。

现在，让我们揭开虚函数背后的那些有趣的东西。（为了与第一部分保持连续性，我延续前面的程序数）

下面我们看这段代码：

程序 20

#include <iostream>
using namespace std;

class Base {
public:
    virtual void fun() {
        cout << "Base::fun" << endl;
    }
    void show() {
        fun();
    }
};

class Drive : public Base {
public:
    virtual void fun() {
        cout << "Drive::fun" << endl;
    }
};

int main() {
    Drive d;
    d.show();

    return 0;
}
输出结果如下：
Drive::fun
这段代码揭示了，在被调用函数是虚函数的情况下，一个基类函数如何调用派生类的函数。这个技术被用在很多不同的框架中，比如MFC 和 像模板设计模式之类的设计模式等。现在，我们对程序稍作改动，来看看其行为。现在，我们在基类的构造函数而不是成员函数中调用虚函数。

程序 21

#include <iostream>
using namespace std;

class Base {
public:
    Base() {
        fun();
    }
    virtual void fun() {
        cout << "Base::fun" << endl;
    }
};

class Drive : public Base {
public:
    virtual void fun() {
        cout << "Drive::fun" << endl;
    }
};

int main() {
    Drive d;

    return 0;
}

输出结果是：

Base::fun
这个程序显示，我们不可以在基类的构造函数中调用派生类的虚函数。为了看清楚内部原因，我们在两个构造函数中分别打印this指针（该类自身的指针）。为了简化，我们移除了类中其他的函数。

程序 22

#include <iostream>
using namespace std;

class Base {
public:
    Base() {
        cout << "In Base" << endl;
        cout << "This Pointer = " << (int*)this << endl;
        cout << endl;
    }
virtual void f() { cout << "Base::f" << endl; }
};

class Drive : public Base {
public:
    Drive() {
        cout << "In Drive" << endl;
        cout << "This Pointer = " << (int*)this << endl;
        cout << endl;
    }
virtual void f() { cout << "Drive::f" << endl; }
};

int main() {
    Drive d;
    cout << "In Main" << endl;
    cout << (int*)&d << endl;

    return 0;
}

程序输出结果为：

In Base
This Pointer = 0012FF7C

In Drive
This Pointer = 0012FF7C

In Main
0012FF7C

结果表明：在内存中只有一个对象。现在我们来打印this指针的值，也就是虚指针的值，以及虚表的值（也就是虚指针值所指的对象的值）。

程序 23

#include <iostream>
using namespace std;

class Base {
public:
    Base() {
        cout << "In Base" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable = " << (int*)*(int*)*(int*)this << endl;
        cout << endl;
    }
    virtual void f1() { cout << "Base::f1" << endl; }
};

class Drive : public Base {
public:
    Drive() {
        cout << "In Drive" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable = " << (int*)*(int*)*(int*)this << endl;
        cout << endl;
    }
    virtual void f1() { cout << "Drive::f2" << endl; }
};

int main() {
    Drive d;
    return 0;
}

The output of this program is

In Base
Virtual Pointer = 0012FF7C
Address of Vtable = 0046C08C
Value at Vtable = 004010F0

In Drive
Virtual Pointer = 0012FF7C
Address of Vtable = 0046C07C
Value at Vtable = 00401217
这个程序显示基类和派生类有着不同的虚表地址。为了更好地理解，让我们再添加一层的继承，然后构造一个该类的对象。

程序 24

#include <iostream>
using namespace std;

class Base {
public:
    Base() {
        cout << "In Base" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable = " << (int*)*(int*)*(int*)this << endl;
        cout << endl;
    }
    virtual void f1() { cout << "Base::f1" << endl; }
};

class Drive : public Base {
public:
    Drive() {
        cout << "In Drive" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable = " << (int*)*(int*)*(int*)this << endl;
        cout << endl;
    }
    virtual void f1() { cout << "Drive::f2" << endl; }
};

class MostDrive : public Drive {
public:
    MostDrive() {
        cout << "In MostDrive" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable = " << (int*)*(int*)*(int*)this << endl;
        cout << endl;
    }
    virtual void f1() { cout << "MostDrive::f2" << endl; }
};

int main() {
    MostDrive d;
    return 0;
}

The output of this program is

In Base
Virtual Pointer = 0012FF7C
Address of Vtable = 0046C0A0
Value at Vtable = 004010F5

In Drive
Virtual Pointer = 0012FF7C
Address of Vtable = 0046C090
Value at Vtable = 00401221

In MostDrive
Virtual Pointer = 0012FF7C
Address of Vtable = 0046C080
Value at Vtable = 00401186
这个程序显示虚指针是在每个类的构造函数中初始化的。因此，虚表的地址在每个类的构造函数中是不同的，而主函数创建了继承链最下层的对象，并调用这个对象的虚表。
现在我们看看每个类的构造函数在虚表中放了什么。为此，我们要利用函数指针来存储虚表中的第一个元素，然后来执行它。

程序 25

#include <iostream>
using namespace std;

typedef void(*Fun)();

class Base {
public:
    Base() {
        cout << "In Base" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable = " << (int*)*(int*)*(int*)this << endl;

        Fun pFun = (Fun)*(int*)*(int*)this;
        pFun();
        cout << endl;
    }
    virtual void f1() { cout << "Base::f1" << endl; }
};

class Drive : public Base {
public:
    Drive() {
        cout << "In Drive" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable = " << (int*)*(int*)*(int*)this << endl;
        
        Fun pFun = (Fun)*(int*)*(int*)this;
        pFun();
        cout << endl;
    }
    virtual void f1() { cout << "Drive::f1" << endl; }
};

class MostDrive : public Drive {
public:
    MostDrive() {
        cout << "In MostDrive" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable = " << (int*)*(int*)*(int*)this << endl;
        
        Fun pFun = (Fun)*(int*)*(int*)this;
        pFun();
        cout << endl;
    }
    virtual void f1() { cout << "MostDrive::f1" << endl; }
};

int main() {
    MostDrive d;
    return 0;
}

上述程序的输出结果是：

In Base
Virtual Pointer = 0012FF7C
Address of Vtable = 0046C098
Value at Vtable = 004010F5
Base::f1

In Drive
Virtual Pointer = 0012FF7C
Address of Vtable = 0046C088
Value at Vtable = 00401221
Drive::f1

In MostDrive
Virtual Pointer = 0012FF7C
Address of Vtable = 0046C078
Value at Vtable = 00401186
MostDrive::f1

这个程序显示每个类的构造函数利用自己的虚函数填充虚表。也就是说，基类用基类的虚函数地址填充虚表，当派生类构造函数执行时，他将创建另一个虚表然后将其自身的虚函数地址存入。

现在我们看看这种情况：基类有多个虚函数，而子类重写了其中的一部分。

程序 26

#include <iostream>
using namespace std;

class Base {
public:
    Base() {
        cout << "In Base" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable 1st entry = " << (int*)*((int*)*(int*)this+0) << endl;
        cout << "Value at Vtable 2nd entry = " << (int*)*((int*)*(int*)this+1) << endl;
        cout << "Value at Vtable 3rd entry = " << (int*)*((int*)*(int*)this+2) << endl;
cout << endl;
    }
    virtual void f1() { cout << "Base::f1" << endl; }
    virtual void f2() { cout << "Base::f2" << endl; }
};

class Drive : public Base {
public:
    Drive() {
        cout << "In Drive" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable 1st entry = " << (int*)*((int*)*(int*)this+0) << endl;
        cout << "Value at Vtable 2nd entry = " << (int*)*((int*)*(int*)this+1) << endl;
        cout << "Value at Vtable 3rd entry = " << (int*)*((int*)*(int*)this+2) << endl;
        cout << endl;
    }
    virtual void f1() { cout << "Drive::f1" << endl; }
};

int main() {
    Drive d;
    return 0;
}

这个程序的输出如下：

In Base
Virtual Pointer = 0012FF7C
Address of Vtable = 0046C0E0
Value at Vtable 1st entry = 004010F0
Value at Vtable 2nd entry = 00401145
Value at Vtable 3rd entry = 00000000

In Drive
Virtual Pointer = 0012FF7C
Address of Vtable = 0046C0C8
Value at Vtable 1st entry = 0040121C
Value at Vtable 2nd entry = 00401145
Value at Vtable 3rd entry = 00000000

这个程序的输出显示，如果子类没有重写父类的虚函数，那子类的构造函数将保留父类虚函数所对应的虚表位置，不做任何处理。从个这个例子，可以清楚的看到，子类若不实现虚函数，将调用父类的虚函数。

现在我们引入纯虚函数，通过下面的例子，来看看其行为。

程序 27

#include <iostream>
using namespace std;

class Base {
public:
    Base() {
        cout << "In Base" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable 1st entry = " << (int*)*((int*)*(int*)this+0) << endl;
        cout << "Value at Vtable 2nd entry = " << (int*)*((int*)*(int*)this+1) << endl;
        cout << endl;
    }
    virtual void f1() = 0;
    virtual void f2() = 0;
};

class Drive : public Base {
public:
    Drive() {
        cout << "In Drive" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable 1st entry = " << (int*)*((int*)*(int*)this+0) << endl;
        cout << "Value at Vtable 2nd entry = " << (int*)*((int*)*(int*)this+1) << endl;
        cout << endl;
    }
    virtual void f1() { cout << "Drive::f1" << endl; }
    virtual void f2() { cout << "Drive::f2" << endl; }
};

int main() {
    Drive d;

    return 0;
}

这个函数的输出在debug和release模式下，有少许的不同，下面是debug模式下的输出：

In Base
Virtual Pointer = 0012FF7C
Address of Vtable = 0046C0BC
Value at Vtable 1st entry = 00420CB0
Value at Vtable 2nd entry = 00420CB0

In Drive
Virtual Pointer = 0012FF7C
Address of Vtable = 0046C0A4
Value at Vtable 1st entry = 00401212
Value at Vtable 2nd entry = 0040128F

下面是release模式下的输出：

In Base
Virtual Pointer = 0012FF80
Address of Vtable = 0042115C
Value at Vtable 1st entry = 0041245D
Value at Vtable 2nd entry = 0041245D

In Drive
Virtual Pointer = 0012FF80
Address of Vtable = 00421154
Value at Vtable 1st entry = 00401310
Value at Vtable 2nd entry = 00401380

为了更好地理解，我们对程序稍作改动，尝试用函数指针调用虚函数。

程序 28

#include <iostream>
using namespace std;

typedef void(*Fun)();

class Base {
public:
    Base() {
        cout << "In Base" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable 1st entry = " << (int*)*((int*)*(int*)this+0) << endl;
        cout << "Value at Vtable 2nd entry = " << (int*)*((int*)*(int*)this+1) << endl;
        
        // try to execute first virtual function
        Fun pFun = (Fun)*((int*)*(int*)this+0);
        pFun();

        cout << endl;
    }
    virtual void f1() = 0;
    virtual void f2() = 0;
};

class Drive : public Base {
public:
    Drive() {
        cout << "In Drive" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable 1st entry = " << (int*)*((int*)*(int*)this+0) << endl;
        cout << "Value at Vtable 2nd entry = " << (int*)*((int*)*(int*)this+1) << endl;
        cout << endl;
    }
    virtual void f1() { cout << "Drive::f1" << endl; }
    virtual void f2() { cout << "Drive::f2" << endl; }
};

int main() {
    Drive d;

    return 0;
}

现在，debug和release模式的结果页不同，在debug模式下，显示了如下的运行时错误：




当我们点击”忽略“时，程序终止了。



在release模式下程序会直接退出。

In Base
Virtual Pointer = 0012FF80
Address of Vtable = 0042115C
Value at Vtable 1st entry = 0041245D
Value at Vtable 2nd entry = 0041245D

runtime error R6025
- pure virtual function call

这里的错误：R6025是什么意思？它的定义可以在CMSGS.h中找到，其实这个头文件里定义了所有的C运行时库的错误消息。

#define _RT_PUREVIRT_TXT   "R6025" EOL "- pure virtual function call" EOL

实际上，当我们定义一个纯虚函数时，编译器会将C运行时库的函数之一：_purecall放入虚表中。这个函数在PUREVIRT.C文件中定义，有如下的原型：

void __cdecl _purecall(void)

我们可以通过直接调用这个函数得到上述同样的结果。让我们看看这个非常袖珍的程序 ：

程序 29

int main() {
    _purecall();    
    return 0;
}

这个程序的输出不管在debug合适release模式下和前面的那个都完全一样。为了更好地理解其中的缘由，我们将继承链加深，再加一层继承，看看结果如何：

程序 30

#include <iostream>
using namespace std;

class Base {
public:
    Base() {
        cout << "In Base" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable 1st entry = " << (int*)*((int*)*(int*)this+0) << endl;
        cout << "Value at Vtable 2nd entry = " << (int*)*((int*)*(int*)this+1) << endl;
        cout << endl;
    }
    virtual void f1() = 0;
    virtual void f2() = 0;
};

class Drive : public Base {
public:
    Drive() {
        cout << "In Drive" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable 1st entry = " << (int*)*((int*)*(int*)this+0) << endl;
        cout << "Value at Vtable 2nd entry = " << (int*)*((int*)*(int*)this+1) << endl;
        cout << endl;
    }
};

class MostDrive : public Drive {
public:
    MostDrive() {
        cout << "In MostDrive" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable 1st entry = " << (int*)*((int*)*(int*)this+0) << endl;
        cout << "Value at Vtable 2nd entry = " << (int*)*((int*)*(int*)this+1) << endl;
        cout << endl;
    }
    virtual void f1() { cout << "MostDrive::f1" << endl; }
    virtual void f2() { cout << "MostDrive::f2" << endl; }
};

int main() {
    MostDrive d;

    return 0;
}

这个程序输出结果如下：

In Base
Virtual Pointer = 0012FF7C
Address of Vtable = 0046C0D8
Value at Vtable 1st entry = 00420F40
Value at Vtable 2nd entry = 00420F40

In Drive
Virtual Pointer = 0012FF7C
Address of Vtable = 0046C0C0
Value at Vtable 1st entry = 00420F40
Value at Vtable 2nd entry = 00420F40

In MostDrive
Virtual Pointer = 0012FF7C
Address of Vtable = 0046C0A8
Value at Vtable 1st entry = 00401186
Value at Vtable 2nd entry = 004010F5

这个程序结果显示，父类和子类都构造他们自己的虚表，并且用同样的值来初始化。如果继承链更加长，而且除了最底层的派生类外，其他派生类都没有重写任何的父类纯虚函数，这时会发生什么情况呢？这种情况其实在COM编程时就会遇到，因为COM编程中，接口就是只有纯虚函数的类，一个接口继承自另一个接口，他们都没有实现这些接口中的纯虚函数，直到实现类重写了这些接口中的纯虚函数。此时，每一个父类构造函数构造他们自己的虚表，并且放同样的值到其虚表入口，这意味着同样的代码在进行着大量的重复。

ATL主要的理念就是让COM组件尽可能的小，但是由于虚表的存在，接口类的构造函数含有大量不必要的代码。为解决这个问题，ATL引入一个宏ATL_NO_VTABLE，定义在ATLDEF.H中：

#define ATL_NO_VTABLE __declspec(novtable)

__declspec(novtable) 是微软C++类的扩展属性。当类拥有这个属性时，编译器就不会添加初始化虚指针和虚表的代码，从而来减少代码量。

对我们的程序稍作修改，看看这个属性对我们有什么用：

程序 31

#include <iostream>
using namespace std;

class Base {
public:
    Base() {
        cout << "In Base" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable 1st entry = " << (int*)*((int*)*(int*)this+0) << endl;
        cout << "Value at Vtable 2nd entry = " << (int*)*((int*)*(int*)this+1) << endl;
        cout << endl;
    }
    virtual void f1() = 0;
    virtual void f2() = 0;
};

class Drive : public Base {
public:
    Drive() {
        cout << "In Drive" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable 1st entry = " << (int*)*((int*)*(int*)this+0) << endl;
        cout << "Value at Vtable 2nd entry = " << (int*)*((int*)*(int*)this+1) << endl;
        cout << endl;
    }
};

class __declspec(novtable) MostDrive : public Drive {
public:
    MostDrive() {
        cout << "In MostDrive" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable 1st entry = " << (int*)*((int*)*(int*)this+0) << endl;
        cout << "Value at Vtable 2nd entry = " << (int*)*((int*)*(int*)this+1) << endl;
        cout << endl;
    }
    virtual void f1() { cout << "MostDrive::f1" << endl; }
    virtual void f2() { cout << "MostDrive::f2" << endl; }
};

int main() {
    MostDrive d;

    return 0;
}

程序的输出结果如下：

In Base
Virtual Pointer = 0012FF7C
Address of Vtable = 0046C0CC
Value at Vtable 1st entry = 00420E60
Value at Vtable 2nd entry = 00420E60

In Drive
Virtual Pointer = 0012FF7C
Address of Vtable = 0046C0B4
Value at Vtable 1st entry = 00420E60
Value at Vtable 2nd entry = 00420E60

In MostDrive
Virtual Pointer = 0012FF7C
Address of Vtable = 0046C0B4
Value at Vtable 1st entry = 00420E60
Value at Vtable 2nd entry = 00420E60

这个程序显示了一下结果：首先Drive和MostDrive类的虚指针内容一致，但是Base类不一样。这是因为我们没有在基类中利用__declspec(novtable)属性。现在稍作改变，我们用同样的属性修饰Drive类

程序 32

#include <iostream>
using namespace std;

class Base {
public:
    Base() {
        cout << "In Base" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable 1st entry = " << (int*)*((int*)*(int*)this+0) << endl;
        cout << "Value at Vtable 2nd entry = " << (int*)*((int*)*(int*)this+1) << endl;
        cout << endl;
    }
    virtual void f1() = 0;
    virtual void f2() = 0;
};

class __declspec(novtable) Drive : public Base {
public:
    Drive() {
        cout << "In Drive" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable 1st entry = " << (int*)*((int*)*(int*)this+0) << endl;
        cout << "Value at Vtable 2nd entry = " << (int*)*((int*)*(int*)this+1) << endl;
        cout << endl;
    }
};

class __declspec(novtable) MostDrive : public Drive {
public:
    MostDrive() {
        cout << "In MostDrive" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable 1st entry = " << (int*)*((int*)*(int*)this+0) << endl;
        cout << "Value at Vtable 2nd entry = " << (int*)*((int*)*(int*)this+1) << endl;
        cout << endl;
    }
    virtual void f1() { cout << "MostDrive::f1" << endl; }
    virtual void f2() { cout << "MostDrive::f2" << endl; }
};

int main() {
    MostDrive d;

    return 0;
}

输出结果如下：

In Base
Virtual Pointer = 0012FF7C
Address of Vtable = 0046C0C0
Value at Vtable 1st entry = 00420E50
Value at Vtable 2nd entry = 00420E50

In Drive
Virtual Pointer = 0012FF7C
Address of Vtable = 0046C0C0
Value at Vtable 1st entry = 00420E50
Value at Vtable 2nd entry = 00420E50

In MostDrive
Virtual Pointer = 0012FF7C
Address of Vtable = 0046C0C0
Value at Vtable 1st entry = 00420E50
Value at Vtable 2nd entry = 00420E50

在MSDN中提及，__declspec(novtable)应该用在纯虚类中。为了更好地理解这个说法，我们再做一个实验：

程序 33

#include <iostream>
using namespace std;

class Base {
public:
    Base() {
        cout << "In Base" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable 1st entry = " << (int*)*((int*)*(int*)this+0) << endl;
        cout << "Value at Vtable 2nd entry = " << (int*)*((int*)*(int*)this+1) << endl;
        cout << endl;
    }
    virtual void f1() = 0;
    virtual void f2() = 0;
};

class __declspec(novtable) Drive : public Base {
public:
    Drive() {
        cout << "In Drive" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable 1st entry = " << (int*)*((int*)*(int*)this+0) << endl;
        cout << "Value at Vtable 2nd entry = " << (int*)*((int*)*(int*)this+1) << endl;
        cout << endl;
    }
};

class __declspec(novtable) MostDrive : public Drive {
public:
    MostDrive() {
        cout << "In MostDrive" << endl;
        cout << "Virtual Pointer = " << (int*)this << endl;
        cout << "Address of Vtable = " << (int*)*(int*)this << endl;
        cout << "Value at Vtable 1st entry = " << (int*)*((int*)*(int*)this+0) << endl;
        cout << "Value at Vtable 2nd entry = " << (int*)*((int*)*(int*)this+1) << endl;
        cout << endl;

        // 尝试调用第一个虚函数
        typedef void (*Fun)();
        Fun pFun = (Fun)*((int*)*(int*)this+0);
        pFun();

    }
    virtual void f1() { cout << "MostDrive::f1" << endl; }
    virtual void f2() { cout << "MostDrive::f2" << endl; }
};

int main() {
    MostDrive d;

    return 0;
}

我们在程序中加入了以下代码：

        // 尝试调用第一个虚函数
        typedef void (*Fun)();
        Fun pFun = (Fun)*((int*)*(int*)this+0);
        pFun();

当我们运行程序时，我们遇到的问题与调用纯虚函数完全一样。这意味着，虚表没有初始化。其实这是因为MostDrive函数的__declspec(novtable)属性导致的，因为它不是一个抽象类，所以，应该去掉该属性。

程序 34

#include <iostream>
using namespace std;

class Base {
public:
    virtual void f1() = 0;
    virtual void f2() = 0;
};

class __declspec(novtable) Drive : public Base {
};

class MostDrive : public Drive {
public:
    MostDrive() {

        // try call first virtual function
        typedef void (*Fun)();
        Fun pFun = (Fun)*((int*)*(int*)this+0);
        pFun();

    }
    virtual void f1() { cout << "MostDrive::f1" << endl; }
    virtual void f2() { cout << "MostDrive::f2" << endl; }
};

int main() {
    MostDrive d;

    return 0;
}

现在，这个程序运行很好，输出结果如下：

MostDrive::f1

这个属性不一定非得用于ATL类，也可以用在任何不允许实例化的抽象类。当然，ATL也不是非要用这个属性不可，只是移除了这个属性将使得ATL类产生更多的代码量。


本部分完。

 

ATL与WTL学习资料[pdf]
01-05
本系列原来是为 VC 6 用户写的，介绍 WTL 7.0 的内容。现在 VC 8 已经出来了，我觉得也到了更新本系列来介绍 VC 7.1 的时候了。;)（不过，VC 7.1 的从 6 到 7 的自动转换工作并不是总能平滑地完成，所以 VC 7.1 的用户在试 着使用示例源代码的时候可能会遭遇失败）因而，我将继续下去，持续更新本系列。文章将更新到可以反映 WTL 7.1 的特性，并会在下载的源代码中包括 VC 7.1 的工程。
ATL 技术内幕 ATL技术内幕
01-19
ATL技术内幕ATL技术内幕ATL技术ATL技术内幕内幕
深入解析ATL（第二版ATL8.0）(1.1-1.3节）
C++、.NET、WPF、Android
08-22 2421
深入解析ATL（第二版ATL8.0），文章在这里：http://www.cppblog.com/TechLab/articles/11561.html
《ATL Internals》书评 . 潘爱民
05-07 1945
潘爱民 提供 2000/06/12 未经作者允许任何机构或个人不得以任何方式转载或复制本文ATL之深入浅出介绍一本关于ATL的书《ATL Internals》潘爱民，5月7日，2000年北京大学计算机研究所，100871引言面对计算机图书市场的繁荣景象，我经常感叹今天学习计算机开发技术的同道们是多么幸运。十年前，我们学习计算机语言非常不容易，要掌握各
ATL技术内幕 第四部分
06-16 1403
前言：这一系列博客翻译自 The Code Project 上的文章，作者是Zeeshan amjad。 题目：ATL Under the Hood - Part 4 原文链接：http://www.codeproject.com/Articles/2387/ATL-Under-the-Hood-Part-4 介绍 目前为止我们还没有讨论汇编语言。但如果想知道ATL的内幕，这是不可避免的。
ATL技术内幕 第五部分 （完结篇）
06-25 3463
前言：这一系列博客翻译自 The Code Project 上的文章，作者是Zeeshan amjad。 题目：ATL Under the Hood - Part 4 原文链接：http://www.codeproject.com/Articles/3102/ATL-Under-the-Hood-Part-5 介绍 很多人认为ATL仅仅是用来创造COM组件。实际上你可以利用ATL的窗口类，
ATL技术内幕 第一部分
06-08 1946
前言：这一系列博客翻译自 The Code Project 上的文章，作者是Zeeshan amjad。 题目：ATL Under the Hood -  Part 1 原文链接：http://www.codeproject.com/Articles/1769/ATL-Under-the-Hood-Part-1   介绍 这个系列我们将讨论ATL的内部机制以及技术细节。 让我们先来看一
深入解析ATL(第2版)_pdf版本
11-19
"深入解析ATL(第2版)"这本书是学习和掌握ATL技术的重要资源，无论你是对COM编程感兴趣，还是希望提升C++开发效率，都可以从中受益。通过阅读和实践，你可以充分利用ATL的强大功能，高效地创建COM组件和服务。
深入解析ATL(第2版)PDF 高清中文版
12-16
深入解析ATL(第2版)PDF 高清中文版 ATL8.0 VS2005 part5
VC技术内幕第五版
03-08
《VC技术内幕第五版》是深入探讨Microsoft Visual C++（简称VC++）编程技术的一本专业书籍，尤其针对其更新的版本进行了详尽的解析。这本书涵盖了从基础概念到高级特性的广泛内容，旨在帮助开发者深入理解VC++的内部...
（中文版、PDF格式）Microsoft_NET程序设计技术内幕.pdf
10-13
中文版的PDF格式的《Microsoft.NET程序设计技术内幕》
com好书合集 com本质论 COM原理与应用COM技术内幕 深入解析ATL
05-04
com本质论 COM原理与应用COM技术内幕 深入解析ATL，可以按这个顺序来看这些书，以上愚见，请指点.
深入解析ATL(第2版) ATL internals 2nd Edition Working with ATL8
08-11
清晰pdf ,这是第二部分。 ATL的发明人Jim Springfield亲自作序推荐 四位顶尖的Windows编程专家倾力合作，绝对经典再现 COM、ATL开发人员的必备宝典 深入分析ATL实现COM内幕细节，展示COM应用中的各类漂亮技巧 ...
visual.c_6.0技术内幕第五版.rar
04-22
《Visual C++ 6.0技术内幕第五版》是一本深度探讨Microsoft的Visual C++ 6.0开发环境和编程语言的专业书籍。该资源包含了多个文件，包括下载说明、注册表文件、说明文档以及主体书籍内容。以下是关于Visual C++ 6.0...
23种设计模式-结构型模式之享元模式（Java版本）
最新发布
DreamCollector的博客
04-23 542
享元模式是一种，它通过来减少内存消耗，适用于大量细粒度对象的场景。关键思想是，避免重复创建。
VC++技术内幕第四版：源代码精华解析
《VC++技术内幕（第四版）》这本书是一本深入介绍Visual C++编程的经典之作，由Andrei Alexandrescu所著，主要面向中高级程序员。本书以其权威性、系统性和详尽的内容成为VC++开发领域的一部重要参考书籍。其中所...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值