33 继承

最新推荐文章于 2024-07-25 14:10:57 发布
最新推荐文章于 2024-07-25 14:10:57 发布
阅读量57 收藏
点赞数 1
分类专栏： 笔记 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36643203/article/details/119820013
版权

类与类之间的关系 继承

1 继承说明

1 子类拥有父类的所有变量和成员函数

2 子类可以拥有父类没有的方法和属性

#include<iostream>
using namespace std;

class Parent {
public:
	void print() {
		cout << "a:" << a << endl;
		cout << "b:" << b << endl;
	}
	int a;
	int b;
};

//class Children :private Parent
//class Children :protected Parent

class Children :public Parent {
private:
	int c;
};

void main() {
	Children c1;
	c1.a = 2;
	c1.b = 3;
	c1.print();
}

2 子类的访问控制

1 单个类的访问控制

C++继承方式对子类访问影响
  1. public继承， 父类成员在子类中保持原有访问级别
  2. private继承， 父类成员在子类中变为private成员
  3. protected继承， 父类public成员在子类变为protected;父类protected成员在子类仍为protected;父类private成员在子类仍为private; protected 关键字修饰的成员变量和成员函数是为了继承

private成员在子类中依然存在，但是无法访问，不论哪种继承，子类都无法使用父类的私有成员
在这里插入图片描述

共有继承

// public 修饰成员变量和方法 类内部和外部都能使用
// private 修饰成员变量和方法 类内部使用，继承子类中可用
// private 修饰成员变量和方法 类内部使用 外部不能用
class Parent {
public:
	int a;
protected:
	int b;
private:
	int c;

public:
	void printT() {
		cout << "printT" << endl;
	}
};

class Children :public Parent {
public:
	void useVar() {
		a = 0;
		b = 0;
		//c = 0; 不能访问
	}
};

void main() {
	Parent t1, t2, t3;
	t1.a = 10;
	// t1.b = 20; // 不能访问
	// t1.c = 30; // 不能访问
}

私有继承

class Parent {
public:
	int a;
protected:
	int b;
private:
	int c;

public:
	void printT() {
		cout << "printT" << endl;
	}
};

class Children2 :private Parent {
public:
	void useVar() {
		a = 0;
		b = 0;
		// c = 0; 不能访问
	}
};

void main() {
	Children2 c2;
	/*c2.a = 10;		不能访问	
	c2.b = 20;
	c2.c = 30;*/
}

保护继承

class Parent {
public:
	int a;
protected:
	int b;
private:
	int c;

public:
	void printT() {
		cout << "printT" << endl;
	}
};

class Children3 :protected Parent {
public:
	void useVar() {
		a = 0;
		b = 0;
		// c = 0; //不能访问
	}
};

void main() {
	Children3 c3;
	/*c3.a = 10;		
	c3.b = 20;
	c3.c = 30;*/
}

判断时看调用语句在类的内部还是类的外部；再看子类是怎么从父类继承的；再看父类的访问级别。

类的访问属性控制

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;
		cout << "b=" << b;
		cout << "c=" << c << endl;
	}
};

class C :protected A {
public:
	void print() {
		//cout << "a=" << a;
		cout << "b=" << b;
		cout << "c=" << c << endl;
	}
};

class D :private A {
public:
	void print() {
		//cout << "a=" << a;
		cout << "b=" << b;
		cout << "c=" << c << endl;
	}
};

void main() {
	A aa;
	B bb;
	C cc;
	D dd;

	aa.c = 100;
	bb.c = 100;
	// cc.c = 100; // 保护
	// dd.c = 100; // 私有

	aa.set(1, 2, 3);
	bb.set(10, 20, 30);
	// cc.set(40, 50, 60); // 保护
	// dd.set(70, 80, 90); // 

	bb.print();
	cc.print();
	// dd.print();
}

3 继承中的构造和析构

1 类型兼容性原则
  1. 子类对象当作父类对象使用
  2. 子类对象可以直接赋值给父类对象
  3. 子类对象可以初始化父类对象
  4. 父类指针可以直接指向子类对象
  5. 父类引用可以直接引用子类对象
#include<iostream>
using namespace std;


class Parent {
public:
	Parent() {
		cout << "构造函数" << endl;
	}
	Parent(const Parent& obj) {
		cout << "拷贝构造函数" << endl;
	}

	void printP() {
		cout << "parent" << endl;
	}
private:
	int a;
};

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


void howToPrint(Parent* base) {
	base->printP();		// 父类成员函数
}

