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

转自:http://blog.csdn.net/gogogo_sky/article/details/72860426



重载,隐藏(重定义),覆盖(重写)—这几个名词看着好像很像,不过其实一样都不一样!!

综述:

这里写图片描述

一、重载:

(1)
概念:在同一个作用域内;函数名相同,参数列表不同(参数个数不同,或者参数类型不同,或者参数个数和参数类型都不同),返回值类型可相同也可不同;这种情况叫做c++的重载!

注意:c语言没有函数重载的机制;

详见:http://blog.csdn.net/gogogo_sky/article/details/72807123

(2)举例:

#include

using namespace std;
int Add(int a,int b)
{
    return a+b;
}
float Add(float a,float b)
{
    return a+b;
}
int main()
{
    cout<4,5)<//调用 int Add(int a,int b)
    cout<2.5f,3.7f)<//调用 float Add(float a,float b)
    return 0;
}
 
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

此时,两个函数Add();在同一作用域,函数名相同都是Add,参数类型不同;就构成了c++中的函数重载;

(3)c++函数重载达到的效果:调用函数名相同的函数,会根据实参的类型和实参顺序以及实参个数选择相应的函数;
(4)c++函数重载是一种静态多态(又叫做静态联编,静态绑定,静态决议)

二、覆盖(又叫重写)

(1)说覆盖之前先说一个概念:
虚函数:类的成员函数前面加virtual关键字,则这个成员函数称为虚函数

(2)覆盖(重写)的前提条件:父类函数为虚函数;

(3)覆盖(重写)的概念:当在子类中定义了一个与父类完全相同的虚函数时,则称子类的这个函数重写(也称覆盖)了父类的这个虚函数。

(4)什么是在子类中定义了一个与父类完全相同的虚函数:
有两种情况:

  • 1.就是说子类中的虚函数和父类中的虚函数,函数名,参数个数,参数类型,返回值类型都相同;这种情况下子类的这个虚函数重写的父类中的虚函数,构成了重写;

  • 2、协变—是说子类中的虚函数和父类中的虚函数,函数名,参数个数,参数类型都相同,只是返回值类型不同;父类的虚函数返回父类的指针或者引用,子类虚函数返回子类的指针或者引用;这种情况下子类的这个虚函数也重写了父类中的虚函数,也构成了重写;——我们把这种特殊的情况叫做协变

注意:

在子类中定义了一个与父类虚函数完全相同的函数,那么这个子类的函数就是重写了父类的虚函数,此时这个子类的函数就是虚函数,如果不显示的加上virtual修饰,编译器也会默认为虚函数;

(5)覆盖(重写)达到的效果:

  • 1.在子类中重写了父类的虚函数,那么子类对象调用该重写函数,调用到的是子类内部重写的虚函数,而并不是从父类继承下来的虚函数;(这其实就是动态多态的实现);

  • 2.在子类中重写了父类的虚函数,如果用一个父类的指针(或引用)指向(或引用)子类对象,那么这个父类的指针或用引用调用该重写的虚函数,调用的是子类的虚函数;相反,如果用一个父类的指针(或引用)指向(或引用)父类的对象,那么这个父类的指针或用引用调用该重写的虚函数,调用的是父类的虚函数

(6)举例1:普通重写+函数重载

//普通重写+函数重载
#include
using namespace std;
class Person//父类
{
public:
    virtual void BuyTickets()//父类虚函数
    {
        cout<<" 买票-全票"<< endl;
    }
protected :
    string  _name; // 姓名
};

class Student : public Person//子类
{
public:
     void BuyTickets()//子类虚函数
    {
        cout<<" 买票-半价"<protected :
    int _num ; //学号
};
void Fun (Person* p)
{
   p->BuyTickets();
}
void Fun (Person&p)
{
    p.BuyTickets();
}
void Test ()
{
    Person p ;
    Student s;
    Fun(p);
    Fun(s);

    Fun(&p);
    Fun(&s);
}

int main()
{
    Test();
    return 0;
}

 
 
   
   
   
   
  • 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
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49

这里写图片描述

分析:

在子类中的函数 void BuyTickets()和父类的虚函数virtual void BuyTickets(),他们的函数名相同都为BuyTickets,参数相同都为空,返回值都相同为void,所以此时子类中的函数void BuyTickets()重写了父类的虚函数virtual void BuyTickets();那么这是即使子类的函数void BuyTickets()不加关键字virtual修饰,编译器默认它为虚函数;
父类的指针Person* p(或引用Person&p)指向(或引用)子类对象s,那么这个父类的指针或用引用调用该重写的虚函数,调用的是子类的虚函数;
相反,用一个父类的指针Person* p(或引用Person&p)指向(或引用)父类的对象p,那么这个父类的指针或用引用调用该重写的虚函数,调用的是父类的虚函数

其中:

void Fun (Person* p)
{
   p->BuyTickets();
}
void Fun (Person&p)
{
    p.BuyTickets();
}
 
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

这两个哈数构成了函数重载

举例二:协变重写+函数重载

//(协变)重写+函数重载

#include
using namespace std;
class Person//父类
{
public:
    virtual  Person& BuyTickets()//父类虚函数
    {
        cout<<"成人买票-全票"<return *this;
    }
public:
  string  _name; // 姓名
};

class Student : public Person//子类
{
public:
    virtual Student& BuyTickets()//子类虚函数
    {
        cout<<"学生买票-半票"<return *this;
    }
public:
    int _num ; //学号
};
void Fun (Person* p)
{
     p->BuyTickets();
}
void Fun (Person&p)
{
     p.BuyTickets();
}   
void Test ()
{
    Person p;
    Student s;
    Fun(p);
    Fun(s);

    Fun(&p);
    Fun(&s);
}
int main()
{
    Test();
    return 0;
}
 
 
   
   
   
   
  • 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
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50

这里写图片描述

三、隐藏(重定义)

(1)隐藏(重定义)概念:

是指在不同的作用域中(分别在父类和子类中),函数名相同,不能构成重写的都是重定义。

(2)隐藏(重定义)的使用范围:

重定义的不光是类的成员函数,还可以是类的成员变量

(3)隐藏(重定义)的直接效果:

如果在父类和子类中有相同名字的成员;那么在子类中。会将父类的成员隐藏;隐藏以后的直接效果就是:无论在子类的内部或者外部(通过子类成员)访问该成员;全都是访问子类的同名成员; 如果在子类内部或者外部(通过子类成员)访问同名的成员函数,则需要根据函数调用的规则来调用子类的同名成员函数;否则调用失败;

#include
using namespace std;

class A
{
protected:
    A(int x=2)
        :_a(x)
    {}
//public:
//  //1
//     void show()
//  {
//      cout<<"A::shou()"<
//  }

//public:
//  //2
//  virtual void show()
//  {
//      cout<<"A::shou()"<
//  }
public:
    //3
    void show(int a)
    {
        cout<<"A::shou()"<public:
    int _a;
};
class B:public A
{
public:
    B(int x=1)
        :_a(x)
    {}
//public:
//  //1
//  void show(int b)
//  {
//      cout<<"B::shou()"<
//  }
//public:
//  //2
//  void show(int a)
//  {
//      cout<<"B::shou()"<
//  }
public:
    //3
    void show(int a,int b)
    {
        cout<<"B::shou()"<public:
    int _a;
};

int main()
{
    B b;
    cout<<(b._a)<1);
    return 0;
}
 
 
   
   
   
   
  • 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
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67

程序中所标明的1,2,3三种情况都是成员隐藏!

你可能感兴趣的:(C++)