virtual-0

C++中的virtual关键字是什么？怎么用？

1,在安装Psensor前，需要安装和配置lm-sensors，这是一个用于硬件监控的命令行工具。如果想要测量磁盘温度，还需要安装hddtemp。要安装这些工具，运行下面的这些命令:。

2,接着开始检测硬件传感器：

3,要确保已经工作，运行下面的命令：

4,它会给出下面这样的输出：

acpitz-virtual-0。

Adapter:Virtual device。

temp1:+43.0°C (crit =+98.0°C)。

coretemp-isa-0000。

Adapter: ISA adapter。

Physical id 0:+44.0°C (high =+100.0°C, crit =+100.0°C)。

Core0:+41.0°C (high =+100.0°C, crit =+100.0°C)。

Core1:+40.0°C (high =+100.0°C, crit =+100.0°C)。

5,如果一切看上去没问题，使用下面的命令安装Psensor：安装完成后，在Unity Dash中运行程序，就可以监控到cpu的温度了。

虚函数virtual的作用

virtual是定义C++中虚函数的关键字 。

1、virtual关键字的作用：

c++中的函数调用默认不适用动态绑定。要触发动态绑定，必须满足两个条件：第一，指定为虚函数；第二，通过基类类型的引用或指针调用。由此可见，virtual主要功能是实现动态绑定。

2、virtual关键字的使用情况：

virtual可用来定义类函数和应用到虚继承。

友元函数 构造函数 static静态函数 不能用virtual关键字修饰；

普通成员函数 和析构函数 可以用virtual关键字修饰。

3、virtual关键字的效果：

class GrandFather //祖父类。

{

public:

GrandFather() {}  //构造函数。

virtual void fun()  //虚函数声明定义。

{

cout << "GrandFather call function!" << endl; 。

}

};

class Father : public GrandFather//父类，公有继承祖父类。

{

public:

Father() {}  //构造函数。

void fun()   //fun函数声明定义。

{

cout << "Father call function!" << endl; 。

}

};

class Son : public Father  //子类，公有继承父类。

{

public:

Son() {}  //构造函数。

void fun()  //fun函数声明定义。

{

cout << "Son call function!" << endl; 。

}

};

void print(GrandFather* father) //输出函数 ，祖父类形参。

{

father->fun();  //调用fun函数。

}

int _tmain(int argc, _TCHAR* argv[]) 。

{

Father * pfather = new Son;//建立一个父类的指针让它指向子类。

pfather->fun(); 。

GrandFather * pgfather = new Father; 。

print(pgfather); //祖父类指针变量。

return 0;  }

4、virtual的继承性：

只要基函数定义了virtual，继承类的该函数也就具有virtual属性；即 GrandFather， Father ，Son同时定义virtual void fun()与GrandFather一个定义virtual void fun效果是一样的。

扩展资料

vitual关键字的用途：

1、vitual基类

在多重继承中，从派生类到基类存在多条路线时（多个继承脉络或者途径），一个这种派生类的对象实例化将包含多个基类对象，浪费资源且调用混乱的现象出现。

因此引入了vitual baseclass，来在运行阶段克服多个基类对象的产生。这个vitual是在运行阶段保证对象唯一性的。

2.vitual函数

虚函数的出现，是由于基类的指针可以执行派生类，因此引出了不便，引入vitual函数，来告诉编译器，出现这种情况时，在运行时动态链接进行处理。

3.vitual在纯虚函数中使用。

纯虚函数完全是为了继承体系的完整，也是集成vitual函数的作用而产生的。代表了编译器阶段对象的绑定，将调用选择转移到运行时动态绑定。

综上：vitual关键的引入，可以理解为阻止编译阶段的静态绑定，将绑定（虚函数）和约束工作（虚基类）转移到运行时动态处理。

参考资料：百度百科——virtual。

C++中virtual怎么用？

虚函数的作用是允许在派生类中重新定义与基类同名的函数，并且可以通过基类指针或引用来访问基类和派生类中的同名函数。

例：基类与派生类中有同名函数。

在下面的程序中Student是基类，Graduate是派生类，它们都有display这个同名的函数。

#include <iostream>。

#include <string>。

using namespace std;。

//声明基类Student

class Student

{public:

Student(int, string,float);//声明构造函数。

void display( ); //声明输出函数。

protected: //受保护成员，派生类可以访问。

int num;

string name;。

float score;。

};

//Student类成员函数的实现。

Student::Student(int n, string nam,float s) //定义构造函数。

{num=n;name=nam;score=s;}。

void Student::display( ) //定义输出函数。

