c++继承方式和类型兼容的学习

继承方式

  • 公有继承:公有继承的特点是基类的公有成员和保护成员作为派生类的成员时,它们都保持原有的状态,而基类的私有成员仍然是私有的,不能被这个派生类的子类所访问。

  • 私有继承:私有继承的特点是基类的共有成员和保护成员在继承时都作为派生类的私有成员,派生类的其他成员可以访问,但派生类的对象不可以访问,值得一提的是如果派生类继续作为基类进行派生,基类得全部成员在新的派生类中都无法访问,实际上是中断了基类的继续派生

  • 保护继承:保护继承的特点是基类的共有成员和保护成员在继承时都作为派生类的保护成员,而派生类的私有成员不可直接访问

    保护继承的特点是基类的所有公有成员和保护成员都成为派生类的保护成员,并且只能被它的派生类成员函数或友元访问,基类的私有成员仍然是私有的。

    下面列出三种不同的继承方式的基类特性和派生类特性。

    public protected private
    共有继承 public protected 不可见
    私有继承 private private 不可见
    保护继承 protected protected 不可见

​ 下面举个栗子😸

公有继承:

#include<iostream>
using namespace std;
//////////////////////////////////////////////////////////////////////////
class A       //父类
{
private:
    int privatedateA;
protected:
    int protecteddateA;
public:
    int publicdateA;
};
//////////////////////////////////////////////////////////////////////////
class B :public A      //基类A的派生类B(公有继承)
{
public:
    void funct()
    {
        int b;
        b=privatedateA;   //error:基类中私有成员在派生类中是不可见的
        b=protecteddateA; //ok:基类的保护成员在派生类中为保护成员
        b=publicdateA;    //ok:基类的公共成员在派生类中为公共成员
    }
};
//////////////////////////////////////////////////////////////////////////
class C :private A  //基类A的派生类C(私有继承)
{
public:
    void funct()
    {
        int c;
        c=privatedateA;    //error:基类中私有成员在派生类中是不可见的
        c=protecteddateA;  //ok:基类的保护成员在派生类中为私有成员
        c=publicdateA;     //ok:基类的公共成员在派生类中为私有成员
    }
};
//////////////////////////////////////////////////////////////////////////
class D :protected A   //基类A的派生类D(保护继承)
{
public:
    void funct()
    {
        int d;
        d=privatedateA;   //error:基类中私有成员在派生类中是不可见的
        d=protecteddateA; //ok:基类的保护成员在派生类中为保护成员
        d=publicdateA;    //ok:基类的公共成员在派生类中为保护成员
    }
};
//////////////////////////////////////////////////////////////////////////
int main()
{
    int a;
 
    B objB;
 //   a=objB.privatedateA;   //error:基类中私有成员在派生类中是不可见的,对对象不可见
 //   a=objB.protecteddateA; //error:基类的保护成员在派生类中为保护成员,对对象不可见
   a=objB.publicdateA;    //ok:基类的公共成员在派生类中为公共成员,对对象可见
 
    C objC;
  //  a=objC.privatedateA;   //error:基类中私有成员在派生类中是不可见的,对对象不可见
  //  a=objC.protecteddateA; //error:基类的保护成员在派生类中为私有成员,对对象不可见
  // a=objC.publicdateA;    //error:基类的公共成员在派生类中为私有成员,对对象不可见
 
    D objD;
//    a=objD.privatedateA;   //error:基类中私有成员在派生类中是不可见的,对对象不可见
//    a=objD.protecteddateA; //error:基类的保护成员在派生类中为保护成员,对对象不可见
//    a=objD.publicdateA;    //error:基类的公共成员在派生类中为保护成员,对对象不可见
 
    return 0;
}

类型兼容

类型兼容是指在需要基类对象的任何地方,都可以使用公有派生类的对象来替代。替代之后,派生类对象就可以作为基类对象来使用,但只能使用从基类继承的成员。其包含以下情形:

  1. 派生类对象可以隐含转换为基类对象
  2. 派生类对象可以初始化基类的引用
  3. 派生类的指针可以隐含转换为基类的指针

举个栗子:

class B{...} //定义基类B
class D:public B{...}  //定共有派生类D
B b1,*pb1;
D d1;
//派生类对象隐含转换为基类对象
b1 = d1;
//派生类对象亦可以初始话基类对象的引用
B &rb = d1;
//派生类的地址可以转换为指向基类的指针
pb1 = &d1;

实例:

#include"pch.h"
#include<iostream>

using namespace std;
class Base1 {       //定义基类Base1
public:
	void dispaly() const {
		cout << "Base1;:dispaly()" << endl;
	}
};

class	Base2 :public Base1 {    //定义公有派生类Base2
public :
	void dispaly() const {
		cout << "Base2::display()" << endl;
	}
};

class Derived :public Base2 {
public:
	void display() {
		cout << "Dervied::display()" << endl;
	}
};


void fun(Base1 *ptr){   //参数为指向基类型的指针
	ptr->dispaly();
}


int main() {
	Base1 base1;
	Base2 base2;
	Derived derived;
    
	fun(&base1);   //用base1对象的指针调用fun函数
	fun(&base2);   //用base2对象的指针调用fun函数
	fun(&derived); //用derived对象的指针调用fun函数
	return 0;
}

运行如下:

由于作者水平有限,以上内容难免有不当之处,还望不吝赐教

posted @ 2019-10-13 14:27  pony.ma  阅读(164)  评论(0编辑  收藏  举报