一、什么是继承？
    它允许程序员在保持原有类特性的基础上进行扩展，增加功能。这样产生新的类，成为派生类。简单来说，就是父子继承关系，你从你父亲继承了某些东西，而你在你父亲的基础上又扩充了相关的功能特性，构成了你自己。你自己就是一个子类，也就是派生类。
    在对派生类做介绍之前，先了解一下继承权限的问题。简单给大家做一个总结。
    继承分为三类：公有继承（public）、保护继承（protected）、私有继承（private）。对于基类中的私有成员，三种继承方式都不可见。以下三种继承是针对除私有成员外，对于公有继承，所有成员的特性不变。对于保护继承，所有成员特性变为保护方式。对于私有继承，所有成员特性变为私有方式。
   在这里需要注意：使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public。
二、对于类中的默认的成员函数，子类会继承父类中的吗？
1.构造函数
  class Base
{
public:
 Base()
 {
 cout << "Base::Base()" << endl;
 }
 int _b;
};

class Derived :public Base
{
public:
 
 int _d;

};
int main()

{


 Derived d;


 d._b = 1;


 d._d = 2;


 return 0;


}


1.基类中有缺省的构造函数，派生类就会调用默认的构造函数。
2.基类没有定义构造函数，则派生类也可以不用定义，全部使用缺省构造函数。
将上面的基类改为如下
class Base
{
public:
 Base(int i)
 :_b(i)
 {
 cout << "Base::Base()" << endl;
 }
 int _b;

};
   编译上述的代码，显示Derived类中没有可用的构造函数，这说明，
   3.当基类中有带参数列表的构造函数时，派生类必须定义构造函数，且在初始化列表中显示的给出基类名和参数列表，
  如下
class Base
{
public:
 Base(int i)
 :_b(i)
 {
 cout << "Base::Base()" << endl;
 }
 int _b;
};

class Derived :public Base
{
public:
 Derived()
 :Base(1)
 {
 cout << "Derived::Base()" << endl;
 }
 int _d;

};


  知道了派生类的构造函数的具体定义，在来看一下派生类的构造函数的调用次序问题
  在派生类中会先调用派生类的构造函数，但是在派生类的初始化链表部分，就会转去调用基类的构造函数，所以先初始化的是基类，然后再去初始化派生类。可以用反汇编代码来看一下派生类的构造函数


 可见在派生类中call即调用了Base的构造函数。
2.拷贝构造函数 
class Base
{
public:
 Base(int i)
 :_b(i)
 {
 cout << "Base::Base()" << endl;
 }


 Base(const Base& b)

 {     
                 _b = b._b;

 cout << "Base::Base(const Base& b)" << endl;


 }




 int _b;

};



class Derived :public Base

{

public:


 Derived()


 :Base(1)


 {


 cout << "Derived::Derived()" << endl;


 }


 int _d;

};


#endif
int main()

{


 Derived d1;


 Derived d2(d1);


 return 0;


}


用内存窗口看看d2是否正确拷贝d1
        上边是d1的，下边是d2的，可以看出拷贝无误。

由此可以看出，1.基类没有定义拷贝构造函数，则派生类也可以不用定义，全部使用默认拷贝构造函数（派生类自己的数据不涉及深拷贝）。
                          2.当基类中有定义的拷贝构造函数时，派生类也可以使用默认的拷贝构造函数（派生类自己的数据不涉及深拷贝）。
       这时不同于构造函数的是，派生类默认的构造函数在转去调用基类中的构造函数时，不会提供基类中的形参列表的数据，这时编译器就不会找到合适的构造函数。  而拷贝构造函数是只需提供一个派生类的对象（包含基类的数据和自己的数据）， 在派生类中调用拷贝构造函数时，会转去调用基类中的拷贝构造函数，这时将基类的数据先去拷贝一份，在根据编译器合成的默认拷贝构造函数，将派生类自己的也拷有人会说深拷贝的时候会出错，这时要考略
                         3. 那如果是深拷贝呢？？？？分为两种情况。
        派生类自己的数据不包含深拷贝，这时如果基类中是深拷贝，有问题吗？？？？当然是没有问题的。这是因为你已经在基类中定义好了基类的拷贝构造函数，你直接去调用而已，所以基类中的数据的地址是两份的。
        派生类自己的数据是深拷贝，这是你必须显示定义派生类的拷贝构造函数，否则派生类自己的指针变量就会出现共用同一块地址空间而导致的析构时，一块地址空间被连续释放多次。
 3.析构函数  
