c++ 动态绑定（c++学习笔记）

c++中有一个很好的特性，通过动态绑定我们能够编写使用继承层次中的任意对象，这样做可以在定义函数的时候可以只声明基类的形参但调用的时候可以使用任何的继承层次中的对象

   类的继承和虚函数，使我们可以使用c++中的动态绑定。

 view plaincopy to clipboardprint?
#include <iostream>  
using namespace std;  
 
//基类  
class base  
{  
protected:  
    int cat;  
public:  
    base():cat(0){}  
    virtual void print_cat()  
    {  
        cout<< cat << endl;  
    }  
};  
 
class derive:public base  
{  
public:  
    derive()  
    {  
        cat = 1;  
    }  
    void print_cat()  
    {  
        cout<< cat << endl;  
    }  
};  
 
void fun(base &b)  
{  
    b.print_cat();  
}  
 
int main()  
{  
    base A;  
    derive B;  
    fun(A);//使用基类对象调用函数  
    fun(B);//使用派生类对象调用函数  
    return 0;  
} 
#include <iostream>
using namespace std;

//基类
class base
{
protected:
    int cat;
public:
    base():cat(0){}
    virtual void print_cat()
    {
        cout<< cat << endl;
    }
};

class derive:public base
{
public:
    derive()
    {
        cat = 1;
    }
    void print_cat()
    {
        cout<< cat << endl;
    }
};

void fun(base &b)
{
    b.print_cat();
}

int main()
{
    base A;
    derive B;
    fun(A);//使用基类对象调用函数
    fun(B);//使用派生类对象调用函数
    return 0;
}

 

调用后结果是0  1

在c++中通过基类的引用（或指针）调用虚函数是，引用(或指针)既可以指向基类对象也可以指向派生类对象，指向的对象的类型是引用（或指针）所指向对象的类型。

 大家看到基类和派生类都定义了自己的print_cat函数；

那如果派生类不定义自己的print_cat函数呢？我们来看下代码：view plaincopy to clipboardprint?
#include <iostream>     
using namespace std;     
 
//基类     
class base     
{     
protected:     
    int cat;     
public:     
    base():cat(0){}     
    virtual void print_cat()     
    {     
        cout<< cat << endl;     
    }     
};     
 
class derive:public base     
{     
public:     
    drive()     
    {     
        cat = 1;     
    }     
};  
 
void fun(base &b)     
{     
    b.print_cat();     
}     
 
int main()     
{     
    base A;     
    derive B;  
    fun(A);//使用基类对象调用函数     
    fun(B);//使用派生类对象调用函数     
    return 0;     
} 
#include <iostream>  
using namespace std;  

//基类  
class base  
{  
protected:  
    int cat;  
public:  
    base():cat(0){}  
    virtual void print_cat()  
    {  
        cout<< cat << endl;  
    }  
};  

class derive:public base  
{  
public:  
    drive()  
    {  
        cat = 1;  
    }  
};

void fun(base &b)  
{  
    b.print_cat();  
}  

int main()  
{  
    base A;  
    derive B;
    fun(A);//使用基类对象调用函数  
    fun(B);//使用派生类对象调用函数  
    return 0;  
}

最后执行结果为 0    0

看来来后一个调用了基类的print_cat函数；

这是为什么呢？因为c++ 规定如果派生类没有重定义某个虚函数，则使用基类中定义的版本。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/z0203153008/archive/2009/09/28/4604570.aspx