c++第十天（隐藏与覆盖）（面试常问）

目录

一、隐藏的概念

二、覆盖

三、继承和组合

---

一、隐藏的概念

1.当子类 与 父类  含有同名函数时，子类就会把父类的函数接口给隐藏掉。  

2.被隐藏后的接口，可以使用 域操作符 :: 显示出来。

3.当子类 与 父类  含有同名函数时，同名函数无法 重载。  

class base 
{
public: 
    void show(int a){  //已经被隐藏了！ 
      cout <<   "show base" << a << endl;
}    
};

class  xbase : public base {
public: 
    void show(int a,int b){
      cout <<   "show xbase" << a <<":"<< b << endl;
}  
};
子类的优先级高

只要派生类中含有与基类的同名函数就会把基类的函数给隐藏了！ 

xbase(子类) tmp；

base (父类) &t = tmp；

//引用tmp; t . show()； //把隐藏的接口显示出来 。

4、子类函数与父类函数的名称相同，参数也相同，但是父类函数没有virtual，父类函数被隐藏 。

5、当子类 与 父类 含有同名函数时，同名函数无法重载。 

注：使用域操作符可以实现父子类函数重载。

#include<iostream>
using namespace std;

当一个类中有一个或多个虚拟函数，那么这个类在创建对象的时候就会创建一个虚表！
虚表就是一个存放虚函数"指针"的表格。
64位系统虚指针的大小也为8字节。
利用虚函数解决二义性。

//基类
class base{
public:
    base() {cout << "构造函数base\n";}

    virtual void show(){
        cout << "show() base" << endl;
    }
    void show_base(){
        cout << "我是base\n";
    }
};

//多级继承(派生类)
class base_a : public virtual base{
public:
    base_a() {cout << "构造函数base_a\n";}
    void show_base(){
        cout  << "我是base_a\n";
    }
};

//多级继承(派生类)
class base_b : public virtual base{
public:
    base_b() {cout << "构造函数base_b\n";}
};

//多继承(派生类的子类)
class base_c : public base_a, public base_b{
public:
    base_c() {cout << "构造函数base_c\n";}
};

int main()
{
    base_c c;
    c.show();   //子类和父类函数重名
    c.base::show_base();    用域操作符引出类的函数，解决二义性
    c.base_a::show_base();     用域操作符引出类的函数
    
}

二、覆盖

1、如果子类和父类有同样的函数，且父类是虚函数，那么子类会把父类的虚函数覆盖。

2、要求：函数名字与参数都相同， 父类的函数是虚函数（virtual）。

3、如果没有多级继承，那么父子函数同名优先使用子类函数。

#include<iostream>
using namespace std;

//基类
class base{
public:
    base() {cout << "构造函数base\n";}

    virtual void show(){    //父类的函数是虚函数，将被子类函数覆盖
        cout << "show() base" << endl;
    }
};

//多级继承(派生类)
class base_a : public virtual base{
public:
    base_a() {} 
};

//多级继承(派生类)
class base_b : public virtual base{
public:
    base_b() {}
};

//多继承(派生类的子类)
class base_c : public base_a, public base_b{
public:
    base_c() {}
    void show(){
        cout << "父类的虚函数已被我覆盖\n";
    }
};

int main()
{
    base_c c;
    c.show();
}

三、继承和组合

组合 ：一个类中包含另外一个类

继承 : 一个类是通过另外一个类派生出来的。

人类派生出，警官类，警官类中养了一条警犬。

#include<iostream>
#include<string.h>
using namespace std;

类的组合继承
拷贝构造函数：一个类通过另一个类初始化
引用另一个类去初始化的时候可以直接放入参数列表
总结：构造函数执行顺序: 基类构造  -> 组合类的构造  -> 派生类的构造
人类（基类）
class Person{
public:
    Person(const char *face){
        strcpy(this->face,face);
        cout << "1、人类的构造\n";
    }
    ~Person(){cout << "1.(1)人类的析构\n";}

private:
    char face[10];
};

//狗类（组合类）
class Dog{
public:
    Dog(){}
    Dog(const char *name,int age):age(age){
        strcpy(this->name,name);
        cout << "2、狗的构造\n";
    }
    Dog(Dog &tmp){  拷贝构造函数只是类外的类帮忙赋值的时候调用，可以自己写也可以系统默认。
        this->age = tmp.age;
        strcpy(this->name,tmp.name);
        cout << "2.(2)狗的拷贝构造\n";
    }
    ~Dog(){cout << "2.(3)狗的析构\n";} 

private:
    char name[10];
    int age;
};

//学生类（派生类）,养了一只狗
class Student : public Person{
public:
    Student(const char *name,int age,const char *face,Dog &d):age(age),Person(face),d(d){ 类外赋值
        strcpy(this->name,name);
        cout << "3、学生的构造\n";
    }
    ~Student(){cout << "3.(1)学生的析构\n";}
   
private:
    char name[10];
    int age;
    Dog d;
};

int main()
{
    Dog d("小黄",2);

    Student S("阿芳",23,"yellow",d);  类外(另一个类)帮忙赋值，调用拷贝构造函数
}

组合：其实就是在一个类的数据成员里面加入了另一个类作为成员数据。类的初始化在参数列表里面直接写：数据成员（传递的参数）。