class Base
{
public:
 Base(int i)
 :_b(i)
 {
 cout << "Base::Base()" << endl;
 }


 Base(const Base& b)
 {
 _b = b._b;
 cout << "Base::Base(const Base& b)" << endl;
 }


 ~Base()
 {
 cout << "Base::~Base()" << endl;
 }


 int _b;
};


class Derived :public Base
{
public:
 Derived(int d)
 :Base(1),
 _d(d)
 {
 cout << "Derived::Base()" << endl;
 }
 int _d;
};

          
                          1.基类没有定义析构函数，则派生类也可以不用定义，全部使用默认析构函数（派生类自己的数据不涉及深拷贝）。
                          2.当基类中有定义的析构函数时，派生类也可以使用默认的拷贝构造函数（派生类自己的数据不涉及深拷贝）。
              3.如果派生类自己包含深拷贝，则析构函数必须显示的给出来，否则设计深拷贝的地址空间释放不了。思想和拷贝构造函数一样。
4.赋值操作符重载  ------->和拷贝构造函数/析构函数一样


  
   

 
文章目录
 
Python中类的多继承
多继承
Python多继承实现
多继承的缺点
Mixin
*思路1*
*思路2*
*思路3*
*思路4*
  
  
Mixin类

 
Python中类的多继承
 
Python2.2之前类是没有共同的祖先的，之后，引入object类，它是所有类的共同祖先类object。Python2中为了兼容，分为古典类（旧式类）和新式类。Python3中全部都是新式类。新式类都是继承自object的，新式类可以使用super。
 
#一下代码在Python2.x中运行

#古典类(旧式类)
class A:pass

#新式类
class B(object):pass

print(dir(A))
print(dir(B))
print(A.__bases__)
print(B.__bases__)

#古典类
a = A()
print(a.__class__)
print(type(a)) #<type 'instance'>

#新式类
b = B()
print(b.__class__)
print(type(b))
 
多继承
 
OCP原则：多用“继承”、少修改
 继承的用途：在子类上实现对基类的增强、实现多态
 多态: 在面向对象中，父类、子类通过继承联系在一起，如果可以通过一套方法，就可以实现不同表现，就是多态。一个类继承自多个类就是多继承，它将具有多个类的特征。
 
多继承弊端
 
多继承很好的模拟了世界，因为事物很少是单一继承，但是舍弃简单，必然引入复杂性，带来了冲突。
多继承的实现会导致代码设计的复杂度增加，所以有些高级编程语言舍弃了类的多继承。
C++支持多继承；Java舍弃了多继承。 
  
Java中，一个类可以实现多个接口，一个接口也可以继承多个接口。Java的接口很纯粹，只是方法的声明，继承者 必须实现这些方法，就具有了这些能力，就能干什么。
 
多继承可能会带来二义性
实现多继承的语言，要解决二义性，深度优先或者广度优先。
 
Python多继承实现
 
class ClassName(基类列表):
    类体
 
 
左图是多继承（菱形继承），右图是单一继承。
 多继承带来路径选择问题，究竟继承哪个父类的特征呢？
 Python使用MRO（method resolution order方法解析顺序）解决基类搜索顺序问题。
 
 
历史原因，MRO有三个搜索算法：
 
  
经典算法：按照定义从左到右，深度优先策略。2.2版本之前 左图的MRO是MyClass,D,B,A,C,A
新式类算法：是经典算法的升级，深度优先，重复的只保留最后一个。2.2版本 左图的MRO是MyClass,D,B,C,A,object
C3算法：在类被创建出来的时候，就计算出一个MRO有序列表。2.3之后，Python3唯一支持的算法 左图中的MRO是MyClass,D,B,C,A,object的列表 
    