{cout<<″num:″<<num<<″//nname:″<<name<<″//nscore:″<<score<<″//n//n″;}。

//声明公用派生类Graduate。

class Graduate:public Student。

{public:

Graduate(int, string, float, float); //声明构造函数。

void display( ); //声明输出函数。

private:

float pay;

};

// Graduate类成员函数的实现。

void Graduate::display( ) //定义输出函数。

{cout<<″num:″<<num<<″//nname:″<<name<<″//nscore:″<<score<<″//npay=″<<pay<<endl;}。

Graduate::Graduate(int n, string nam,float s,float p):Student(n,nam,s),pay(p){ }。

//主函数

int main()

{Student stud1(1001,″Li″,87.5); //定义Student类对象stud1。

Graduate grad1(2001,″Wang″,98.5,563.5); //定义Graduate类对象grad1。

Student *pt=&stud1; //定义指向基类对象的指针变量pt。

pt->display( );。

pt=&grad1;。

pt->display( );。

return 0;

}

运行结果如下，请仔细分析。

num:1001(stud1的数据)。

name:Li

score:87.5

num:2001 (grad1中基类部分的数据)。

name:wang

score:98.5

下面对程序作一点修改，在Student类中声明display函数时，在最左面加一个关键字virtual，即。

virtual void display( );。

这样就把Student类的display函数声明为虚函数。程序其他部分都不改动。再编译和运行程序，请注意分析运行结果:。

num:1001(stud1的数据)。

name:Li

score:87.5

num:2001 (grad1中基类部分的数据)。

name:wang

score:98.5

pay=1200 (这一项以前是没有的)。

由虚函数实现的动态多态性就是: 同一类族中不同类的对象，对同一函数调用作出不同的响应。虚函数的使用方法是:。

(1) 在基类用virtual声明成员函数为虚函数。这样就可以在派生类中重新定义此函数，为它赋予新的功能，并能方便地被调用。

在类外定义虚函数时，不必再加virtual。

(2) 在派生类中重新定义此函数，要求函数名、函数类型、函数参数个数和类型全部与基类的虚函数相同，并根据派生类的需要重新定义函数体。

C++规定，当一个成员函数被声明为虚函数后，其派生类中的同名函数都自动成为虚函数。因此在派生类重新声明该虚函数时，可以加virtual，也可以不加，但习惯上一般在每一层声明该函数时都加virtual，使程序更加清晰。

如果在派生类中没有对基类的虚函数重新定义，则派生类简单地继承其直接基类的虚函数。

(3) 定义一个指向基类对象的指针变量，并使它指向同一类族中需要调用该函数的对象。

(4) 通过该指针变量调用此虚函数，此时调用的就是指针变量指向的对象的同名函数。

通过虚函数与指向基类对象的指针变量的配合使用，就能方便地调用同一类族中不同类的同名函数，只要先用基类指针指向即可。如果指针不断地指向同一类族中不同类的对象，就能不断地调用这些对象中的同名函数。这就如同前面说的，不断地告诉出租车司机要去的目的地，然后司机把你送到你要去的地方。

需要说明；有时在基类中定义的非虚函数会在派生类中被重新定义，如果用基类指针调用该成员函数，则系统会调用对象中基类部分的成员函数；如果用派生类指针调用该成员函数，则系统会调用派生类对象中的成员函数，这并不是多态性行为(使用的是不同类型的指针),没有用到虚函数的功能。

以前介绍的函数重载处理的是同一层次上的同名函数问题，而虚函数处理的是不同派生层次上的同名函数问题，前者是横向重载，后者可以理解为纵向重载。但与重载不同的是: 同一类族的虚函数的首部是相同的，而函数重载时函数的首部是不同的(参数个数或类型不同)。

c++中virtual是是啥意思

C++中的虚函数和纯虚函数用法。

1.虚函数和纯虚函数可以定义在同一个类(class)中，含有纯虚函数的类被称为抽象类（abstract class），而只含有虚函数的类（class）不能被称为抽象类（abstract class）。

2.虚函数可以被直接使用，也可以被子类（sub class）重载以后以多态的形式调用，而纯虚函数必须在子类（sub class）中实现该函数才可以使用，因为纯虚函数在基类（base class）

只有声明而没有定义。

3.虚函数和纯虚函数都可以在子类（sub class）中被重载，以多态的形式被调用。

4.虚函数和纯虚函数通常存在于抽象基类（abstract base class -ABC）之中，被继承的子类重载，目的是提供一个统一的接口。

5.虚函数的定义形式：virtual {method body} ；纯虚函数的定义形式：virtual { } = 0; 在虚函数和纯虚函数的定义中不能有static标识符，原因很简单，被static修饰的函数在编译时候要求前期bind,然而虚函数却是动态绑定（run-time bind），而且被两者修饰的函数生命周期（life recycle）也不一样。

6.如果一个类中含有纯虚函数，那么任何试图对该类进行实例化的语句都将导致错误的产生，因为抽象基类（ABC）是不能被直接调用的。必须被子类继承重载以后，根据要求调用其子类的方法。

举个例子就明白了：

class A

{

virual fun()。

{cout<<"a"<<endl;}。

class B : public A。

virual fun() //在子类中改写。

{cout<<"B"<<endl;}。

class C: public A。

virual fun() //在子类中改写。

{cout<<"C"<<endl;}。

int main()

A * p ;

B mb;

C mc;

p=&mb;

p->fun();//输出B。

p=&mc;

p->fun();//输出C。

return 0;

同样是 p->fun();但结果不一样。

好吧，写着写着，感觉写多了。

通俗的说，就是基类做出来，让子类继承，并且可以在子类改写。

你可能会问，为何不直接在子类中写一个函数不是更快。

上面的例子就是一个很好的说明（临时写的，写的不怎么样），只用了一个指针就把两个函数都调用了。

再举个例子，就比如从 员工类 Y 中派生了 经理类 J，服务员类 F，保安类 B。这时候我用一个for循环就能把每个职位的某个信息比如工资输出来。而不用一个一个类的专门设计输出。

好吧，我承认还是没讲清楚。

原文地址：http://www.qianchusai.com/virtual-0.html