C++继承

C++继承

面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。也达到了重用代码功能和提高执行时间的效果。

当创建一个类时，不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。

继承代表了is a 关系。例如，哺乳动物是动物，狗是哺乳动物，因此，狗是动物，等。

基类 & 派生类

一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名。

形式：

class derived-class: access-specifier base-class

其中，访问修饰符 access-specifier 是 public、protected 或 private 其中的一个，base-class 是之前定义过的某个类的名称。如果未使用访问修饰符 access-specifier，则默认为 private。

访问控制和继承

派生类可以访问基类中所有的非私有成员。因此基类成员如果不想被派生类的成员函数访问，则应在基类中声明为 private。

根据访问权限总结出不同的访问类型，如下所示：

类型	public	protected	private
同一个类	可以	可以	可以
派生类	可以	可以	不可以
其他类	可以	不可以	不可以

一个派生类继承了所有的基类方法，但下列情况除外：

• 基类的构造函数、析构函数和拷贝构造函数。
• 基类的重载运算符。
• 基类的友元函数。

继承类型

当一个类派生自基类，该基类可以被继承为 public、protected 或 private 几种类型。继承类型是通过上面讲解的访问修饰符 access-specifier 来指定的。

一般不使用 protected 或 private 继承，通常使用 public 继承。当使用不同类型的继承时，遵循以下几个规则：

• 公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。
• 保护继承（protected）： 当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。
• 私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。

多继承

多继承即一个子类可以有多个父类，它继承了多个父类的特性。

C++ 类可以从多个类继承成员，语法如下：

class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
{
<派生类类体>
};

其中，访问修饰符继承方式是 public、protected 或 private 其中的一个，用来修饰每个基类，各个基类之间用逗号分隔。

例子：

#include <iostream>
 
using namespace std;
 
// 基类 Shape
class Shape 
{
   public:
      void setWidth(int w)
      {
         width = w;
      }
      void setHeight(int h)
      {
         height = h;
      }
   protected:
      int width;
      int height;
};
 
// 基类 PaintCost
class PaintCost 
{
   public:
      int getCost(int area)
      {
         return area * 70;
      }
};
 
// 派生类
class Rectangle: public Shape, public PaintCost
{
   public:
      int getArea()
      { 
         return (width * height); 
      }
};
 
int main(void)
{
   Rectangle Rect;
   int area;
 
   Rect.setWidth(5);
   Rect.setHeight(7);
 
   area = Rect.getArea();
   
   // 输出对象的面积
   cout << "Total area: " << Rect.getArea() << endl;
 
   // 输出总花费
   cout << "Total paint cost: $" << Rect.getCost(area) << endl;
 
   return 0;
}

虚继承

为什么需要虚继承

菱形继承是多重继承中跑不掉的，Java拿掉了多重继承，辅之以接口。C++中虽然没有明确说明接口这种东西，但是只有纯虚函数的类可以看作Java中的接口。在多重继承中建议使用“接口”，来避免多重继承中可能出现的各种问题。

虚继承概念

虚继承是一种机制，类通过虚继承指出它希望共享虚基类的状态。对给定的虚基类，无论该类在派生层次中作为虚基类出现多少次，只继承一个共享的基类子对象，共享基类子对象称为虚基类。虚基类用virtual声明继承关系就行。

#include <iostream>

using namespace std;
//基类

class D
{
public:
    D(){cout<<"D()"<<endl;}
    ~D(){cout<<"~D()"<<endl;}
protected:
    int d;
};

class B:virtual public D
{
public:
    B(){cout<<"B()"<<endl;}
    ~B(){cout<<"~B()"<<endl;}
protected:
    int b;
};

class A:virtual public D
{
public:
    A(){cout<<"A()"<<endl;}
    ~A(){cout<<"~A()"<<endl;}
protected:
    int a;
};

class C:public B, public A
{
public:
    C(){cout<<"C()"<<endl;}
    ~C(){cout<<"~C()"<<endl;}
protected:
    int c;
};
int main()
{
    cout << "Hello World!" << endl;
    C c;   //D, B, A ,C
    cout<<sizeof(c)<<endl;
    return 0;
}

继承

这个机制是面向对象使代码复用的重要手段，在原有类的基础上进行扩展，增加功能；