C3算法解决多继承的二义性
 
 
 
经典算法有很大的问题，如果C中有覆盖A的方法，就不会访问到了，因为先访问A（深度优先）。
 
 
新式类算法，依然采用了深度优先，解决了重复问题，但是同经典算法一样，没有解决继承的单调性。
 
 
C3算法，解决了继承的单调性，它阻止创建之前版本产生二义性的代码。求得的MRO本质是为了线性化，且确定 了顺序。
 
  
单调性：假设有A、B、C三个类，C的mro是[C, A, B]，那么C的子类的mro中，A、B的顺序一致就是单调的。
 
 
多继承的缺点
 
当类很多，继承复杂的情况下，继承路径太多，很难说清什么样的继承路径。Python语法是允许多继承，但Python代码是解释执行，只有执行到的时候，才发现错误。团队协作开发，如果引入多继承，那代码很有可能不可控。不管编程语言是否支持多继承，都应当避免多继承。Python的面向对象，我们看到的太灵活了，太开放了，所以要团队守规矩。
 
Mixin
 
类有下面的继承关系
 
 文档Document类是其他所有文档类的抽象基类；Word、Pdf类是Document的子类。
 需求：为Document子类提供打印能力
 
思路1
 
在Document中提供print方法
 假设已经有了下面3个类
 
class Document:
    def __init__(self,content):
        self.content = content

    def print(self): #抽象方法
        raise NotImplementedError()

class Word(Document): pass #其他功能略去
class Pdf(Document): pass #其他功能略去
 
基类提供的方法可以不具体实现，因为它未必适合子类的打印，子类中需要覆盖重写。
基类中只定义，不实现的方法，称为“抽象方法“。 
  
在Python中，如果采用这种方式定义的抽象方法，子类可以不实 现，直到子类使用该方法的时候才报错。
 
 
print算是一种能力 —— 打印功能，不是所有的Document的子类都需要的，所有，从这个角度出发，上面的基类 Document设计有点问题。
 
思路2
 
在需要打印的子类上增加打印功能
 如果在现有子类Word或Pdf上直接增加，虽然可以，却违反了OCP的原则，所以可以继承后增加打印功能。因此有 下图
 
 
class Document: #第三方库，不允许修改
    def __init__(self,content):
        self.content = content
class Word(Document): pass #第三方库，不允许修改
class Pdf(Document): pass #第三方库，不允许修改

#单继承
class PrintableWord(Word):
    def print(self):
        print(self.content,self.__class__.__name__)

print(PrintableWord.__dict__)
print(PrintableWord.mro())

pw = PrintableWord("我是word打印")
pw.print()
 

 看似不错，如果需要还要提供其他能力，如何继承？
 例如，如果该类用于网络，还应具备序列化的能力，在类上就应该实现序列化。
 可序列化还可能分为使用pickle、json、messagepack等。
 这个时候发现，为了增加一种能力，就要增加一次继承，类可能太多了，继承的方式不是很好了。
 功能太多，A类需要某几样功能，B类需要另几样功能，它们需要的是多个功能的自由组合，继承实现很繁琐。
 
思路3
 
装饰器。用装饰器增强一个类，把功能给类附加上去，那个类需要，就装饰它。
 
class Document: #第三方库，不允许修改
    def __init__(self,content):
        self.content = content
class Word(Document): pass #第三方库，不允许修改
class Pdf(Document): pass #第三方库，不允许修改

#类装饰器，为类动态增加打印功能
def printtable(cls):
    def _print(self):
        print(self.content,"---装饰器")
    cls.print = _print
    return cls

@printtable
class PrintableWord(Word):pass

@printtable
class PrintablePdf(Pdf):pass

print(PrintableWord.__dict__)
print(PrintableWord.mro())

