C++ 继承Inheritance

C++面向对象的三大特性：封装encapsulation 继承inheritance 多态polymorphism
今天我们来复习一下继承Inheritance⇩

---

继承inheritance

●优点-减少重复代码
●语法-class 子类：继承方式 父类
Derived Class子类 也称为 派生类
Base Class父类 也称为 基类
●派生类中的成员包含：
①从基类继承过来的（表现共性）
②自己增加的成员（表现特性）
（下级别的成员拥有上一级的共性 也有自己的特性）

---

继承方式

1.公有继承
class B:public A
父类中的公共权限成员 到子类中依然是公共权限
父类中的保护权限成员 到子类中依然是保护权限
父类中的私有权限成员 子类访问不到
2.保护继承
class B:protected A
父类中的公共权限成员 到子类中变为保护权限
父类中的保护权限成员 到子类中变为保护权限
父类中的私有权限成员 子类访问不到
3.私有继承
class C:private A
父类中的公共权限成员 到子类中变为私有成员
父类中的保护权限成员 到子类中变为私有成员
父类中的私有权限成员 子类访问不到

Public Inheritance		Protected Inheritance		Private Inheritance
Base Class	Derived Class	Base Class	Derived Class	Base Class	Derived Class
public	public	public	protected	public	private
protected	protected	protected	protected	protected	private
private		private		private

注：继承不降低数据的安全性

父类中私有成员属性被编译器隐藏，因此访问不到，但父类中所有非静态成员都被继承下去了。

#include <iostream>
using namespace std;

class Base
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;//私有成员只是被隐藏了 但还是会继承下去
};

//公有继承
class Son :public Base
{
public:
    int m_D;
};

void test01()
{
    //父类中所有非静态成员属性都会被子类继承下去
    //父类中私有成员属性被编译器隐藏 因此访问不到 但被继承下去了
    cout << "size of Son=" << sizeof(Son) << endl;//答案是16
}

int main()
{
    test01();

    system("pause");

    return 0;
}

运行结果：

结果说明，父类中私有成员int m_C也被子类继承。

●父类中的private私有成员子类不能用，为什么还要继承过来占用空间？
因为可能父类的public部分会调用到它的private，有依赖关系，不能随意丢弃。
●继承后子类新定义的部分不能直接用父类的private部分。
●子类的对外接口有：继承的public和新定义的public。
●父类public里的构造函数、析构函数、拷贝构造函数、拷贝赋值、友元不能被继承；static可以被继承。
●不同的继承方式不影响子类调用父类的函数和变量。
但会影响下一次继承，即子类的子类会受影响；
还会影响子类对象的对外数据接口，父类的public能否成为子类的对外数据接口由继承方式决定。

---

继承中构造和析构顺序

先构造父类 再构造子类
先析构子类 再析构父类

#include <iostream>
using namespace std;

class Base
{
public:
	Base()
	{
		cout << "Base的构造函数" << endl;
	}

	~Base()
	{
		cout << "Base的析构函数" << endl;
	}
};

class Son :public Base
{
public:
	Son()
	{
		cout << "Son的构造函数" << endl;
	}

	~Son()
	{
		cout << "Son的析构函数" << endl;
	}
};

void test01()
{
	//继承中的构造和析构顺序如下：
	//先构造父类 再构造子类 析构的顺序与构造的顺序相反
	Son s;
}

int main()
{
	test01();

	system("pause");

	return 0;
}

运行结果：

---

继承中同名成员处理方式

1.子类对象可以直接访问到子类中同名成员；
2.子类对象加作用域可以访问到父类同名成员；
3.当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数。

同名属性处理方式

#include <iostream>
using namespace std;

class Base
{
public:
    Base()
    {
        m_A = 100;
    }
    int m_A;
};

class Son :public Base
{
public:
    Son()
    {
        m_A = 200;
    }
    int m_A;
};
//同名属性处理方式
void test01()
{
    Son s;
    cout << "Son 下 m_A = " << s.m_A << endl;
    //如果通过子类对象 访问到父类中同名成员 需要加作用域
    cout << "Base 下 m_A = " << s.Base::m_A << endl;
}

