c++学习笔记--虚函数和多态的重新认识

　　从看《Effective c++》以来，越发的觉得自己应该重新学习c++。但还是从零碎的知识中开始拾起，慢慢前进吧。

　　多态性

　　指相同对象收到不同消息或不同对象收到相同消息时产生不同的实现动作。C++支持两种多态性：编译时多态性，运行时多态性。
　　a.编译时多态性：通过重载函数实现
　　b 运行时多态性：通过虚函数实现。

 

　　包含纯虚函数的类称为抽象类。由于抽象类包含了没有定义的纯虚函数，所以不能定义抽象类的对象。

 

　　

引用以下文字：

　　

　　编译器到底做了什么实现的虚函数的晚绑定呢？我们来探个究竟。

　　编译器对每个包含虚函数的类创建一个表（称为V TA B L E）。在V TA B LE中，编译器放置特定类的虚函数地址。在每个带有虚函数的类中，编译器秘密地置一指针，称为v p o i n t e r（缩写为V P TR），指向这个对象的V TA B L E。通过基类指针做虚函数调用时（也就是做多态调用时），编译器静态地插入取得这个V P T R，并在VTA B L E表中查找函数地址的代码，这样就能调用正确的函数使晚捆绑发生。为每个类设置V TA B L E、初始化V P TR、为虚函数调用插入代码，所有这些都是自动发生的，所以我们不必担心这些。利用虚函数，这个对象的合适的函数就能被调用，哪怕在编译器还不知道这个对象的特定类型的情况下。（《C++编程思想》）

 

 

 

以下内容来自　“VC知识库”

 

三、虚函数在内存中的结构

1．我们先看一个例子：

#include "iostream.h"
#include "string.h"

class A {
public:
virtual void fun0() { cout << "A::fun0" << endl; }
};


int main(int argc, char* argv[])
{
A  a;
cout << "Size of A = " << sizeof(a) << endl;
return 0;
}      

结果如下：Size of A = 4

2．如果再添加一个虚函数：virtual void fun1() { cout << "A::fun" << endl;}
得到相同的结果。如果去掉函数前面的virtual修饰符

class A {
public:
void fun0() { cout << "A::fun0" << endl; }
};


int main(int argc, char* argv[])
{
A  a;
cout << "Size of A = " << sizeof(a) << endl;
return 0;
}      

结果如下：Size of A = 1

3．在看下面的结果：

class A {
public:
virtual void fun0() { cout << "A::fun0" << endl; }
int a;
int b;
};
int main(int argc, char* argv[])
{
A  a;
cout << "Size of A = " << sizeof(a) << endl;
return 0;
}      

结果如下：Size of A = 12

其实虚函数在内存中结构是这样的:


图一

   在window2000下指针在内存中占4个字节，虚函数在一个虚函数表(VTABLE)中保存函数地址。在看下面例子。

class A {
public:
virtual void fun0() { cout << "A::fun0" << endl; }
virtual void fun1() { cout << "A::fun1" << endl; }
int a;
int b;
};
int main(int argc, char* argv[])
{
A  a;
cout << "Size of A = " << sizeof(a) << endl;
return 0;
}
      

结果如下：结果如下：
Size of A = 4

   虚函数的内存结构如下，你也可以通过函数指针，先找到虚函数表(VTABLE),然后访问每个函数地址来验证这种结构，在国外网站作者是：Zeeshan Amjad写的"ATL on the Hood中有详细介绍"


图二

4．我们再来看看继承中虚函数的内存结构，先看下面的例子

class A {
public:
virtual void f() { }
};
class B {
public:
virtual void f() { }
};
class C {
public:
virtual void f() { }
};
class Drive : public A, public B, public C {
};
int main() {
Drive d;
cout << "Size is = " << sizeof(d) << endl;
return 0;
}      

结果如下：Size is = 12 ，相信大家一看下面的结构图就会很清楚，


图三

5.我们再来看看用虚函数实现多态性，先看个例子：

class A {
public:
virtual void f() { cout << "A::f" << endl; }
};
class B :public A{
public:
virtual void f() { cout << "B::f" << endl;}
};
class C :public A {
public:
virtual void f() { cout << "C::f" << endl;}
};
class Drive : public C {
public:
virtual void f() { cout << "D::f" << endl;}
};

int main(int argc, char* argv[])
{
A a;
B b;
C c;
Drive d;
a.f();
b.f();
c.f();
d.f();
return 0;
}
结果：A::f
B::f
C::f
D::f
      

不用解释，相信大家一看就明白什么道理！注意：多态不是函数重载

6．用虚函数实现动态连接在编译期间，C++编译器根据程序传递给函数的参数或者函数返回类型来决定程序使用那个函数，然后编译器用正确的的函数替换每次启动。这种基于编译器的替换被称为静态连接，他们在程序运行之前执行。另一方面，当程序执行多态性时，替换是在程序执行期进行的，这种运行期间替换被称为动态连接。如下例子：

class A{
public:
virtual void f(){cout << "A::f" << endl;};
};

class B:public A{
public:
virtual void f(){cout << "B::f" << endl;};
};
class C:public A{
public:
virtual void f(){cout << "C::f" << endl;};
};
void test(A *a){
a->f();
};
int main(int argc, char* argv[])
{     
B *b=new B;
C *c=new C;
char choice;
do{
cout<<"type  B for class B,C for class C:"<<endl;
cin>>choice;
if(choice==''b'')
test(b);
else if(choice==''c'')
test(c);
}while(1);
cout<<endl<<endl;
    return 0;
}

    在上面的例子中，如果把类A,B,C中的virtual修饰符去掉，看看打印的结果，然后再看下面一个例子想想两者的联系。如果把B和C中的virtual修饰符去掉，又会怎样，结果和没有去掉一样。

7．在基类中调用继承类的函数（如果此函数是虚函数才能如此）还是先看例子：

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

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

int main() {
    A a;
    a.show();

    return 0;
}      

打印结果：A::fun

    在6中的例子中，test(A*a)其实有一个继承类指针向基类指针隐式转化的过程。可以看出利用虚函数我们可以在基类调用继承类函数。但如果不是虚函数，继承类指针转化为基类指针后只可以调用基类函数。反之，如果基类指针向继承类指针转化的情况怎样，这只能进行显示转化，转化后的继承类指针可以调用基类和继承类指针。如下例子：

class A {
public:
    void fun() {
        cout << "A::fun" << endl;
    }
    
};
class B : public A {
public:
void fun() {
cout << "B::fun" << endl;
}
void fun0() {
        cout << "B::fun0" << endl;
    }
};
int main() {
    A *a=new A;
B *b=new B;
A *pa;
B *pb;
pb=static_cast<B *>(a); //基类指针向继承类指针进行显示转化
    pb->fun0();
pb->fun();
    return 0;
}