继承中的类型兼容性原则

类型兼容规则是指在需要基类对象的任何地方,都可以使用公有派生类的对象来替代。通过公有继承,派生类得到了基类中除构造函数、析构函数之外的所有成员。这样,公有派生类实际就具备了基类的所有功能,凡是基类能解决的问题,公有派生类都可以解决。类型兼容规则中所指的替代包括以下情况:

子类对象可以当作父类对象使用

子类对象可以直接赋值给父类对象

子类对象可以直接初始化父类对象

父类指针可以直接指向子类对象

父类引用可以直接引用子类对象

在替代之后,派生类对象就可以作为基类的对象使用,但是只能使用从基类继承的成员。

类型兼容规则是多态性的重要基础之一。

demo

#include <iostream>
using namespace std;

class Parent
{
public:
	void printP()
	{
		cout<<"父类..."<<endl;
	}

	Parent()
	{
		cout<<"parent构造函数"<<endl;
	}

	Parent(const Parent &obj)
	{
		cout<<"copy构造函数"<<endl;
	}

private:
	int a;
};

class child : public Parent
{
public:
	void printC()
	{
		cout<<"子类"<<endl;
	}
protected:
private:
	int c;
};

/*
兼容规则中所指的替代包括以下情况:
	子类对象可以当作父类对象使用
	子类对象可以直接赋值给父类对象
	子类对象可以直接初始化父类对象
	父类指针可以直接指向子类对象
	父类引用可以直接引用子类对象
	*/

//C++编译器 是不会报错的 .....
void howToPrint(Parent *base) // 父类指针
{
	base->printP(); //父类的 成员函数 

}

void howToPrint2(Parent &base) // 父类引用
{
	base.printP(); //父类的 成员函数
}
int main()
{
	//

	Parent p1;
	p1.printP();

	child c1;
	c1.printC();
	c1.printP();

	//赋值兼容性原则
	//1-1 基类指针 (引用) 指向 子类对象
	Parent *p = NULL;
	p = &c1;
	p->printP();  

	//1-2 指针做函数参数

	howToPrint(&p1);
	howToPrint(&c1); 

	//1-3 引用做函数参数
	howToPrint2(p1);
	howToPrint2(c1); 

	//第二层含义

	//可以让子类对象初始化父类对象
	//子类就是一种特殊的父类
	Parent p3 = c1;

	return 0;
}
时间: 2024-10-22 23:42:55

继承中的类型兼容性原则的相关文章

C++ 类的继承二(赋值兼容性原则)

//赋值兼容性原则 #include<iostream> using namespace std; class PointA{ public: PointA(){ x = 0; y = 0; } void Set(){ } private: int x; int y; }; class PointB :public PointA{ public: private: int c; }; /* 赋值兼容性原则内部原理分析 在子类继承父类的时候,在子类的内存区域上,父类的元素会放在前面,子类的元素会

【C++第十课】---继承中的构造与析构

一.继承中的赋值兼容性原则 1.子类对象可以当作父类对象使用 2.子类对象可以直接赋值给父类对象 3.子类对象可以直接初始化父类对象 4.父类指针可以直接指向子类对象 5.父类引用可以直接引用子类对象 6.子类是就是特殊的父类. 举例说明: #include <iostream> using namespace std; class Parent { protected: const char* name; public: Parent() { name= "Parent ...&q

NET中的类型和装箱/拆箱原理

谈到装箱拆箱,DebugLZQ相信给位园子里的博友一定可以娓娓道来,大概的意思就是值类型和引用类型的相互转换呗---值类型到引用类型叫装箱,反之则叫拆箱.这当然没有问题,可是你只知道这么多,那么DebugLZQ建议你花点时间看看楼主这篇文章,继续前几篇博文的风格--浅谈杂侃. 1. .NET中的类型 为了说明装箱和拆箱,那首先必须先说类型.在.NET中,我们知道System.Object类型是所有内建类型的基类.注意这里说的是内建类型,程序员可以编写不继承子自System.Object的类型,这

C++ 抽象类一(多继承与赋值兼容性原则)

//多继承与赋值兼容性原则 #include<iostream> using namespace std; class Point{ public: Point(){ a = 1; b = 2; } int a; int b; }; class PointA { public: PointA(){ c = 3; } int c; }; class PointB :public Point, public PointA{ }; void ProtectB(){ PointB pb; Point

继承中的对象类型转化以及程序运行步骤

1class Parent{ 2 3          int x=10; 4          public Parent(){ 5               add(2); 6          } 7          void add(int y){ 8               x+=y; 9          }10     }1112     class Child extends Parent{13          int x=9;14          void add(

.NET Framework中重点类型的继承关系

继承关系 Object ├─Array │ └─T[] ├─ArrayList └─String .NET Framework中重点类型的继承关系

继承中类型的转换

执行以下代码: class Mammal{} class Dog extends Mammal {} class Cat extends Mammal{} public class TestCast { public static void main(String args[]) { Mammal m; Dog d=new Dog(); Cat c=new Cat(); m=d; d=m; d=(Dog)m; d=c; c=(Cat)m; } } 这个程序不能正常运行,因为在主函数里d=m;这句

设计模式中的六大设计原则之一,二

最近在学习设计模式方面的知识,首先接触到的是设计模式中的六大设计原则: 1.单一职责原则: 2.里氏替换原则:3.依赖倒置原则:4.接口隔离原则:5.迪米特法则:开闭原则.下面我来讲讲我对这六大设计自己的理解,如有欠缺地地方,请大家及时指出啊...   1.单一职责原则:应该有且仅有一个原因引起类的变更.通俗的说,即一个类只负责一项职责.下面我们举一个具体的例子来说明一下什么是单一职责原则.电话通话的时候有4个过程发生:拨号,通话,回应,挂机,首先看下面这样一个借口,如图1所示: 图1. 我们来

面向对象开发中的七大设计原则和23种设计模式

一.面向对象开发中的七大设计原则 软件开发中最核心的思想就是"高内聚,低耦合",主要的目的也是为了方便后期的维护和变更.下面的设计原则也是依靠这个核心思想衍生出来的. 1.单一职责原则[SINGLE RESPONSIBILITY PRINCIPLE]:单一职责原则想表达的核心思想就是"高内聚",一个模块只完成一项功能.在面向对象设计中,一个类只应该负责一项职责,如果同时承担太多职责,就等于把这些职责耦合在了一起. 后面很可能因为某项职责的变更而导致其他职责的削弱或者