void howToPrint2(Parent &base) {
	base.printP();		// 父类成员函数
}

void 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);

	// 2
	// 让子类对象初始化父类对象
	// 子类就是一种特殊的父类
	Parent p3 = c1;
}
2 继承中对象模型
  1. 子类对象构造时，需要调用父类构造函数对其继承得来的成员进行初始化
  2. 子类对象析构时，需要调用父类析构函数对其继承得来的成员进行清理
3 先父类构造再子类构造，先子类析构再父类析构
// 先调用父类构造函数，再调用子类构造函数
// 析构顺序与构造相反
class Parent {
public:
	Parent(int a, int b) {
		this->a = a;
		this->b = b;
		cout << "parent构造函数" << endl;
	}
	/*Parent(const Parent& obj) {
		cout << "拷贝构造函数" << endl;
	}*/
	~Parent() {
		cout << "Parent析构函数" << endl;
	}
	void printP() {
		cout << "parent" << endl;
	}
private:
	int a;
	int b;
};

class Child :public Parent {
public:
	Child(int a, int b, int c):Parent(a,b) {
		this->c = c; 
		cout << "child构造函数" << endl;
	}
	~Child() {
		cout << "Child析构" << endl;
	}
	void printC() {
		cout << "child" << endl;
	}
private:
	int c;
};


void howToPrint(Parent* base) {
	base->printP();		// 父类成员函数
}

void howToPrint2(Parent &base) {
	base.printP();		// 父类成员函数
}

void objplay() {
	Child c1(1, 2, 3);
}

void main() {
	//Parent p(1, 2);
	objplay();
}

结果

parent构造函数
child构造函数
Child析构
Parent析构函数

4 继承和组合混搭

// 继承和组合混搭？
class Object {
public:
	Object(int a, int b) {
		this->a = a;
		this->b = b;
		cout << "Object构造函数" << " a " << a << " b " << b << endl;
	}
	~Object() {
		cout << "Object析构函数" << " a " << a << " b " << b << endl;
	}
protected:
	int a;
	int b;
};
class Parent:public Object {
public:
	Parent(char *p) :Object(1,2){
		this->p = p;
		cout << "Parent构造函数" << p << endl;
	}
	~Parent() {
		cout << "Parent析构函数" << p << endl;
	}
	void printP() {
		cout << "parent" << endl;
	}
protected:
	char* p;

};

class Child :public Parent {
public:
	Child(char *p) :Parent(p),obj1(3,4),obj2(5,6) {
		this->myp = p;
		cout << "child构造函数" << myp << endl;
	}
	~Child() {
		cout << "Child析构" << myp << endl;
	}
	void printC() {
		cout << "child" << endl;
	}
private:
	char* myp;
	Object obj1;
	Object obj2;
};


void objplay() {
	Child c1((char*)"继承测试");
}
void main() {
	objplay();
}

结果

Object构造函数 a 1 b 2
Parent构造函数继承测试
Object构造函数 a 3 b 4
Object构造函数 a 5 b 6
child构造函数继承测试
Child析构继承测试
Object析构函数 a 5 b 6
Object析构函数 a 3 b 4
Parent析构函数继承测试
Object析构函数 a 1 b 2

5 继承中的同名成员变量处理方法

class A {
public:
	int a;
	int b;
public:
	void get() {
		cout << "b: " << b << endl;
	}
	void print() {
		cout << "A" << endl;
	}
};

class B:public A {
public:
	int b;
	int c;
public:
	void get_child() {
		cout << "b: " << b << endl;
	}

	void print() {
		cout << "B" << endl;
	}
};

// 同名成员变量，同名成员函数
void main() {
	B b1;
	b1.b = 1;
	b1.get_child();

	b1.A::b = 100;	// 修改父类
	b1.B::b = 200;	// 修改子类 默认情况

	b1.get();

	b1.print();
	b1.A::print();
	b1.B::print();	// 默认情况
}

结果

b: 1
b: 100
B
A
B

6 static

// 继承中static
class A {
public:
	static int a;
	int b;
	A() {
		cout << "A构造函数" << endl;
	}
public:
	void get() {
		cout << "b: " << b << endl;
	}
	void print() {
		cout << "A" << endl;
	}
};

int A::a = 100;	// 不仅变量赋值，更重要告诉编译器分配内存，继承类中使用a，不然报错

class B :private A {
public:
	int b;
	int c;
public:
	void get_child() {
		cout << "b: " << b << endl;
		cout << "a: " << a << endl;
	}

	void print() {
		cout << "B" << endl;
	}
};