继承的出现，应该主要是为了多态性；继承实质是是为了多态做准备。

访问属性

1. 有public、protected、private继承，不写的话，默认私有继承；
   class d : public B1，B2，B3，在这块，B1是公有继承，B2和B3是默认的，私有继承；

2. class Base{}；sizeof(Base); 空类，计算结果 1 字节；起标识作用

3. 不管什么继承，子类均不会继承父类的构造方法和析构方法，其余的拷贝一份(包括私有，公有，保护)放到子类，只不过更改相应的修饰符权限。

4. 不论什么继承，子类都不能直接访问父类的私有数据。

5. 从对象和子类内看访问属性：

   • 对象角度：永远只能访问公有方法；
   • 子类内角度：子类永不可能直接访问父类的私有-------->安全性；
   • 子类在公有继承(public)中，父类的(除去私有的)都可以访问;其继承下来的修饰符权限不用改；
   • 子类在保护继承(protected)中，除去父类的私有，都可以访问；
   • 子类在私有继承(private)中，；继承下来的属性都变为私有，原因：成员函数可以访问自己的私有数据；

6. protected----->只在继承中体现，其它的地方用不到这个；

   • protected/private————>不同之处：影响下一层此的继承；private会阻断继承；

构造函数的调用顺序

1. 当在继承时创建一个对象，其内部隐藏了先调用其父类的构造函数，先创建了父类的对象，其后创建子类对象；析构函数的调用与此相反;

2. 按继承顺序，成员对象创建顺序，调用父类的构造函数，创建父类对象，最后创建自己对象；与参数列表的顺序无关；

3. 看看有没有虚继承(virtual public B1)；有的话，先调用虚继承的构造函数，在调用普通父类的构造函数，最后调用自己的，一切按顺序来；

砖石继承

继承下来时有2个n，在调用时候会产生二义性；其采用虚继承可以解决：

#include<iostream>
using namespace std;
 
class Base{
public:
    int n;
};
 
class D1 : virtual public Base{//加上virtual，表示虚继承
public:     //public virtual Base和上面等同
    int x;
};
 
class D2 : virtual public Base{  //加上virtual，表示虚继承
public:
    int y;
};
 
class S : public D1, public D2{  //此时就只有一个n了;
public:
    int z;
};
 
int main(){
    S c;
    c.n = 10;
 
    cout<<&c.D1::n<<endl;  //因为同一个n,所以地址相同；
    cout<<&c.D2::n<<endl;
    return 0;
}

虚继承可以解决这类问题，就只有一个n被继承下来，就可以正确访问n了;

同名隐藏与赋值兼容规则

5.1、同名隐藏

#include<iostream>
using namespace std;
  
class Base
{
public:
    void fun()  //父类的无参fun()方法
    {
        cout<<"This is Base fun()"<<endl;
    }
    void fun(int a) //父类的一个参数的fun()方法
    {
        cout<<"This is Base fun(int)"<<endl;
    }
};
  
class D : public Base
{
public:
    void fun()   //子类的fun()方法
    {
        cout<<"This is D fun()"<<endl;
    }
};
  
int main()
{
    D d;
    d.fun();   //肯定调用子类的fun()方法
 // d.fun(1);  此时因为函数名相同，隐藏了父类所有的该方法，子类有没有参数，所以报错
    d.Base::fun(1);//此时调用了父类的fun带参数的方法，刚才只是隐藏了，并没有覆盖！
    return 0;
}

子类在继承父类时，父类中与子类中函数名字相同的所有均被隐藏，(父类中同名的函数不能是虚函数)—>同名隐藏

5.2、赋值兼容规则

class Base{};
  
void Cloud(Base *pb){
    pb->fun();  //没写虚函数，将访问父类的此方法；
    pb->show();
}
  
int main(){
    Base b;
    D d;
    Cloud(&d);
    b = d;  //(1)、子类对象可以直接给父类对象赋值
  
    Base *pb = &d; //(2)、子类对象的地址可以赋值给父类对象的指针
    
    Base &rb = d; //(3)、子类对象可以让父类对象所引用
    return 0;
}

以上就是赋值兼容三规则；在多态中将会体现出用处。