c ++继承

目录

继承的含义：（常规->具体）

 派生类：

重定义、重载与重写

重定义：（redefining）

重载：（overload）

重写：（override）

 派生类的对象具有多个类型

不继承的函数：

构造函数和析构函数

---

继承的含义：（常规->具体）

继承意味着可以先定义并编译常规形式的类，再定义这个类的更加具体的形式并继承这个类的所有属性，即一个基类创建派生类的过程，在这个过程中，我们可以根据需要添加更多的成员属性和成员函数。

 派生类：

class HourlyEmployee : public Employee
{

}

•  HourlyEmployee:派生类
• Employee：基类
• 继承关系：符号（：）

派生类的定义只列出新增的成员变量，基类定义的成员变量不必提及，它们会自动提供给派生类。

重定义、重载与重写

重定义：（redefining）

继承基类的成员函数的定义需要在派生类的定义中修改，使其在派生类中的定义有别于在基类中的定义。为了重定义成员函数，只需在类定义中列出它，并提供新的定义，类似于在派生中新增成员函数。

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

重载：（overload）

• 重载是函数名相同，参数列表不同
• 重载只是在类的内部存在。但是不能靠返回类型来判断。

重写：（override）

重写也叫做覆盖。子类重新定义父类中有相同名称和参数的虚函数。函数特征相同。但是具体实现不同，主要是在继承关系中出现的 。

重写需要注意：

1 被重写的函数不能是static的。必须是virtual的

2 重写函数必须有相同的类型，名称和参数列表

3 重写函数的访问修饰符可以不同。尽管virtual是private的，派生类中重写改写为public,protected也是可以的

#include <iostream>
using namespace std;

class A
{
public:
    A()
    {
        cout<<"this is A'contrutor."<<endl;
    }
    ~A()
    {
        cout<<"this is A'destrutor."<<endl;
    }
    //overload，两个f1函数在Base类的内部被重载
    void f1() { cout<<"A f1(null)"<<endl; }
    void f1(int a) { cout<<"A f1(int)"<<endl; }

    virtual void display() { cout<<"A display()"<<endl; } 
private:   
    void say(){ cout<<"A say()"<<endl; }
};
class B:public A
{
public:
    B():A()
    {
        cout<<"this is B'contrutor."<<endl;
    }
    ~B()
    {
        cout<<"this is B'destrutor."<<endl;
    }
    //重定义
    void f1(int a) { cout<<"B f1(int)"<<endl; }
    //重写
    void display() { cout<<"B display()"<<endl; }
};
int main()
{
    int a=1;
    A a1;
    cout<<"********"<<endl;
    B b1;

    a1.f1();
    a1.f1(a);

    b1.f1(a);

    a1.display();
    b1.display();
    return 0;
}

综上所述，总结如下：

•  成员函数重载特征：

相同的范围（在同一个类中）

函数名字相同

参数不同

virtual关键字可有可无

• 重写（覆盖)是指派生类函数覆盖基类函数，特征是

不同的范围，分别位于基类和派生类中

函数的名字相同

参数相同

基类函数必须有virtual关键字

• 重定义(隐藏)是指派生类的函数屏蔽了与其同名的基类函数，规则如下：

   a 如果派生类的函数和基类的函数同名，但是参数不同，此时，不管有无virtual，基类的函数被隐藏。

   b 如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有vitual关键字，此时，基类的函数被隐藏。

派生类的对象具有多个类型

• 在允许使用基类对象的任何地方，都能使用派生类的对象。

例如：

在函数中要求使用Employee类型的参数，就可以为该参数传递HourlyEmployee类型的值，另外，可以将HourlyEmployee类的对象赋给Employee类型的变量。

• 注意：不可以将Employee对象赋给HourlyEmployee类型的变量，毕竟Employee不一定是HourlyEmployee.

不继承的函数：

• 构造函数不继承
• 私有成员函数和成员变量不继承
• 析构函数不继承
• 拷贝构造函数不继承
• 赋值操作符不继承

构造函数和析构函数

• 基类的构造函数不被派生类继承，构造函数不能被继承是有道理的，因为即使继承了，它的名字和派生类的名字也不一样，不能成为派生类的构造函数，当然更不能成为普通的成员函数，但可在派生类构造函数的定义中调用基类的构造函数
• 析构函数也不能被继承。与构造函数不同的是，在派生类的析构函数中不用显式地调用基类的析构函数，因为每个类只有一个析构函数，编译器知道如何选择，无需程序员干涉。

#include <iostream>
using namespace std;

class A
{
public:
    A()
    {
        cout<<"this is a'contrutor."<<endl;
    }
    ~A()
    {
        cout<<"this is a'destrutor."<<endl;
    }
};
class B:public A
{
public:
    B():A()
    {
        cout<<"this is b'contrutor."<<endl;
    }
    ~B()
    {
        cout<<"this is B'destrutor."<<endl;
    }
};
int main()
{
    A a1;
    cout<<"********"<<endl;
    B b1;
    return 0;
}

• 执行顺序：析构函数的执行顺序和构造函数的执行顺序相反

创建派生类对象时，构造函数的执行顺序和继承顺序相同，即先执行基类构造函数，再执行派生类构造函数。

而销毁派生类对象时，析构函数的执行顺序和继承顺序相反，即先执行派生类析构函数，再执行基类析构函数。

私有成员函数和成员变量

• 假如类的私有成员变量可在派生类的成员函数定义中访问，这违背了其保密性，因此，除了通过基类的接口函数进行访问，否则不能直接访问基类的成员函数和成员变量
• 私有成员函数只应作为辅助函数使用，所以只应在定义他们的类中使用。

赋值操作符和拷贝构造函数

• 重载的赋值操作符和拷贝构造函数不会被继承，然而，他们可以在派生的重载赋值操作符以及拷贝构造函数的定义中使用。
• 重载赋值操作符必须定义为类的成员函数。
• 为什么赋值运算符重载函数不能被继承呢？

     因为相较于基类，派生类往往要添加一些自己的数据成员和成员函数，如果允许派生类继承基类的赋值运算符重载函数，那么，在派生类不提供自己的赋值运算符重载函数时，就只能调用基类的，但基类版本只能处理基类的数据成员，在这种情况下，派生类自己的数据成员怎么办？

参考：

https://blog.csdn.net/u010177010/article/details/51014207

https://www.cnblogs.com/zpcdbky/p/5027481.html

protected限定符

在类的成员变量或成员函数之前，如果添加了限定符protected,那么除了派生类之外的其他任何类或函数，它的作用等同于private,但在派生类中，可以通过名称直接访问这些成员变量