int main()
{
    test01();

    system("pause");

    return 0;
}

运行结果：

同名函数处理方式

#include <iostream>
using namespace std;

class Base
{
public:
    void func()
    {
        cout << "Base-func()调用" << endl;
    }

    void func(int a)
    {
        cout << "Base-func(int a)调用" << endl;
    }
};

class Son :public Base
{
public:
    void func()
    {
        cout << "Son-func()调用" << endl;
    }
};

//同名函数处理方式
void test01()
{
    Son s;
    //直接调用 调用的是子类中的同名成员
    s.func();
    //调用父类的同名成员函数 加作用域
    s.Base::func();
    //如果子类中出现和父类同名的成员函数 子类的同名成员会隐藏掉父类中所有同名成员函数
    //如果想访问到父类中被隐藏的同名成员函数 需要加作用域
    s.Base::func(100);
}

int main()
{
    test01();

    system("pause");

    return 0;
}

运行结果：

---

继承中同名静态成员处理方式

静态成员和非静态成员出现同名 处理方式一致
访问子类同名成员-直接访问
访问父类同名成员-加作用域

同名静态成员属性处理方式

#include <iostream>
using namespace std;

class Base
{
public:
    static int m_A;
};

int Base::m_A = 100;

class Son :public Base
{
public:
    static int m_A;
};

int Son::m_A = 200;

//同名静态成员属性
void test01()
{
    //1.通过对象访问
    cout << "通过对象访问：" << endl;
    Son s;
    cout << "Son 下 m_A = " << s.m_A << endl;
    cout << "Base 下 m_A = " << s.Base::m_A << endl;

    //2.通过类名访问
    cout << "通过类名访问：" << endl;
    cout << "Son 下 m_A = " << Son::m_A << endl;
    //第一个::代表通过类名方式访问   第二个::代表访问父类作用域下
    cout << "Base 下 m_A = " << Son::Base::m_A << endl;
}

int main()
{
    test01();

    system("pause");

    return 0;
}

运行结果：

同名静态函数处理方式

#include <iostream>
using namespace std;

class Base
{
public:
    static void func()
    {
        cout << "Base-static void func()" << endl;
    }

    static void func(int a)
    {
        cout << "Base-static void func(int a)" << endl;
    }
};

class Son :public Base
{
public:
    static void func()
    {
        cout << "Son-static void func()" << endl;
    }
};

//同名静态成员函数
void test01()
{
    //1.通过对象访问
    cout << "通过对象访问：" << endl;
    Son s;
    s.func();
    s.Base::func();

    //2.通过类名访问
    cout << "通过类名访问：" << endl;
    Son::func();
    Son::Base::func();

    //子类出现和父类同名静态成员函数 会隐藏父类中所有同名成员函数
    //如果想访问父类中被隐藏的同名成员 需要加作用域
    Son::Base::func(100);
}

int main()
{
    test01();

    system("pause");

    return 0;
}

运行结果：

●父类的指针/引用能否指向子类对象？反之是否可以？
父类的引用可以指向子类对象，因为子类对象满足父类引用的成员变量和函数；
子类的引用不能指向父类对象，因为若会访问到子类特有的成员变量或函数，则出现非法访问。

●子类和父类里同一个变量或函数重复，会发生隐藏，子类的会隐藏父类的，优点是可以把父类里不适合子类的重新定义，且不会影响父类里的，只是被遮挡了而已。

---

多继承

C++允许一个类继承多个类
多继承可能会引发父类中有同名成员出现 需要加作用域区分

语法-class 子类：继承方式 父类1，继承方式 父类2...

若Base1和Base2中都有int A
class Son :public Base1, public Base2
Base1和Base2中的int A 需要加作用域区分
Son s;
s.Base1::A//Base1中的int A
s.Base2::A//Base2中的int A

---

谢谢大家 欢迎大家批评指正！