C++覆盖、重载、多态区别 ； 重载、重写（覆盖）、重定义（隐藏）三者区别

覆盖：

在基类中定义了一个非虚拟函数，然后在派生类中又定义了一个同名同参数同返回类型的函数，这就是覆盖了。

在派生类对象上直接调用这个函数名，只会调用派生类中的那个。

//coverage.cpp

 

#include

using namespace std;

 

class A

{

public:

  void ShowMessage();

};

class B:public A

{

public:

  void ShowMessage();

};

 

void A::ShowMessage()

{

  cout<<"Hello,This is A./n";

  return;

}

void B::ShowMessage()

{

  cout<<"Hello,This is B./n";

  return;

}

 

int main()

{

  A* p;

  B memb;

  *p = memb;

  p->ShowMessage();

  memb.ShowMessage();

  return 0;

}

 

输出为：

Hello,This is A.

Hello,This is B.

重载：

有两个或多个函数名相同的函数，但是函数的形参列表不同。在调用相同函数名的函数时，根据形参列表确定到底该调用哪一个函数。

//reload

 

#include

using namespace std;

 

class A

{

public:

  void ShowMessage();

  void ShowMessage(string str);

};

 

void A::ShowMessage()

{

cout<<"Hi,This is A./n";

  return;

}

void A::ShowMessage(string str)

{

  cout<

  return;

}

 

int main()

{

  A mem;

  mem.ShowMessage();

  mem.ShowMessage("Hello.How are you?/n");

  return 0;

}

输出为：

Hi,This is A.

Hello.How are you?

多态：

在基类中定义了一个虚拟函数，然后在派生类中又定义一个同名，同参数表的函数，这就是多态。多态是这3种情况中唯一采用动态绑定技术的一种情况。也就是说，通过一个基类指针来操作对象，如果对象是基类对象，就会调用基类中的那个函数，如果对象实际是派生类对象，就会调用派声雷中的那个函数，调用哪个函数并不由函数的参数表决定，而是由函数的实际类型决定。

//poly.cpp

 

#include

using namespace std;

 

class A

{

public:

   virtual void ShowMessage();

};

class B:public A

{

public:

  void ShowMessage();

};

 

void A::ShowMessage()

{

  cout<<"This is A./n";

  return;

}

void B::ShowMessage()

{

  cout<<"This is B./n";

  return;

}

 

int main()

{

  A* p;

  p=new A();

  p->ShowMessage();

  p=new B();

  p->ShowMessage();

  return 0;

}

输出为：

This is A.

This is B.

----------------------------------------------------------------------------------------------------------------------------

1、重载

首先说重载,它最简单，C++中的重载和java中的差不多，都是在一个类中，方法名相同而参数不同的几个方法，但是不能靠返回类型来判断。例如：

class AA
{
public:
    void print()
    {
        cout << "父类" << endl;
    }
    void print(int x )
    {
        cout << "父类:" << x  << endl;
    }
};

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

上面的两个方法就属于重载。

2、重定义

重定义 (redefining)也叫做隐藏:

子类重新定义父类中有相同名称的非虚函数 ( 参数列表可以不同 ) 。

class AA
{
public:
    void print()
    {
        cout << "父类" << endl;
    }
};
class BB : public AA
{
public:
    void print(int x)//这叫重定义，此时A类中的print()被隐藏
    {
        cout << "子类:" << x  << endl;
    }
};

void main()
{
    int x = 1;
    BB b; //子类
    AA a; //父类
    a.print();//访问父类的print()
    b.print(x);//访问子类的print()
    b.AA::print();//访问父类的print()
    //b.print();error:函数参数太少
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29

这种情况下print()和print(int x)叫作重定义,在重定义时，父类的print()方法被隐藏了，要想使用父类的方法必须通过::。

3、重写（也叫覆盖）

函数特征相同。但是具体实现不同，主要是在继承关系中出现的 。当我们对别人提供好的类的方法感觉不是太满意时，我们就可以通过继承这个类然后重写其方法改成我们需要的逻辑。

1、最重要的一点，重写是子类与父类之间的。

2、被重写的函数不能是 static 的。

3、函数三要素（函数名、函数参数、函数返回类型）完全一样

4、如果父类中有virtual关键字，这种父子之间的关系叫做虚函数重写，这也就是C++中的多态机制，和java自动转换不同的是，C++需要我们手动设置。

例如：

class AA
{
public:
    virtual void print(int x )
    {
        cout << "父类:" << x  << endl;
    }
};

class BB : public AA
{
public:
    virtual void print(int x)
    {
        cout << "子类:" << x  << endl;
    }
};

int main()
{
    AA *p = NULL;
    BB b; 
    p = &b;
    p->print(1);
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26

这个输出结果取决于AA类中的void print(int x )函数前面是否加入virtual关键字，如果加了则调用子类的，否则父类。