// 1 static遵守派生类访问控制规则
// 2 int A::a = 100;不仅变量赋值，更重要告诉编译器分配内存，继承类中使用a，不然报错
// 3 A类中添加构造函数
void main() {
	A a1;
	a1.print();
	B b1;
	b1.get_child();
	// b1.a = 200;
}

多继承

1 一个类有多个直接基类继承关系(B继承Base1,Base2)

// 多继承
class Base1 {
public:
	Base1(int b1) {
		this->b1 = b1;
	}
	void printB1() {
		cout << "b1:" << b1 << endl;
	}
private:
	int b1;
};

class Base2 {
public:
	Base2(int b2) {
		this->b2 = b2;
	}
	void printB2() {
		cout << "b2:" << b2 << endl;
	}
private:
	int b2;
};

class B :public Base1, public Base2 {
public:
	B(int b1, int b2, int c) :Base1(b1),Base2(b2){
		this->c = c;
	}
	void printC() {
		cout << "c:" << c << endl;
	}
private:
	int c;
};

void main() {
	B b(1, 2, 3);
	b.printB1();
	b.printB2();
	b.printC();
}

2 虚继承
class B
class B1
class B2
C 
// 虚继承
class B {
public:
	int b;
};

class B1:virtual public B {
public:
	int b1;
};

class B2:virtual public B{
public:
	int b2;
};

class C:public B1, public B2 {
public:
	int c;
};

void main() {
	C c1;
	c1.b1 = 100;
	c1.b2 = 200;
	c1.c = 300;

	c1.b = 500;	// b不明确，加virtual可以解决
}

不调用B中的b时，去掉virtual，调用两次B的构造函数

class B {
public:
	int b;
	B() {
		cout << "B构造函数" << endl;
	}
};
class B1 : public B {
public:
	int b1;
};

class B2 : public B {
public:
	int b2;
};

class C:public B1, public B2 {
public:
	int c;
};

void main() {
	C c1;
}

一个类有两个父类，且父类成员中有相同的名字
D1
E
D2 
class D1 {
public:
	int k;
};

class D2 {
public:
	int k;
};

class E :public D1, public D2 {

};

void main() {
	E e1;
	e1.D1::k = 10;
	e1.D2::k = 20;
}

virtual关键字会给类变量增加属性

class B {
public:
	int b;
	B() {
		cout << "B构造函数" << endl;
	}
};
class B1:virtual public B {
public:
	int b1;
};
class B2 : public B {
public:
	int b2;
};

class C:public B1, public B2 {
public:
	int c;
};