pw = PrintableWord("我是word打印")
pw.print()

pf = PrintablePdf("我是pdf打印")
pf.print()
 
 
优点： 
  
简单方便，在需要的地方动态增加，直接使用装饰器。
可以为类灵活的增加功能。
 
 
思路4
 
使用Mixin类，为类增强功能
 
class Document: #第三方库，不允许修改
    def __init__(self,content):
        self.content = content
class Word(Document): pass #第三方库，不允许修改
class Pdf(Document): pass #第三方库，不允许修改

class PrintableMixin:
    def print(self):
        print(self.content,"--Mixin类增强功能")

class PrintableWord(PrintableMixin,Word):pass

class PrintablePdf(PrintableMixin,Pdf):pass

print(PrintableWord.__dict__)
print(PrintableWord.mro())

pw = PrintableWord("我是word打印")
pw.print()

pf = PrintablePdf("我是pdf打印")
pf.print()
 

 Mixin就是其它类混合进来，同时带来了类的属性和方法。Mixin类和装饰器效果一样，也没有什么特别的。但是Mixin是类，就可以继承。
 如果在上需代码完成后，再次开发，需要对原有的print功能再次增强，可以重新在写个增强的print功能，再类需要使用这种增强的print功能时，可以继承增强后的print功能。
 
class Document: #第三方库，不允许修改
    def __init__(self,content):
        self.content = content
class Word(Document): pass #第三方库，不允许修改
class Pdf(Document): pass #第三方库，不允许修改

class PrintableMixin:
    def print(self):
        print(self.content,"--Mixin类增强功能")

class PrintableWord(PrintableMixin,Word):pass

class PrintablePdf(PrintableMixin,Pdf):pass

print(PrintableWord.__dict__)
print(PrintableWord.mro())

pw = PrintableWord("我是word打印")
pw.print()

pf = PrintablePdf("我是pdf打印")
pf.print()

#为print类进行功能增强
class SuperPrintableMixin(PrintableMixin):
    def print(self):
        print("- "*10,"打印前增强")
        super().print()
        print("- "*10,"打印后增强")

#使用新增强的功能
class SuperPrintablePdf(SuperPrintableMixin,Pdf):pass

print("")
print(SuperPrintablePdf.__dict__)
print(SuperPrintablePdf.mro())
spp = SuperPrintablePdf("我是super Pdf")
spp.print()
 
 
Mixin类
 
 
Mixin本质上就是多继承实现的。
 
 
Mixin体现的是一种组合的设计模式。
 在面向对象的设计中，一个复杂的类，往往需要很多功能，而这些功能有来自不同的类提供，这就需要很多的类组 合在一起。
 从设计模式的角度来说，多组合，少继承。
 
 
Mixin类的使用原则
 
  
Mixin类中不应该显式的出现__init__初始化方法
Mixin类通常不能独立工作，因为它是准备混入别的类中的部分功能实现
Mixin类的祖先类也应是Mixin类
使用时，Mixin类通常在继承列表的第一个位置 
    
例如： class PrintableWord(PrintableMixin, Word): pass
 
 
 
Mixin类和装饰器，这两种方式都可以使用，看个人喜好。如果还需要继承就得使用Mixin类的方式。

Python中类的继承、多层继承和多继承
 
Python中，一个类可以通过继承的方式来获得父类中的非私有属性和非私有方法。
 
一、继承、重写、和调用重写的父类方法
 
继承的语法为在类名后的小括号()中写入要继承的父类名，如果要继承多个类则中间用逗号分隔。
 
class Electrical(object):

    def __init__(self, name):
        self.name = name

    def watch_movie(self):
        print('Watch movie!')

    def game(self):
        print('Play game!')

    def chat(self):
        print('Chat with friend!')


class Phone(Electrical, object):

    def send_message(self):
        print('Send message!')

    def game(self):
        print('Play game in phone!')

    def chat(self):
        super(Phone, self).chat()
        print('Chat with anyone!')


