c++ 虛函數(shù)與純虛函數(shù)的區(qū)別(深入分析)
更新時間:2013年05月28日 16:13:16 作者:
本篇文章是對c++中虛函數(shù)與純虛函數(shù)的區(qū)別進行了詳細(xì)的分析介紹,需要的朋友參考下
在面向?qū)ο蟮腃++語言中,虛函數(shù)(virtual function)是一個非常重要的概念。因為它充分體現(xiàn) 了面向?qū)ο笏枷胫械睦^承和多態(tài)性這兩大特性,在C++語言里應(yīng)用極廣。比如在微軟的MFC類庫中,你會發(fā)現(xiàn)很多函數(shù)都有virtual關(guān)鍵字,也就是說, 它們都是虛函數(shù)。難怪有人甚至稱虛函數(shù)是C++語言的精髓。
那么,什么是虛函數(shù)呢,我們先來看看微軟的解釋:
虛函數(shù)是指一個類中你希望重載的成員函數(shù),當(dāng)你用一個基類指針或引用指向一個繼承類對象的時候,你調(diào)用一個虛函數(shù),實際調(diào)用的是繼承類的版本。 這個定義說得不是很明白。MSDN中還給出了一個例子,但是它的例子也并不能很好的說明問題。我們自己編寫這樣一個例子:
#include "stdio.h"
#include "conio.h"
class Parent
{
public:
char data[20];
void Function1();
virtual void Function2(); // 這里聲明Function2是虛函數(shù)
}parent;
void Parent::Function1()
{
printf("This is parent,function1\n");
}
void Parent::Function2()
{
printf("This is parent,function2\n");
}
class Child: public Parent
{
void Function1();
void Function2();
} child;
void Child::Function1()
{
printf("This is child,function1\n");
}
void Child::Function2()
{
printf("This is child,function2\n");
}
int main(int argc, char* argv[])
{
Parent *p; // 定義一個基類指針
if ( _getch()=='c' ) // 如果輸入一個小寫字母c
p=&child; // 指向繼承類對象
else
p=&parent; // 否則指向基類對象
p->Function1(); // 這里在編譯時會直接給出Parent::Function1()的 入口地址。
p->Function2(); // 注意這里,執(zhí)行的是哪一個Function2?
return 0;
}
用任意版本的Visual C++或Borland C++編譯并運行,輸入一個小寫字母c,得到下面的結(jié)果:
This is parent,function1
This is child,function2
為什么會有第一行的結(jié)果呢?因為我們是用一個Parent類的指針調(diào)用函數(shù)Fuction1(),雖然實際上這個指針指向的是Child類的對象,但編譯器 無法知道這一事實(直到運行的時候,程序才可以根據(jù)用戶的輸入判斷出指針指向的對象),它只能按照調(diào)用Parent類的函數(shù)來理解并編譯,所以我們看到了 第一行的結(jié)果。
那么第二行的結(jié)果又是怎么回事呢?我們注意到,F(xiàn)unction2()函數(shù)在基類中被virtual關(guān)鍵字修飾,也就是 說,它是一個虛函數(shù)。虛函數(shù)最關(guān)鍵的特點是“動態(tài)聯(lián)編”,它可以在運行時判斷指針指向的對象,并自動調(diào)用相應(yīng)的函數(shù)。如果我們在運行上面的程序時任意輸入 一個非c的字符,結(jié)果如下:
This is parent,function1
This is parent,function2
請注意看第二行,它的結(jié)果出現(xiàn)了變化。程序中僅僅調(diào)用了一個Function2()函數(shù),卻可以根據(jù)用戶的輸入自動決定到底調(diào)用基類中的Function2 還是繼承類中的Function2,這就是虛函數(shù)的作用。我們知道,在MFC中,很多類都是需要你繼承的,它們的成員函數(shù)很多都要重載,比如編寫MFC應(yīng) 用程序最常用的CView::OnDraw(CDC*)函數(shù),就必須重載使用。把它定義為虛函數(shù)(實際上,在MFC中OnDraw不僅是虛函數(shù),還是純虛 函數(shù)),可以保證時刻調(diào)用的是用戶自己編寫的OnDraw。虛函數(shù)的重要用途在這里可見一斑。
-----------------------------------------------------------
再看下面的
派生類的大小問題C++中虛函數(shù)和純虛函數(shù)的概念,差別和分別存在的原因
首先:強調(diào)一個概念
定義一個函數(shù)為虛函數(shù),不代表函數(shù)為不被實現(xiàn)的函數(shù),定義它為虛函數(shù)是為了允許用基類的指針來調(diào)用子類的這個函數(shù)
定義一個函數(shù)為純虛函數(shù),才代表函數(shù)沒有被實現(xiàn),定義他是為了實現(xiàn)一個接口,起到一個規(guī)范的作用,規(guī)范繼承這個類的程序員必須實現(xiàn)這個函數(shù)。
對繼承的影響:
普通的類(沒有虛函數(shù),純虛函數(shù))就可以被繼承,而且工作的相當(dāng)好
關(guān)于這個問題有以下疑問:
純虛函數(shù)難道就是為了實現(xiàn)接口?接口存在的意義?
我實在弄不懂,我干嘛要預(yù)先定義好?未來的事情本難料,就等有一天我的類中需要使用某個函數(shù),在添加一個函數(shù)不就可以?
關(guān)于實例化一個類:
有純虛函數(shù)的類是不可能生成類對象的,如果沒有純虛函數(shù)則可以。比如:
class CA
{
public:
virtual void fun() = 0; // 說明fun函數(shù)為純虛函數(shù)
virtual void fun1();
};
class CB
{
public:
virtual void fun();
virtual void fun1();
};
// CA,CB類的實現(xiàn)
...
void main()
{
CA a; // 不允許,因為類CA中有純虛函數(shù)
CB b; // 可以,因為類CB中沒有純虛函數(shù)
...
}
---------------------------------------------------------------
虛函數(shù)在多態(tài)中間的使用:
多態(tài)一般就是通過指向基類的指針來實現(xiàn)的。
dog mydogwangwang;
mydogwangwang.born();
一定是返回“dog”
那么
horse myhorsepipi;
myhorsepipi.born();
一定是返回“horse”
也是多態(tài)呀?
/////////////////////////////////////////////////
有一點你必須明白,就是用父類的指針在運行時刻來調(diào)用子類:
例如,有個函數(shù)是這樣的:
void animal::fun1(animal *maybedog_maybehorse)
{
maybedog_maybehorse->born();
}
參數(shù)maybedog_maybehorse在編譯時刻并不知道傳進來的是dog類還是horse類,所以就把它設(shè)定為animal類,具體到運行時決定了才決定用那個函數(shù)。
也就是說用父類指針通過虛函數(shù)來決定運行時刻到底是誰而指向誰的函數(shù)。
//用虛函數(shù)
#include <iostream.h>
class animal
{
public:
animal();
~animal();
void fun1(animal *maybedog_maybehorse);
virtual void born();
};
void animal::fun1(animal *maybedog_maybehorse)
{
maybedog_maybehorse->born();
}
animal::animal()
{
}
animal::~animal()
{
}
void animal::born()
{
cout<< "animal";
}
class dog: public animal
{
public:
dog();
~dog();
virtual void born();
};
dog::dog()
{
}
dog::~dog()
{
}
void dog::born()
{
cout<<"dog";
}
class horse:public animal
{
public:
horse();
~horse();
virtual void born();
};
horse::horse()
{
}
horse::~horse()
{
}
void horse::born()
{
cout<<"horse";
}
void main()
{
animal a;
dog b;
horse c;
a.fun1(&c);
}
//output: horse
//不用虛函數(shù)
#include <iostream.h>
class animal
{
public:
animal();
~animal();
void fun1(animal *maybedog_maybehorse);
void born();
};
void animal::fun1(animal *maybedog_maybehorse)
{
maybedog_maybehorse->born();
}
animal::animal()
{
}
animal::~animal()
{
}
void animal::born()
{
cout<< "animal";
}
class dog: public animal
{
public:
dog();
~dog();
void born();
};
dog::dog()
{
}
dog::~dog()
{
}
void dog::born()
{
cout<<"dog";
}
class horse:public animal
{
public:
horse();
~horse();
void born();
};
horse::horse()
{
}
horse::~horse()
{
}
void horse::born()
{
cout<<"horse";
}
void main()
{
animal a;
dog b;
horse c;
a.fun1(&c);
}
//output: animal
---------------------------------------------------------------
有純虛函數(shù)的類是抽象類,不能生成對象,只能派生。他派生的類的純虛函數(shù)沒有被改寫,那么,它的派生類還是個抽象類。
---------------------------------------------------------------
定義純虛函數(shù)就是為了讓基類不可實例化化,
因為實例化這樣的抽象數(shù)據(jù)結(jié)構(gòu)本身并沒有意義.
或者給出實現(xiàn)也沒有意義
實際上我個人認(rèn)為純虛函數(shù)的引入,是出于兩個目的:
1.為了安全.因為避免任何需要明確但是因為不小心而導(dǎo)致的未知的結(jié)果. 提醒子類去做應(yīng)做的實現(xiàn).
2.為了效率,不是程序執(zhí)行的效率,而是為了編碼的效率.
那么,什么是虛函數(shù)呢,我們先來看看微軟的解釋:
虛函數(shù)是指一個類中你希望重載的成員函數(shù),當(dāng)你用一個基類指針或引用指向一個繼承類對象的時候,你調(diào)用一個虛函數(shù),實際調(diào)用的是繼承類的版本。 這個定義說得不是很明白。MSDN中還給出了一個例子,但是它的例子也并不能很好的說明問題。我們自己編寫這樣一個例子:
復(fù)制代碼 代碼如下:
#include "stdio.h"
#include "conio.h"
class Parent
{
public:
char data[20];
void Function1();
virtual void Function2(); // 這里聲明Function2是虛函數(shù)
}parent;
void Parent::Function1()
{
printf("This is parent,function1\n");
}
void Parent::Function2()
{
printf("This is parent,function2\n");
}
class Child: public Parent
{
void Function1();
void Function2();
} child;
void Child::Function1()
{
printf("This is child,function1\n");
}
void Child::Function2()
{
printf("This is child,function2\n");
}
int main(int argc, char* argv[])
{
Parent *p; // 定義一個基類指針
if ( _getch()=='c' ) // 如果輸入一個小寫字母c
p=&child; // 指向繼承類對象
else
p=&parent; // 否則指向基類對象
p->Function1(); // 這里在編譯時會直接給出Parent::Function1()的 入口地址。
p->Function2(); // 注意這里,執(zhí)行的是哪一個Function2?
return 0;
}
用任意版本的Visual C++或Borland C++編譯并運行,輸入一個小寫字母c,得到下面的結(jié)果:
This is parent,function1
This is child,function2
為什么會有第一行的結(jié)果呢?因為我們是用一個Parent類的指針調(diào)用函數(shù)Fuction1(),雖然實際上這個指針指向的是Child類的對象,但編譯器 無法知道這一事實(直到運行的時候,程序才可以根據(jù)用戶的輸入判斷出指針指向的對象),它只能按照調(diào)用Parent類的函數(shù)來理解并編譯,所以我們看到了 第一行的結(jié)果。
那么第二行的結(jié)果又是怎么回事呢?我們注意到,F(xiàn)unction2()函數(shù)在基類中被virtual關(guān)鍵字修飾,也就是 說,它是一個虛函數(shù)。虛函數(shù)最關(guān)鍵的特點是“動態(tài)聯(lián)編”,它可以在運行時判斷指針指向的對象,并自動調(diào)用相應(yīng)的函數(shù)。如果我們在運行上面的程序時任意輸入 一個非c的字符,結(jié)果如下:
This is parent,function1
This is parent,function2
請注意看第二行,它的結(jié)果出現(xiàn)了變化。程序中僅僅調(diào)用了一個Function2()函數(shù),卻可以根據(jù)用戶的輸入自動決定到底調(diào)用基類中的Function2 還是繼承類中的Function2,這就是虛函數(shù)的作用。我們知道,在MFC中,很多類都是需要你繼承的,它們的成員函數(shù)很多都要重載,比如編寫MFC應(yīng) 用程序最常用的CView::OnDraw(CDC*)函數(shù),就必須重載使用。把它定義為虛函數(shù)(實際上,在MFC中OnDraw不僅是虛函數(shù),還是純虛 函數(shù)),可以保證時刻調(diào)用的是用戶自己編寫的OnDraw。虛函數(shù)的重要用途在這里可見一斑。
-----------------------------------------------------------
再看下面的
派生類的大小問題C++中虛函數(shù)和純虛函數(shù)的概念,差別和分別存在的原因
首先:強調(diào)一個概念
定義一個函數(shù)為虛函數(shù),不代表函數(shù)為不被實現(xiàn)的函數(shù),定義它為虛函數(shù)是為了允許用基類的指針來調(diào)用子類的這個函數(shù)
定義一個函數(shù)為純虛函數(shù),才代表函數(shù)沒有被實現(xiàn),定義他是為了實現(xiàn)一個接口,起到一個規(guī)范的作用,規(guī)范繼承這個類的程序員必須實現(xiàn)這個函數(shù)。
對繼承的影響:
普通的類(沒有虛函數(shù),純虛函數(shù))就可以被繼承,而且工作的相當(dāng)好
關(guān)于這個問題有以下疑問:
純虛函數(shù)難道就是為了實現(xiàn)接口?接口存在的意義?
我實在弄不懂,我干嘛要預(yù)先定義好?未來的事情本難料,就等有一天我的類中需要使用某個函數(shù),在添加一個函數(shù)不就可以?
關(guān)于實例化一個類:
有純虛函數(shù)的類是不可能生成類對象的,如果沒有純虛函數(shù)則可以。比如:
復(fù)制代碼 代碼如下:
class CA
{
public:
virtual void fun() = 0; // 說明fun函數(shù)為純虛函數(shù)
virtual void fun1();
};
class CB
{
public:
virtual void fun();
virtual void fun1();
};
// CA,CB類的實現(xiàn)
...
void main()
{
CA a; // 不允許,因為類CA中有純虛函數(shù)
CB b; // 可以,因為類CB中沒有純虛函數(shù)
...
}
---------------------------------------------------------------
虛函數(shù)在多態(tài)中間的使用:
多態(tài)一般就是通過指向基類的指針來實現(xiàn)的。
dog mydogwangwang;
mydogwangwang.born();
一定是返回“dog”
那么
horse myhorsepipi;
myhorsepipi.born();
一定是返回“horse”
也是多態(tài)呀?
/////////////////////////////////////////////////
有一點你必須明白,就是用父類的指針在運行時刻來調(diào)用子類:
例如,有個函數(shù)是這樣的:
復(fù)制代碼 代碼如下:
void animal::fun1(animal *maybedog_maybehorse)
{
maybedog_maybehorse->born();
}
參數(shù)maybedog_maybehorse在編譯時刻并不知道傳進來的是dog類還是horse類,所以就把它設(shè)定為animal類,具體到運行時決定了才決定用那個函數(shù)。
也就是說用父類指針通過虛函數(shù)來決定運行時刻到底是誰而指向誰的函數(shù)。
復(fù)制代碼 代碼如下:
//用虛函數(shù)
#include <iostream.h>
class animal
{
public:
animal();
~animal();
void fun1(animal *maybedog_maybehorse);
virtual void born();
};
void animal::fun1(animal *maybedog_maybehorse)
{
maybedog_maybehorse->born();
}
animal::animal()
{
}
animal::~animal()
{
}
void animal::born()
{
cout<< "animal";
}
class dog: public animal
{
public:
dog();
~dog();
virtual void born();
};
dog::dog()
{
}
dog::~dog()
{
}
void dog::born()
{
cout<<"dog";
}
class horse:public animal
{
public:
horse();
~horse();
virtual void born();
};
horse::horse()
{
}
horse::~horse()
{
}
void horse::born()
{
cout<<"horse";
}
void main()
{
animal a;
dog b;
horse c;
a.fun1(&c);
}
//output: horse
//不用虛函數(shù)
#include <iostream.h>
class animal
{
public:
animal();
~animal();
void fun1(animal *maybedog_maybehorse);
void born();
};
void animal::fun1(animal *maybedog_maybehorse)
{
maybedog_maybehorse->born();
}
animal::animal()
{
}
animal::~animal()
{
}
void animal::born()
{
cout<< "animal";
}
class dog: public animal
{
public:
dog();
~dog();
void born();
};
dog::dog()
{
}
dog::~dog()
{
}
void dog::born()
{
cout<<"dog";
}
class horse:public animal
{
public:
horse();
~horse();
void born();
};
horse::horse()
{
}
horse::~horse()
{
}
void horse::born()
{
cout<<"horse";
}
void main()
{
animal a;
dog b;
horse c;
a.fun1(&c);
}
//output: animal
---------------------------------------------------------------
有純虛函數(shù)的類是抽象類,不能生成對象,只能派生。他派生的類的純虛函數(shù)沒有被改寫,那么,它的派生類還是個抽象類。
---------------------------------------------------------------
定義純虛函數(shù)就是為了讓基類不可實例化化,
因為實例化這樣的抽象數(shù)據(jù)結(jié)構(gòu)本身并沒有意義.
或者給出實現(xiàn)也沒有意義
實際上我個人認(rèn)為純虛函數(shù)的引入,是出于兩個目的:
1.為了安全.因為避免任何需要明確但是因為不小心而導(dǎo)致的未知的結(jié)果. 提醒子類去做應(yīng)做的實現(xiàn).
2.為了效率,不是程序執(zhí)行的效率,而是為了編碼的效率.
相關(guān)文章
C語言中怎么在main函數(shù)開始前執(zhí)行函數(shù)
C語言中怎么在main函數(shù)開始前執(zhí)行函數(shù)呢?下面小編就大家詳細(xì)的介紹一下。需要的朋友可以過來參考下,希望對大家有所幫助2013-10-10