重载,重定义与隐藏

重载:在同一个类中,要求函数名相同,函数参数不同

重定义:在基类与派生类之间,派生类重新定义基类中的函数,且要求函数的名称、参数类型以及返回值类型完全一致。如果基类中的函数为virtual,则通过基类指针指向派生类时,可以实现多态。如果是非virtual,通过基类指针,不论指向的是基类还是派生类,所调用的都是基类的函数;通过派生类指针,调用的则是派生类的函数。(即实际调用的函数由指针的静态类型决定,即指针定义为什么类型,其静态类型就是什么类型)

隐藏:在基类和派生类之间,派生类定义了基类中的同名函数,但是参数可以不同。当参数不同的时候,对于派生类对象、指针、引用,其基类该同名函数都被隐藏了。(在virtual情况下,属于重定义)

class Base
{
public:
	void f()
	{cout<<"Base:f"<<endl;}
	void f(int a)
	{cout<<"Base:f(int)"<<endl;}
	virtual void g()
	{cout<<"Base:g()"<<endl;}
	virtual void h()
	{cout<<"Base:h()"<<endl;}

};
class Derived:public Base
{
public:
	void f(float)
	{cout<<"Derived:f(float)"<<endl;}
	void f(int)
	{cout<<"Derived:f(int)"<<endl;}
	void g(int)
	{cout<<"Derived:g(int)"<<endl;}
	void h()
	{cout<<"Derived:h()"<<endl;}
};
int main()
{
	Base *p1,*p2;
	Derived *d1;
	Base b;Derived d;
	p1=&b;
	p2=&d;
	d1=&d;
	p1->f(2);//指针的静态类型为Base,直接调用Base中的f(int)
	p2->f(2);//指针的静态类型为Base,直接调用Base中的f(int)
	p2->f(2.222);//将2.222转换为了int,指针的静态类型为Base,直接调用Base中的f(int)
	p2->g();//指针的静态类型为Base,直接调用Base中的g(),因为在Derived中并没有重新定义g(),所以虚函数表中,指向的函数Base中的g()
	p2->h();//指针的静态类型为Base,直接调用Base中的h(),但这时候虚函数表中的h()已经替换成了Derived中的h()
	//d1->f();//编译不通过,Derived中没有无参的f
	d1->f(2);//指针的静态类型为Derived,直接调用Derived中的f(int)
	//d1->g();//编译不通过,Derived中没有无参的g
	d1->g(2);//指针的静态类型为Derived,直接调用Derived中的g(int)
	return 0;
}

版权声明:本文为博主原创文章,未经博主允许不得转载。

时间: 2024-10-01 00:31:27

重载,重定义与隐藏的相关文章

重写,重定义,重载

> 重写,重定义经常与继承和虚继承一起使用,那么我们一步一步来,先看看重写,重定义到底是什么样子的呢? >重载: 1.它在同一个作用域中 2.函数名必须相同 3.参数个数,类型,顺序不同 4.返回值不作要求 5.virtual关键字不作要求 >重写(覆盖): 1.不在同一个作用域中(即基类与子类中) 2.函数名相同,返回值相同,参数也相同 3.只是在基类同名函数前必须有virtual关键字不能有static. 这时派生类的重写函数就会覆盖基类中的同名函数. >重定义(隐藏): 1.

【重载】【重写】【重定义】的区别和联系

测试重写/重载/重定义 class Base { public : void TestOver () { cout<<"Base::TestOver" <<endl; } }; class Derive : public Base { public : void TestOver () { cout<<"Derive::TestOver" <<endl; } }; void TestOver () { Derive d

c++三大概念要分清--重载,隐藏(重定义),覆盖(重写)

重载,隐藏(重定义),覆盖(重写)-这几个名词看着好像很像,不过其实一样都不一样!! 综述: 一.重载: (1)概念:在同一个作用域内:函数名相同,参数列表不同(参数个数不同,或者参数类型不同,或者参数个数和参数类型都不同),返回值类型可相同也可不同:这种情况叫做c++的重载! (2)举例: #include "stdafx.h" #include<iostream> using namespace std; int Add(int a, int b) { return a

重载重写重定义

1.重载:overload,是指同一可访问区内被声明的几个具有不同参数列表(参数的类型,个数,顺序不同)的同名函数,根据参数列表确定调用哪个函数,重载不关心函数返回类型. class Overload{ public: void V1(int i); void V1(double i); void V1(int i, double j); void V1(double i, int j); int test(int i); //编译报错,不是重载 }; 2.隐藏(重定义):隐藏是指派生类的函数屏

C++纯虚函数、虚函数、实函数、抽象类,重载、重写、重定义

首先,面向对象程序设计(object-oriented programming)的核心思想是数据抽象.继承.动态绑定.通过数据抽象,可以使类的接口与实现分离,使用继承,可以更容易地定义与其他类相似但不完全相同的新类,使用动态绑定,可以在一定程度上忽略相似类的区别,而以统一的方式使用它们的对象. 虚函数的作用是实现多态性(Polymorphism),多态性是将接口与实现进行分离,采用共同的方法,但因个体差异而采用不同的策略.纯虚函数则是一种特殊的虚函数.虚函数联系到多态,多态联系到继承. 一.虚函

(转)C++重写、重载和重定义的区别

C++ 重写重载重定义区别 (源自:http://blog.163.com/[email protected]/blog/static/111352259201102441934870/) 1 成员函数重载特征:   a 相同的范围(在同一个类中) b 函数名字相同 c 参数不同 d virtual关键字可有可无 2 重写(覆盖)是指派生类函数覆盖基类函数,特征是: a 不同的范围,分别位于基类和派生类中 b 函数的名字相同 c 参数相同 d 基类函数必须有virtual关键字 3 重定义(隐藏

C++的重载(overload)、重写(override)、重定义(redefine)

C++由于函数的名字相同,导致的几种不同的情况: 1,overload:重载: 重载是函数实现多态的一种方式,重载针对的是在同一个作用域(类)中,函数名相同的情况.如果,函数的特征标不同,即函数的参数个数或者类型不同,或者类型的顺序不同,那么,该函数就被重载了,能够根据不同的参数调用不同的函数. 2,override:重写: 重写涉及到继承的概念,即如果一个函数在基类中被指明是 virtual函数,那么,在其子类中,如果某个函数的名字,参数的特征标相同,那么子类就重写了基类的虚函数,能够根据对象

C++中重载、重写和重定义的区别

参考博客:http://blog.sina.com.cn/s/blog_8ddc5c2e01013hbd.html 相信看到这个标题头就晕了,其实将他们彼此放到一起来看,就会比较清晰辨认了. 重载:函数名相同,函数的参数个数.参数类型或参数顺序三者中必须至少有一种不同.函数返回值的类型可以相同,也可以不相同. 重写:也叫做覆盖,一般发生在子类和父类继承关系之间.子类重新定义父类中有相同名称和参数的虚函数. 重定义:也叫做隐藏,子类重新定义父类中有相同名称的非虚函数 ( 参数列表可以不同 ) ,指

C++重载,重写,重定义

1.重载:重载是在一个类中,函数名一样,参数类型或参数个数不同的一系列函数需要注意的是,与返回类型无关. class Test { public: void show(); void show(int a); void show(double a); void show(int a,int b); void show(int a,double b); }; 2.重写我们比较熟悉的另一个词是“覆盖”用在继承中,子类若没有重新定义父类的虚方法,则子类对象调用该方法时,使用的仍是父类的方法:否则,子类