p = Phone('VIVO')
# 继承父类的属性
print(p.name)
# 继承父类的方法
p.watch_movie()
# 子类自己实现的方法
p.send_message()
# 重写了父类的方法
p.game()
# 先继承父类的方法，在对父类方法的功能进行扩展
p.chat()
 
运行结果：
 
VIVO
Watch movie!
Send message!
Play game in phone!
Chat with friend!
Chat with anyone!
 
1.父类的非私有属性和非私有方法子类可以直接继承，子类对象可以直接使用。如果子类要调用父类的私有属性和私有方法，只能通过间接的方法来获取。
 
2.子类可以实现父类没有的属性和方法，与继承的属性和方法互不干扰。
 
3.如果在子类中有跟父类同名的方法，但方法中执行的内容不同，则子类可以重写父类方法。
 
当子类实现一个和父类同名的方法时，叫做重写父类方法。直接在子类中定义与父类同名的方法，然后在方法中实现子类的业务逻辑，子类方法就会覆盖父类的同名方法。子类重写了父类方法，子类再调用该方法将不会执行父类的方法。
 
4.如果在子类重写父类的方法中，需要使用父类同名方法中的功能，在父类功能基础上做扩展，则子类可以在重写的方法中调用父类被重写的方法，使用super()来调用。
 
二、类的多层继承
 
类可以多层继承。
 
class Mi(Phone):
    pass


m = Mi('Redmi')
print(m.name)
m.chat()
 
运行结果：
 
Redmi
Chat with friend!
Chat with anyone!
 
继续上面的类，我们定义的类Mi继承自Phone类，Phone类继承自Electrical类，这样就构成了多层继承。
 
Mi类对象可以使用Phone中的方法和属性，也可以使用Electrical中的方法和属性，如果Phone重写了Electrical的方法，则继承的是Phone中的方法。
 
当Mi类对象调用属性和方法时，优先在自己的内部查找是否有该属性和方法，如果没有会到它的父类Phone中查找该属性和方法，如果没有会继续往上在Phone的父类Electrical中查找，一直查找到object类中。到最后也没有找到，就说明对象没有该属性和方法，程序报错，如果找到就会返回找到的属性和方法，不再继续往上查找。
 
三、类的多继承
 
class Computer(Electrical):

    def coding(self):
        print('Coding something!')


class HuaWei(Phone, Computer):
    pass


h = HuaWei('huawei')
h.send_message()
h.coding()
print(h.name)
h.watch_movie()
 
运行结果：
 
Send message!
Coding something!
huawei
Watch movie!
 
同一个类可以继承多个类，如上面的HuaWei类同时继承了Phone和Computer两个类。这时，两个父类中的方法和属性子类都可以使用，两个父类的父类中的属性和方法子类也可以使用。
 
 
 
 
 
 
 

二义性：就是指取值不明确，比如下面例子中的D3同时继承与父类D1,D2。而两个父类当中都有成员变量k.此时如果想要用D3的对象，访问父类的成员变量K，则需要加上相应的域名才能访问。并且只有在继承方式为公有的情况下才可以访问。
 
如果继承方式忘了写，就算加上域名也访问不了。因为类的默认继承方式为保护类型。二此种继承方式下，派生类对象无法访问基类的任何成员。
 
#include <iostream>

using namespace std;

class D1
{
public:
    D1(int k)
    {
        this->k = k;
        cout << "D1 cunstruct " << this->k << endl;
    }
    int k;
};


class D2
{
public:
    D2(int k)
    {
        this->k = k;
        cout << "D2 cunstruct " << this->k << endl;
    }
    int k;

};

class D3 : public D1, public D2 // 如果不写继承方式则默认为保护类型
{
public:
    D3(int k, int k1) :D1(k), D2(k1)
    {
        cout << "D3 cunstruct " << endl;
    }

private:

};

void main()
{
    D3 d3(20, 30);
    d3.D2::k = 100;
    cout << d3.D2::k << endl;   //如果不加域名则访问不明确
    getchar();

}