从很多代码中,经常看到virtual的使用
如:
virtual ~StereoMatch(void);
学习virtual关键字:
浅析c++中virtual关键字
1.virtual关键字主要是什么作用?
- c++中的函数调用默认不适用动态绑定。要触发动态绑定,必须满足两个条件:第一,指定为虚函数;第二,通过基类类型的引用或指针调用。由此可见,virtual主要功能是实现动态绑定。
2.那些情况下可以使用virtual关键字?
- virtual可用来定义类函数和应用到虚继承。
- 友元函数 构造函数 static静态函数 不能用virtual关键字修饰;
- 普通成员函数 和析构函数 可以用virtual关键字修饰;
virtual ~StereoMatch(void);
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;
}
- 输出为 Son call function – Father call function
4.virtual的继承性
- 只要基函数定义了virtual,继承类的该函数也就具有virtual属性;即 GrandFather, Father ,Son同时定义virtual void fun()与GrandFather一个定义virtual void fun效果是一样的
5.虚析构函数
class GrandFather
{
public:
GrandFather() {}
virtual void fun()
{
cout << "GrandFather call function!" << endl;
}
~GrandFather() //析构函数
{
cout << "GrandFather destruction!" << endl;
}
};
class Father : public GrandFather
{
public:
Father() {}
void fun()
{
cout << "Father call function!" << endl;
}
~Father() //析构函数
{
cout << "Father destruction!" << endl;
}
};
class Son : public Father
{
public:
Son() {}
void fun()
{
cout << "Son call function!" << endl;
}
~Son() //析构函数
{
cout << "Son destruction!" << endl;
}
};
void print(GrandFather* p)
{
p->fun();
}
int _tmain(int argc, _TCHAR* argv[])
{
Father * pfather = new Son;
delete pfather;
return 0;
}
以上代码输出:Father destruction!
GrandFather destruction!
执行了Son的构造函数,没执行Son的析构函数,故把GrandFather的析构函数设置为virtual
则输出: Son destruction!
Father Destruction!
GrandFather destruction!故在基类调加virtural虚析构函数,所以的派生类的析构函数都执行;否则,派生类的析构函数不执行;
纯虚函数
纯虚函数定义如下:
class GrandFather //祖父类
{
public:
GrandFather() {} //构造函数
virtual void fun() = 0 //纯虚函数
{
cout << "GrandFather call function!" << endl;
}
virtual ~GrandFather() //虚析构函数
{
cout << "GrandFather destruction!" << endl;
}
};
- 纯虚函数为后代派生类提供可覆盖的接口,但这个类中的版本决不会调用。
- 含有(或继续)一个或多个纯虚函数的类是抽象基类,抽象基类不能实例化!
- 继承类只有重写这个接口才能被实例化
7.虚继承
虚继承主要解决交叉继承带来的问题。
C++虚继承:
class GrandFather //祖父类;
{
public:
GrandFather() {}//构造函数
void fun() //fun函数
{
cout << "GrandFather call function!" << endl;
}
virtual ~GrandFather() //虚析构函数
{
cout << "GrandFather destruction!" << endl;
}
};
class Father1 : public GrandFather //多继承,父类1
{
public:
Father1() {}
void fun()
{
cout << "Father call function!" << endl;
}
};
class Father2 : public GrandFather// 多继承,父类2
{
public:
Father2() {}
void fun()
{
cout << "Father call function!" << endl;
}
};
class Son : public Father1, public Father2
//子类多继承,父类1 ,父类2
{
public:
Son() {}
//void fun()
//{
// cout << "Son call function!" << endl;
//}
};
void print(GrandFather* p)
{
p->fun();
}
int _tmain(int argc, _TCHAR* argv[])
{
Son* son = new Son;
son->fun();
return 0;
}
编译时会提示报错,对fun的访问不明确如果Father1和Father2都用虚继承继承GrandFather类则可以解决这个问题。
8.构造函数和析构函数中的虚函数:
如果在构造函数或析构函数中调用虚函数,则运行的是为构造函数或析构函数自身类型定义的版本
class classA //classA类
{
public:
classA() //构造函数
{
clear(); //构造函数中调用clear函数
}
virtual ~classA() //classA虚析构函数
{
}
void clear() //clear函数定义
{
memset(this , 0 , sizeof(*this));
}
virtual void func() //虚函数func定义
{
printf("func\n");
}
};
class classB : public classA //派生类classB
{
};
int main(void)
{
classA oa; //classA类类型oa
classB ob; //classB类类型ob
classA * pa0 = &oa; //类类型指针变量
classA * pa1 = &ob;
classB * pb = &ob;
oa.func(); // 调用classA的func函数
ob.func(); // 调用classB的func函数,classB完全继承classA;执行classA的func函数
pa0->func(); // 3
pa1->func(); // 4
pb->func(); // 5
return 0;
}
补充一个例子,这个程序输出依次是
func
func
出错
func
func
谈谈我的理解,
- 当classA oa;oa.func();不存在动态调用的过程,所以func虽然是虚函数,但是函数调用不通过虚表访问,所以即使
memset(this , 0 , sizeof(*this));
找不到虚表地址也没有关系 - 在执行classB ob;的时候,注意memset的是classA的地址,所有ob的虚表是存在的;即是如下,通过指针或引用(动态绑定)访问oa的func函数(需要从虚表访问),会出错访问ob的func和函数,无论静态访问还是动态访问,都不会出错
- 当把classB的代码改成如下时:
class classB : public classA
<pre name="code" class="cpp" style="font-weight: bold;">{</pre><pre name="code" class="cpp" style="font-weight: bold;">
classB()
{
clear();
}
virtual ~classB()
{
}
void clear()
{
memset(this , 0 , sizeof(*this));
}</pre><br>
<pre></pre>
<pre name="code" class="cpp" style="font-weight: bold;">};</pre>输出为
func
func
出错
出错
出错