虚函数的作用主要是实现了多态的机制。简而言之就是用父类型的指针指向其子类的实例,然后通过父类的指针调用实际子类的成员函数。但仅仅可调用父类含有的函数,非父类函数不能调用。
普通虚函数调用
假设我们有下面的类层次:
#include <iostream>
using namespace std;
class A
{
public:
A(){};
~A(){}
virtual void foo()
{
cout << "A::foo() is called" << endl;
}
};
class B :public A
{
public:
B(){}
~B(){}
void foo()
{
cout << "B::foo() is called" << endl;
}
void fun()
{
cout << "B::fun() is called" << endl;
}
virtual void fun1()
{
cout << "B::fun() is called" << endl;
}
};
int main(void)
{
A *a = new B();
a->foo(); // 在这里,a虽然是指向A的指针,但是被调用的函数(foo)却是B的!
// a->fun(); // 这里调用错误,提示:error C2039: “fun”: 不是“A”的成员, e:\debug\base\test\main.cpp(8) : 参见“A”的声明
// a->fun1(); // 这里调用错误,提示:error C2039: “fun1”: 不是“A”的成员, e:\debug\base\test\main.cpp(8) : 参见“A”的声明
return 0;
}
以上例子说明,子类的虚函数替换了父类的同名虚函数(参见【C++学习笔记】虚函数实现多态原理)实现通过父类调用子类函数实现的功能。非父类含有的函数无法调用,可能因为父类中未包含子类中相关函数信息。
构造函数与析构函数调用
假设有如下类层次:
class A
{
public:
A(){ cout << "A::A() is called" << endl; };
~A(){ cout << "A::~A() is called" << endl; }
virtual void foo()
{
cout << "A::foo() is called" << endl;
}
};
class B :public A
{
public:
B(){ cout << "B::B() is called" << endl; }
~B(){ cout << "B::~B() is called" << endl; }
void foo()
{
cout << "B::foo() is called" << endl;
}
};
int main(void)
{
A *a = new B();
a->foo(); // 在这里,a虽然是指向A的指针,但是被调用的函数(foo)却是B的!
delete a;
return 0;
}
程序输出:
A::A() is called
B::B() is called
B::foo() is called
A::~A() is called
由程序输出可以看出,程序先构造父类,再构造子类,析构时未调用子类的析构函数。(这是否可以理解为:父类中未包含子类的信息,所以没有被调用)。若子类的构造函数存在动态内存分配,则会存在内存泄漏的问题。若父类析构函数为虚函数,则程序输出如下:
A::A() is called
B::B() is called
B::foo() is called
B::~B() is called
A::~A() is called
子类的动态内存分配就可以被释放。
虽然调用delete释放父类指针a,但是子类B的析构函数也被调用了。为何父类A析构函数为虚函数,释放父类指针可以调用子类析构函数,父类A析构函数不为虚函数,释放父类指针不调用子类析构函数?父类中也没有包含子类析构函数的信息呀!!!!!!!!!
父子类指针强制转换的安全性
假设有如使用:
class A
{
public:
A(){ cout << "A::A() is called" << endl; };
virtual~A(){ cout << "A::~A() is called" << endl; }
virtual void foo()
{
cout << "A::foo() is called" << endl;
}
};
class B :public A
{
public:
B()
{
cout << "B::B() is called" << endl;
}
virtual~B()
{
cout << "B::~B() is called" << endl;
delete [] pt;
}
void foo()
{
cout << "B::foo() is called" << endl;
}
void fun()
{
cout << "B::fun() is called" << endl;
}
};
int main(void)
{
A *a = new A();
B *b = static_cast<B*>(a); // 需显示强制转换
b->fun();
delete b;
return 0;
}
程序输出:
A::A() is called
B::fun() is called
A::~A() is called
父类指针强制转换为子类指针,并调用了子类函数,释放时释放的是父类A指针,并未释放B指针。父类指针a强制转换过程中并未调用子类B构造函数,释放时也未调用子类B析构函数。原父类动态分配的内存强制转换为子类,向下强制转换为子类存在较大风险,如下所示:
class A
{
public:
A(){ cout << "A::A() is called" << endl; };
virtual~A(){ cout << "A::~A() is called" << endl; }
virtual void foo()
{
cout << "A::foo() is called" << endl;
}
};
class B :public A
{
public:
B()
{
cout << "B::B() is called" << endl;
pt = new int[10];
for (int i = 0; i < 10; i++)
pt[i] = i;
}
virtual~B()
{
cout << "B::~B() is called" << endl;
delete [] pt;
}
void foo()
{
cout << "B::foo() is called" << endl;
}
void fun()
{
cout << "B::fun() is called" << endl;
cout << pt[0] << endl;
}
int *pt;
};
int main(void)
{
A *a = new A();
B *b = static_cast<B*>(a);// 需显示强制转换
b->fun();
delete a;
return 0;
}
程序输出异常,因为子类B调用的函数使用了需要在子类构造函数中动态分配的内存。因为强制转换过程中,未调用子类B的构造函数,pt内存没有进行动态分配。
int main(void)
{
A *a = new B();
B *b = static_cast<B*>(a);
b->fun();
delete a;
return 0;
}
程序输出:
A::A() is called
B::B() is called
B::fun() is called
0
B::~B() is called
A::~A() is called
父类指针强制转换为子类指针,并调用了子类函数(存在使用动态内存分配部分)。此情况说明:父类指针a指向子类指针,再将父类指针转换为子类B使用的安全的。