子类继承父类虚函数

//实现多态的三个条件

//1 要有继承

//2 要有虚函数重写

//3 用父类指针(父类引用)指向子类对象

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

成员函数被重载的特征是：

(1)具有相同的作用域(即同一个类定义中)；

(2)函数名字相同

(3)参数类型，顺序或数目不同(包括const参数和非const函数)

(4)virtual关键字可有可无。

覆盖是指派生类重新实现(或者改写即重写)了基类的成员函数，其特征是：

(1)不同的作用域(分别位于派生类和基类中)；（即虚函数的重写）

(2)函数名称相同

(3)参数列表完全相同；

(4)基类函数必须是虚函数。

（即我们可以得到，覆盖只是针对于虚函数）

隐藏是指派生类的成员函数遮蔽了与其同名的基类成员函数，具体规则如下：

(1) 派生类的函数与基类的函数同名，但是参数列表有所差异。此时，不论有无virtual关键字，基类的函数在派生类中将被隐藏。(注意别与重载混合)

(2)派生类的函数与基类的函数同名，参数列表也相同，但是基类函数没有virtual关键字。此时，基类的函数在派生类中将被吟唱。(注意别与覆盖混合)

1.虚函数(impure virtual)

C++的虚函数主要作用是“运行时多态”，即动态联编，父类中提供虚函数的实现，为子类提供默认的函数实现。

子类可以重写父类的虚函数实现子类的特殊化。

2.纯虚函数(pure virtual)

　C++中包含纯虚函数的类，被称为是“抽象类”。抽象类不能使用new出对象，只有实现了这个纯虚函数的子类才能new出对象。

　C++中的纯虚函数更像是“只提供申明，没有实现”，是对子类的约束，是“接口继承”。

　C++中的纯虚函数也是一种“运行时多态”，动态联编。

class A
{
public:
    virtual void out1(string s)=0;//纯虚函数
    virtual void out2(string s)//虚函数
    {
        cout<<"A(out2):"<<s<<endl;
    }
};

3.普通函数(no-virtual)

普通函数是静态编译的，没有运行时多态，只会根据指针或引用的“字面值”类对象，调用自己的普通函数。

普通函数是父类为子类提供的“强制实现”。

因此，在继承关系中，子类不应该重写父类的普通函数，因为函数的调用至于类对象的字面值有关。

===============================================================

#include <iostream>
using namespace std; 

class Base 
{ 
public: 
	virtual void f(float x){ cout << "Base::f(float) " << x << endl; } 
	void f(int x){ cout << "Base::f(int) " << x << endl; } //重载
	void g(float x){ cout << "Base::g(float) " << x << endl; } 
	void h(float x){ cout << "Base::h(float) " << x << endl; } 
}; 

class Derived : public Base 
{ 
public: 
	virtual void f(float x){ cout << "Derived::f(float) " << x << endl; } //重写
	void g(int x){ cout << "Derived::g(int) " << x << endl; } //隐藏
	void h(float x){ cout << "Derived::h(float) " << x << endl; } //隐藏
}; 

void main(void) 

{ 
	Derived d; 
	Base *pb = &d; 
	Derived *pd = &d; 
	// Good : behavior depends solely on type of the object 
	pb->f(3.14f); //运行结果: Derived::f(float) 3.14 
	pd->f(3.14f); //运行结果: Derived::f(float) 3.14 
	// Bad : behavior depends on type of the pointer 
	pb->g(3.14f); //运行结果: Base::g(float) 3.14 
	pd->g(3.14f); //运行结果: Derived::g(int) 3 
	// Bad : behavior depends on type of the pointer 
	pb->h(3.14f); //运行结果: Base::h(float) 3.14 
	pd->h(3.14f); //运行结果: Derived::h(float) 3.14 
}

===========================================

 #include <iostream>
using namespace std; 
class Base {
public:  
	virtual void f(int a) {  
		cout << "virtual Base::f(int a)" << endl;  
	}   
	void f(double d) {  //重载
		cout << "Base::f(double d)" << endl;  
	}
};  

class Derived : public Base {
public:   
	void f(double d) { //隐藏
		cout << "Derivd::f(double d)" << endl;  
	} 
}; 
int main() { 
	Derived d; 
	d.f(3); 
	d.f(2.5); 
	Derived *pd = new Derived();
	pd->f(3);  
	pd->f(2.5); 
	Base b; 
	b.f(5);  
	b.f(3.5);  
	Base *pBase = new Derived();
	pBase->f(5);
	pBase->f(3.5);
}

子类继承父类虚函数

猜你喜欢