void main() {
	cout << sizeof(B) << endl;	//4
	cout << sizeof(B1) << endl;	//12 virtual关键字会给变量增加属性
	cout << sizeof(B2) << endl;	//8
}
HowDonew
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
js模拟类继承小例子
10-29
var p2 = new Child("xxx", 33); // ...其他方法调用 alert(p1 instanceof Child); // true alert(p1 instanceof Parent); // true ``` 总结，这个例子展示了如何利用JavaScript的原型链来实现类继承，包括构造...
Python语言基础：类的继承.pptx
05-05
Python 作为一门强大的动态类型语言，支持丰富的 OOP 特性，包括类的继承。类的继承允许我们创建一个新的类，这个新类可以保留原有类的属性和方法，同时可以添加新的功能或修改已有功能，从而实现代码的复用和模块化...
STAC33
02-26
STAC33是一个与JavaScript相关的项目，但没有给出更具体的项目描述或背景信息。不过，我们可以根据"STAC33"这一标题以及“JavaScript”标签来推测这可能是一个使用JavaScript技术构建的开源项目或者框架。JavaScript...
p33
03-31
标题中的“p33”可能是指某个项目、问题编号或者是课程的一部分，但没有具体的上下文，我们只能假设它与JavaScript相关的知识点有关。描述中同样只有“p33”，没有提供更多信息。然而，我们可以深入探讨JavaScript的...
C33
02-20
原型链是JavaScript继承的核心机制，通过`__proto__`属性或`Object.getPrototypeOf`方法访问。 6. **数组**：JavaScript的数组是一个特殊的对象，可以存储任意类型的数据。它提供了一些内置方法，如push、pop、...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1131
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++二叉搜索树
Jk_Mr的博客
07-20 1129
树结构是一种重要的数据结构。树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
C++笔试强训7
m0_74189279的博客
07-21 972
这意味着编译器会尝试将函数的代码直接插入到每个调用该函数的地方，而不是像通常那样进行函数调用（即，生成调用指令，跳转到函数代码，执行函数体，然后返回）。友元函数是在类外部定义的普通函数，它只能通过传入的参数（如果有的话）来访问类的成员，或者通过类的对象显式地访问（如果该函数设计为接受类的对象作为参数）。函数参数默认值又叫缺省参数，缺省参数必须从右向左开始缺省，必须连续给定缺省值，也就是说，从左到右，一旦遇到一个参数是缺省的，那么之后的参数也必须都是缺省的。指针是类成员函数特有的，用于指向调用该函数的对象。
商品信息管理系统(C语言)
zeyeqianli的博客
07-22 325
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
C++笔记3：基类指针delete子类对象的内存泄漏问题
subtitle_的博客
07-21 260
C++笔记3：基类指针delete子类对象的内存泄漏问题
2024年华为OD机试真题-虚拟游戏理财-C++-OD统一考试（C卷D卷）
热门推荐
面试高手的博客
07-21 4万+
现有一家Bank，它提供有若干理财产品m，风险及投资回报不同，你有N（元）进行投资，能接受的总风险值为X。第一行：产品数(取值范围[1, 20])，总投资额(整数，取值范围[1, 10000])，可接受的总风险(整数，取值范围[1, 200])投资第二项30个单位，第四项40个单位，总的投资风险为两项相加为4+6=10。第四行：最大投资额度序列，输入为整数，取值范围[1,10000]第二行：产品投资回报率序列，输入为整数，取值范围[1,60]第三行：产品风险值序列，输入为整数，取值范围[1,100]
C++中的模板函数和模板类
2302_81171591的博客
07-22 658
T1 ,classT2 ,... ,classTnclass类模板名//类内成员定义。
内网对抗-隧道技术篇&防火墙组策略&HTTP反向&SSH转发&出网穿透&CrossC2&解决方案
siu~
07-24 725
1、C2/C2上线-CrossC2插件-多系统平台支持 2、隧道技术篇-应用层-SSH协议-判断&封装&建立&穿透 3、隧道技术篇-应用层-HTTP协议-判断&封装&建立&穿透
C语言 打印菱形的程序（Program to print the Diamond Shape）
csdn_aspnet的专栏
07-22 2185
O(n*n)，因为我们正在遍历网格的行和列来打印空格 ' '和星号 '*'。给定一个数字n ，编写一个程序来打印一个有2n行的菱形。O(1)，不使用额外空间。
C++初学（1）
2301_79654372的博客
07-23 1132
c++c初学
【C++】详解 set | multiset
2301_80171004的博客
07-22 1283
本文探讨了C++标准模板库中set与multiset容器的使用，涵盖构造、插入、查找、删除等基本操作，并解析lower_bound、upper_bound及equal_range函数的高效区间搜索机制，为高效数据管理提供实战指南。
C语言 ——— 数组指针的定义 & 数组指针的使用
weixin_55341642的博客
07-22 440
之前有编写过关于指针数组的相关知识C语言 ——— 指针数组 & 指针数组模拟二维整型数组-CSDN博客指针数组顾名思义就是存放指针的数组那什么是数组指针呢？何为数组指针？整型指针——指向整型变量 的指针存放的是整型变量的地址字符指针——指向 字符变量 的指针存放的是字符变量的地址那么数组指针——指向 数组 的指针存放的是数组的地址// 数组指针代码解析：解析：int(*parr)[5] = &arr;取地址数组名（&arr），取出的是整个数组的大小。
扫雷-C语言
h_number_1的博客
07-24 1553
扫雷操作的基本实现-C语言
c++ 智能指针shared_ptr与make_shared
最新发布
Txwtech笛克特科
07-25 206
shared_ptr是C++11引入的一种智能指针，‌它允许多个shared_ptr实例共享同一个对象，‌通过引用计数来管理对象的生命周期。‌当最后一个持有对象的shared_ptr被销毁时，‌它会自动删除所指向的对象。‌这种智能指针主要用于解决资源管理问题，‌避免内存泄漏。make_shared是C++标准库中的一个函数，‌用于创建一个shared_ptr智能指针，‌它接受一个或多个参数来构造一个对象，‌并返回一个指向该对象的shared_ptr。类SerialModbus的成员指针。
python 封装继承多态
09-01
Python中的封装、继承和多态是面向对象编程的三个重要概念。封装是指将数据和方法封装在一个对象中，使得对象能够对外提供统一的接口，隐藏内部的实现细节。继承是指一个类可以继承另一个类的属性和方法，以达到代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值