蓓蓓-
virtual是定义C++中虚函数的关键字 。
在使用virtual之前，C++对成员函数使用静态联编，而使用virtual，并且在调用函数时是通过指针或引用调用，C++则对成员函数进行动态联编。
一、概念
1、以继承为前提。
2、在父类中用virtual修饰函数。
3、在子类中重写该虚函数。
二、作用
1、以父类的引用作为函数的参数类型。
2、调用该函数传递子类对象。
3、在函数中可以通过该父类的引用调用到子类中重写的虚函数。
三、用法
class 类名{
public:
virtual 成员函数说明；
}
class 类名：基类名{
public:
virtual 成员函数说明；
}扩展资料
定义虚函数的限制：
（1）非类的成员函数不能定义为虚函数，类的成员函数中静态成员函数和构造函数也不能定义为虚函数，但可以将析构函数定义为虚函数。实际上，优秀的程序员常常把基类的析构函数定义为虚函数。
因为，将基类的析构函数定义为虚函数后，当利用delete删除一个指向派生类定义的对象指针时，系统会调用相应的类的析构函数。而不将析构函数定义为虚函数时，只调用基类的析构函数。
（2）只需要在声明函数的类体中使用关键字“virtual”将函数声明为虚函数，而定义函数时不需要使用关键字“virtual”。
（3）当将基类中的某一成员函数声明为虚函数后，派生类中的同名函数（函数名相同、参数列表完全一致、返回值类型相关）自动成为虚函数。
（4）如果声明了某个成员函数为虚函数，则在该类中不能出现和这个成员函数同名并且返回值、参数个数、类型都相同的非虚函数。在以该类为基类的派生类中，也不能出现和这个成员函数同名并且返回值、参数个数、类型都相同的非虚函数。
参考资料来源：百度百科—virtual
wpBeta-
C++中的virtual关键字是定义C++中虚函数的关键字 。
在使用virtual之前，C++对成员函数使用静态联编，而使用virtual，并且在调用函数时是通过指针或引用调用，C++则对成员函数进行动态联编。
virtual的作用：
（1）以父类的引用作为函数的参数类型。
（2）调用该函数传递子类对象。
（3）在函数中可以通过该父类的引用调用到子类中重写的虚函数。
扩展资料
C++语言工作原理
C++语言的程序因为要体现高性能，所以都是编译型的。但其开发环境，为了方便测试，将调试环境做成解释型的。即开发过程中，以解释型的逐条语句执行方式来进行调试，以编译型的脱离开发环境而启动运行的方式来生成程序最终的执行代码。
生成程序是指将源码（C++语句）转换成一个可以运行的应用程序的过程。如果程序的编写是正确的，那么通常只需按一个功能键，即可搞定这个过程。该过程实际上分成两个步骤。
第一步是对程序进行编译，这需要用到编译器（compiler）。编译器将C++语句转换成机器码(也称为目标码)；如果这个步骤成功，下一步就是对程序进行链接，这需要用到链接器（linker）。
链接器将编译获得机器码与C++库中的代码进行合并。C++库包含了执行某些常见任务的函数（“函数”是子程序的另一种称呼）。
例如，一个C++库中包含标准的平方根函数sqrt，所以不必亲自计算平方根。C++库中还包含一些子程序，它们把数据发送到显示器，并知道如何读写硬盘上的数据文件。
参考资料：百度百科——virtual
黑桃云-
是定义C++中虚函数的关键字。
演示使用的代码：
class Base
{
public:Base() {}
public:
virtual void print() { cout << "Base"; }
};
class Derived :public Base
{
public:Derived() {}
public:
void print() { cout << "Derived"; }
};
void main() {
Base *point = new Derived();
point->print();
getchar();
}
代码截图：
扩展资料：
虚函数的定义
简单地说，那些被virtual关键字修饰的成员函数，就是虚函数。
虚函数的作用，用专业术语来解释就是实现多态性（Polymorphism），多态性是将接口与实现进行分离；用形象的语言来解释就是实现以共同的方法，但因个体差异，而采用不同的策略。
即：指向基类的指针在操作它的多态类对象时，会根据不同的类对象，调用其相应的函数，这个函数就是虚函数。
参考资料：百度百科-虚函数
参考资料：百度百科-virtual
可乐-
virtual意为虚拟，在C++中用到关键字virtual的一共有两个部分一个是虚继承,一个是虚函数。
c++中的函数调用默认不适用动态绑定。要触发动态绑定，必须满足两个条件：第一，指定为虚函数；第二，通过基类类型的引用或指针调用。
下面这些情况可用virtual关键字：
友元函数 构造函数 static静态函数 不能用virtual关键字修饰；
普通成员函数 和析构函数 可以用virtual关键字修饰；
扩展资料：
vitual关键字用途：
vitual基类
在多重继承中，从派生类到基类存在多条路线时（多个继承脉络或者途径），一个这种派生类的对象实例化将包含多个基类对象，浪费资源且调用混乱的现象出现。
因此引入了vitual baseclass，来在运行阶段克服多个基类对象的产生。这个vitual是在运行阶段保证对象唯一性的。
vitual函数
虚函数的出现，是由于基类的指针可以执行派生类，因此引出了不便，如
class deriv：public class base
{
public：
void show（）；
}
当
deriv d；
base* b；
b=&d；
b->show();
这里的show应该调用谁的呢？我们的意思肯定是调用d的，但是编译器处理的话b和base类是绑定在一起的，他实际上是会调用b的show函数。
因此，我们引入vitual函数，来告诉编译器，出现这种情况时，在运行时动态链接进行处理。
3.vitual在纯虚函数中使用
纯虚函数完全是为了继承体系的完整，也是集成vitual函数的作用而产生的。代表了编译器阶段对象的绑定，将调用选择转移到运行时动态绑定。
综上：vitual关键的引入，可以理解为阻止编译阶段的静态绑定，将绑定（虚函数）和约束工作（虚基类）转移到运行时动态处理。
参考资料来源：百度百科-虚拟函数
S笔记-
c++规定，当一个成员函数被声明为虚函数后，其派生类中的同名函数都自动成为虚函数。因此，在子类重新声明该虚函数时，可以加，也可以不加，但习惯上每一层声明函数时都加virtual,使程序更加清晰。
cloudcone-
virtual 是实现多态的关键
康康map-
* 回复内容中包含的链接未经审核，可能存在风险，暂不予完整展示！http://blog.c**.net/djh512/article/details/8973606
大鱼炖火锅-
GOOD~
瑞瑞爱吃桃-
C++中的虚函数
虽然很难找到一本不讨论多态性的C++书籍或杂志，但是，大多数这类讨论使多态性和C++虚函数的使用看起来很难。我打算在这篇文章中通过从几个方面和结合一些例子使读者理解在C++中的虚函数实现技术。说明一点，写这篇文章只是想和大家交流学习经验因为本人学识浅薄，难免有一些错误和不足，希望大家批评和指正，在此深表感谢！
一、 基本概念
首先，C++通过虚函数实现多态."无论发送消息的对象属于什么类，它们均发送具有同一形式的消息，对消息的处理方式可能随接手消息的对象而变"的处理方式被称为多态性。"在某个基类上建立起来的类的层次构造中，可以对任何一个派生类的对象中的同名过程进行调用，而被调用的过程提供的处理可以随其所属的类而变。"虚函数首先是一种成员函数，它可以在该类的派生类中被重新定义并被赋予另外一种处理功能。
二、 虚函数的定义与派生类中的重定义
class 类名{
public:
virtual 成员函数说明；
}
class 类名：基类名{
public:
virtual 成员函数说明；
}
三、 虚函数在内存中的结构
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;
}