C++继承

概念及工方式

保持已有类的特性而构造新类的过程称为继承。

在已有类的基础上新增自己的特性而产生新类的过程称为派生。

被继承的已有类称为基类（或父类）。

派生出的新类称为派生类(或子类）

继承的目的

实现代码重用

派生的目的：当新的问题出现，原有程序无法解决（或不能完全解决）时，需要对原有程序进行改造

派生类的构造

派生类可以直接访问基类的保护数据成员

只以接口作沟通。即使基类与子类也不例外。这正是类能够发挥其生命力的原因所在。

在构造一个子类时,完成其基类部分的构造由基类的构造函数去做

继承的访问权限

不同继承方式的影响主要体现在：

派生类成员对基类成员的访问权限

通过派生类对象对基类成员的访问权限

三种继承方式

公有继承

私有继承

保护继承

公有继承

基类的public和protected成员的访问属性在派生类中保持不变，但基类的private成员不可直接访问。

派生类中的成员函数可以直接访问基类中的public和protected成员，但不能直接访问基类的private成员。

通过派生类的对象只能访问基类的public成员。

私有继承

基类的public和protected成员都以private身份出现在派生类中，但基类的private成员不可直接访问。

派生类中的成员函数可以直接访问基类中的public和protected成员，但不能直接访问基类的private成员。

通过派生类的对象不能直接访问基类中的任何成员。

保护继承

基类的public和protected成员都以protected身份出现在派生类中，但基类的private成员不可直接访问。

派生类中的成员函数可以直接访问基类中的public和protected成员，但不能直接访问基类的private成员。

通过派生类的对象不能直接访问基类中的任何成员

默认的继承是私有

private 和protect的区别

在单个类中，protected和private没有什么区别。

但在继承关系中，基类的private成员不但对应用程序隐藏，

甚至对派生类也隐藏。而基类的保护成员则只对应用程序隐藏，而对派生类则毫不隐瞒。

#include<iostream>
using namespace std;
class Shop
{
public:
    int m_a;
    void saleDaliyGoods()
    {
        cout<<"卖日用品"<<endl;
        return;
    }
};
class Market:public Shop
{
public:
    void saleFood()
    {
        m_a=10;
        cout<<"食品"<<m_a<<endl;
        return;
    }
};
class SuperMarket:public Market
{
public:
    void pay()
    {
        cout<<"代缴水电费"<<endl;
        return;
    }
};
int main(int argc,char **argv)
{
    SuperMarket m;
    m.saleDaliyGoods();
    m.saleFood();
    m.pay();
}

//结果为:
//卖日用品
//食品10
//代缴水费

#include<iostream>
using namespace std;
class Shop
{
protected:
    int m_a;
public:
    void saleDaliyGoods()
    {
        cout<<"卖日用品"<<endl;
        return;
    }
};
class Market:public Shop
{
public:
    void saleFood()
    {
        m_a=10;
        cout<<"食品"<<m_a<<endl;
        return;
    }
};
int main(int argc,char **argv)
{
    Market m;
//  m.m_a=10;
    m.saleDaliyGoods();
    m.saleFood();
}
//用protected ,则在Market中可以访问,但是在int main中,m.m_a=10;是错误的

#include<iostream>
using namespace std;
class Shop
{
public:
    Shop()
    {
        cout<<"Shop construct"<<endl;
    }
};
class Market:public Shop
{
public:
    Market()
    {
        cout<<"Market construct"<<endl;
    }
};
int main()
{
    Market m;
}
//结果为:
//shop construct
//Market construct

#include<iostream>
using namespace std;
class Shop
{
    int m_a;
public:
    Shop(int a)
    {
        m_a=a;
        cout<<"Shop construct"<<m_a<<endl;
    }
};
class Market:public Shop
{
public:
    Market():Shop(222)
    {
        cout<<"Market construct"<<endl;
    }
};
int main()
{
    Market m;
}
//结果为:
//Shop construct222
//Market construct

#include<iostream>
using namespace std;
class Shop
{
    int m_a;
public:
    Shop(int a=111)
    {
        m_a=a;
        cout<<"Shop construct"<<m_a<<endl;
    }

};
class Market:public Shop
{
    
public:
    Market():Shop()
    {
        cout<<"Market construct"<<endl;
    }
    
};
int main()
{
    Market m;
}
//结果为:Shop construct111
//Market construct

#include<iostream>
using namespace std;
class Shop
{
    int m_a;
public:
    Shop(int a)
    {
        m_a=a;
        cout<<"Shop construct"<<m_a<<endl;
    }
    Shop()
    {
        m_a=333;
        cout<<"Shop construct"<<m_a<<endl;
    }
};
class Market:public Shop
{
    
public:
    Market():Shop()
    {
        cout<<"Market construct"<<endl;
    }
    
};
int main()
{
    Market m;
}
//结果为:
Shop construct333
//Market construct

最先创建的最后析构

#include<iostream>
using namespace std;
class Shop
{
    int m_a;
public:
    Shop(int a)//=111)
    {
        m_a=a;
        cout<<"Shop construct"<<m_a<<endl;
    }
/*  Shop()
    {
        m_a=333;
    }*/
    ~Shop()
    {
        cout<<"~~~~~~~Shop"<<m_a<<endl;
    }
};
class Test
{
public:
    Test()
    {
        cout<<"Test construct"<<endl;
    }
    ~Test()
    {
        cout<<"~~~~~~Test"<<endl;
    }
};
class Market:public Shop
{
    Test m_t;
public:
    Market():Shop(222)
    {
        cout<<"Market construct"<<endl;
    }
    ~Market()
    {
        cout<<"~~~~~Market"<<endl;
    }
};
int main()
{
    Market m;
    cout<<"=========="<<endl;
}
//结果为:
//Shop construct222
//Test construct
//Market construct
//============
//~~~~~~~~Market
//~~~~~~~~~Test
//~~~~~~~~~Shop

赋值兼容规则

赋值兼容规则中所指的替代包括以下的情况：

派生类的对象可以赋值给基类对象。

派生类的对象可以初始化基类的引用。

派生类对象的地址可以赋给指向基类的指针。

#include<iostream>
using namespace std;
class B0
{
    public:
        void display()
        {
            cout<<"B0 display"<<endl;
        }
};
class B1:public B0
{
    public:
        void display()
        {
            cout<<"B1 display"<<endl;
        }
};
class D1:public B1
{
    public:
        void display()
        {
            cout<<"D1 display"<<endl;
        }
};
int main()
{
    B0 b0;b0.display();
    B1 b1;b1.display();
//  D1 d1;d1.display();
    D1 b3;b3.B1::display();
}
//结果为:
//B0 display
//B1 display
//B1 display

重写虚函数,实现多态(多态)

多态是C++的重要概念,是面向对象设计理念的精华, 大型的C++软件项目和大型的系统实现中,多态是必不可少的,可以减轻系统升级、维护、调试的工作量和复杂度.

多态的条件

C++多态是通过虚函数实现的，虚函数允许子类重新定义成员函数，而子类重新定义父类接口的做法称为覆盖或重写

子类需要公有继承于父类

定义父类的指针或引用，然后通过指针或引用去调用相应的虚函数

虚函数

成员函数之前加上 virtua
关键字之后，就是虚成员函数

判断子类的成员函数是否为虚函数

该函数是否与基类的虚函数相同的函数名

该函数是否与基类的虚函数有相同的参数个数及相同的对应参数类型

该函数是否与基类的虚函数有相同的返回值或者满足赋值兼容规则的指针、引用的返回值

多态与非多态的区别

多态与非多态的区别就是函数地址是早绑定还是晚绑定。如果函数的调用在编译期间就可以确定函数的调用地址，并生产代码，就是静态的也就是早绑定是非多态的。而如果函数的调用地址不能在编译期间确定，需要在运行时才确定，这就是晚绑定也称动态联编，是多态的

#include<iostream>
using namespace std;
class B0
{
    public:
        virtual void display()
        {
            cout<<"B0 display"<<endl;
        }
};
class B1:public B0
{
    public:
        void display()
        {
            cout<<"B1 display"<<endl;
        }
};
class D1:public B1
{
    public:
        void display()
        {
            cout<<"D1 display"<<endl;
        }
};
int main()
{
    B0 b0,*p0;
    p0=&b0;
    p0->display();
    B1 b1;
    p0=&b1;
    p0->display();
    D1 d1;
    p0=&d1;
    p0->display();
//  D1 b3;b3.B1::display();
}
//结果为:
//B0 display
//B1 display
//D1 display

重载与重写的区别（重写重要）

重载overload：函数名相同，参数列表不同，重载只是在同类的内部存在，并且不能靠返回值来判断

重写overwrite：也称覆盖，子类重新定义父类中的同名函数。函数特征相同，单数具体实现不同，基类的函数要有关键字virtual,主要是在继承关系中出现。

重写函数

#include<iostream>
using namespace std;
class B0
{
    public:
        virtual void display()
        {
            cout<<"B0 display"<<endl;
        }
};
class B1:public B0
{
    /*  public:
        void display()
        {
            cout<<"B1 display"<<endl;
        }*/
};
class D1:public B1
{
    public:
        void display()
        {
            cout<<"D1 display"<<endl;
        }
};
int main()
{
    B0 b0,*p0;
    p0=&b0;
    p0->display();
    B1 b1;
    p0=&b1;
    p0->display();
    D1 d1;
    p0=&d1;
    p0->display();
}
//结果为:
//B0 display
//B0 display
//D1 display

纯虚函数

#include<iostream>
using namespace std;
class B0
{    public:
        virtual void display()=0;
};
class B1:public B0
{
    public:
        void display()
        {
            cout<<"B1 display"<<endl;
        }
};
int main()
{
    B0 *p0;//加上B0 b0有错
    B1 b1;
    p0=&b1;
    p0->display();
}
B1 display

多继承(缺点:如果Father有一个id,Mother也有一个id,则多继承,Son会有两个id,二义性)

#include<iostream>
using namespace std;
class Father
{
public:
    void money()
    {
        cout<<"有钱"<<endl;
    }
};
class Mother
{
public:
    void face()
    {
        cout<<"高挑，漂亮"<<endl;
    }
};
class Son:public Father,public Mother
{
    
};
int main()
{
    Son s;
    s.money();
    s.face();
}
//结果为:
//有钱
//高挑,漂亮

以上问题的处理方法

#include<iostream>
using namespace std;
class Person
{
    public:
        int id;
};
class Father:virtual public Person
{
    public:
        void money()
        {   
            cout<<"有钱"<<endl;
        }
};
class Mother:virtual public Person
{
    public:
        void face()
        {
            cout<<"高挑，漂亮"<<endl;
        }
};
class Son:public Father,public Mother
{
    
};
int main()
{
    Son s;
    s.id=3;
    Person *p=&s;
    cout<<p->id<<endl;
}
//结果为3

继承顺序

任何虚拟基类的构造函数按照它们被继承的顺序构造

任何非虚拟基类的构造函数按照它们被继承的顺序构造；

任何成员对象的构造函数按照它们声明的顺序调用；
类自己的构造函数。

继承顺序

#include<iostream>
using namespace std;
class A
{
    public:
        A()
        {
            cout<<"A construct"<<endl;
        }
        ~A()
        {
            cout<<"~~~~~~~A"<<endl;
        }
};
class B
{
    public:
        B()
        {
            cout<<"B construct"<<endl;
        }
        ~B()
        {
            cout<<"~~~~~~~B"<<endl;
        }
};
class C
{
    public:
        C()
        {
            cout<<"C construct"<<endl;
        }
        ~C()
        {
            cout<<"~~~~~~~C"<<endl;
        }
};
class D:public A,public B,virtual public C
{
    public:
        D()
        {
            cout<<"D construct"<<endl;
        }
        ~D()
        {
            cout<<"~~~~~~~D"<<endl;
        }
};
int main()
{
    D d;
    cout<<"========="<<endl;
}
//结果为:
//C construct
//A construct
//B construct
//D construct
//=========
//~~~~~~~D
//~~~~~~~B
//~~~~~~~A
//~~~~~~~C

最后编辑于：2017.12.04 11:31:56

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 206,839评论 6赞 482
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 88,543评论 2赞 382
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 153,116评论 0赞 344
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 55,371评论 1赞 279
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 64,384评论 5赞 374
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 49,111评论 1赞 285
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 38,416评论 3赞 400
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 37,053评论 0赞 259
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 43,558评论 1赞 300
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 36,007评论 2赞 325
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 38,117评论 1赞 334
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,756评论 4赞 324
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 39,324评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,315评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,539评论 1赞 262
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 45,578评论 2赞 355
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,877评论 2赞 345

C++继承

概念及工方式

继承的目的

派生类的构造

继承的访问权限

公有继承

私有继承

保护继承

默认的继承是私有

private 和protect的区别

赋值兼容规则

重写虚函数,实现多态(多态)

多态的条件

虚函数

判断子类的成员函数是否为虚函数

多态与非多态的区别

重载与重写的区别（重写重要）

重写函数

纯虚函数

继承顺序

继承顺序

推荐阅读更多精彩内容