继承

1）继承是面向对象程序设计实现软件重用的重要方法。程序猿能够在已有基类的基础上定义新的派生类。

2） 单继承的派生类仅仅有一个基类。多继承的派生类有多个基类。

3） 派生类对基类成员的訪问由继承方式和成员性质决定。

4） 创建派生类对象时，先调用基类构造函数初始化派生类中的基类成员。调用析构函数的次序和调用构造函数的次序相反。

5）C++提供虚继承机制，防止类继承关系中成员訪问的二义性。

6） 多继承提供了软件重用的强大功能。也添加了程序的复杂性。

派生类类成员訪问级别

1、须要被外界訪问的成员直接设置为public

2、仅仅能在当前类中訪问的成员设置为private

3、仅仅能在当前类和子类中訪问的成员设置为protected。protected成员的訪问权限介于public和private之间。

//类的继承方式对子类对外訪问属性影响

#include <cstdlib>

#include <iostream>

using namespace std;

class A

{

private:

    int a;

protected:

    int b;

public:

    int c;

    A()

    {

        a = 0;

        b = 0;

        c = 0;

    }

    void set(int a, int b, int c)

    {

        this->a = a;

        this->b = b;

        this->c = c;

    }

};

class B : public A

{

public:

    void print()

    {

        //cout<<"a = "<<a; //err

        cout<<"b = "<<b;

        cout<<"c = "<<endl;

    }

};

class C : protected A

{

public:

    void print()

    {

        //cout<<"a = "<<a; //err

        cout<<"b = "<<b;

        cout<<"c = "<<endl;

    }

};

class D : private A

{

public:

    void print()

    {

        //cout<<"a = "<<a; //err

        cout<<"b = "<<b<<endl;

        cout<<"c = "<<c<<endl;

    }

};

int main_01(int argc, char *argv[])

{

    A aa;

    B bb;

    C cc;

    D dd;

    aa.c = 100; //ok

    bb.c = 100; //ok

    //cc.c = 100; //err 类的外部是什么含义

    //dd.c = 100; //err

    aa.set(1, 2, 3);

    bb.set(10, 20, 30);

    //cc.set(40, 50, 60); //ee

    //dd.set(70, 80, 90); //ee

    bb.print();

    cc.print();

    dd.print();

    system("pause");

    return 0;

}

类型兼容性原则

子类对象能够当作父类对象使用

子类对象能够直接赋值给父类对象

子类对象能够直接初始化父类对象

父类指针能够直接指向子类对象

父类引用能够直接引用子类对象

#include <cstdlib>

#include <iostream>

using namespace std;

//子类就是特殊的父类

class Parent03

{

protected:

    const char* name;

public:

    Parent03()

    {

        name = "Parent03";

    }

    void print()

    {

        cout<<"Name: "<<name<<endl;

    }

};

class Child03 : public Parent03

{

protected:

    int i;

public:

    Child03(int i)

    {

        this->name = "Child2";

        this->i = i;

    }

};

int main()

{

    Child03 child03(1000);

    //分别定义父类对象 父类指针 父类引用 child

    Parent03 parent = child03;

    Parent03* pp = &child03;

    Parent03& rp = child03;

    parent.print();

    pp->print();

    rp.print();

    system("pause");

    return 0;

}

继承中构造和析构

在子类对象构造时。须要调用父类构造函数对其继承得来的成员进行初始化

在子类对象析构时。须要调用父类析构函数对其继承得来的成员进行清理

#include <cstdlib>

#include <iostream>

using namespace std;

class Parent04

{

public:

    Parent04(const char* s)

    {

        cout<<"Parent04()"<<" "<<s<<endl;

    }

    ~Parent04()

    {

        cout<<"~Parent04()"<<endl;

    }

};

class Child04 : public Parent04

{

public:

    Child04() : Parent04("Parameter from Child!")

    {

        cout<<"Child04()"<<endl;

    }

    ~Child04()

    {

        cout<<"~Child04()"<<endl;

    }

};

void run04()

{

    Child04 child;

}

int main_04(int argc, char *argv[])

{

    run04();

    system("pause");

    return 0;

}

1、子类对象在创建时会首先调用父类的构造函数

2、父类构造函数运行结束后，运行子类的构造函数

3、当父类的构造函数有參数时，须要在子类的初始化列表中显示调用

4、析构函数调用的先后顺序与构造函数相反

继承中的同名成员变量

1、当子类成员变量与父类成员变量同名时

2、子类依旧从父类继承同名成员

3、在子类中通过作用域分辨符::进行同名成员区分（在派生类中使用基类的同名成员，显式地使用类名限定符）

4、同名成员存储在内存中的不同位置