[C++]继承

news2024/11/18 21:45:04

🥁作者： 华丞臧
📕​​​​专栏：【C++】
各位读者老爷如果觉得博主写的不错，请诸位多多支持(点赞+收藏+关注)。如果有错误的地方，欢迎在评论区指出。

推荐一款刷题网站 👉LeetCode

文章目录

  • 一、继承的概念及其定义
    • 1.1 继承的概念
    • 1.2 继承的定义
      • 1.2.1 定义格式
      • 1.2.2 继承关系和访问限定符
      • 1.2.3继承基类成员访问方式的变化
  • 二、基类和派生类对象赋值转换
  • 三、继承中的作用域
  • 四、派生类的默认成员函数
  • 五、继承--友元和静态成员
    • 5.1 继承与友元
    • 5.2 继承与static静态成员
  • 六、复杂的菱形继承及菱形虚拟继承
    • 6.1 单继承和多继承
    • 6.2 菱形继承
    • 6.3 虚拟继承解决数据冗余和二义性的原理
  • 七、继承的总结

一、继承的概念及其定义

1.1 继承的概念

继承机制是面向对象程序设计实现代码复用最重要的手段，继承允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称为派生类，原有类称为基类。派生类也称为子类，基类也称为父类。

继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们学习接触到的复用都是函数复用，继承是类设计层次的复用。
来看下面的例子：

class Person
{
public:
	void Print()
	{
		cout << "name:" << _name << endl;
 		cout << "age:" << _age << endl;
	}
	
protected:
 	string _name = "peter"; // 姓名
 	int _age = 18;  // 年龄
};


class Student : public Person
{
protected:
 	int _stuid; // 学号
};

class Teacher : public Person
{
protected:
 	int _jobid; // 工号
};

int main()
{
 	Student s;
 	Teacher t;
 	s.Print();
 	t.Print();
 	return 0;
}

继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。这里体现出了Student和Teacher复用了Person的成员。
在这里插入图片描述

调用Print函数可以看到函数的复用：
在这里插入图片描述

1.2 继承的定义

1.2.1 定义格式

下面代码中，Student是子类，也称为派生类；Person是父类，也称为基类；其中public表示继承方式。
在这里插入图片描述

1.2.2 继承关系和访问限定符

在这里插入图片描述

1.2.3继承基类成员访问方式的变化

类成员/继承方式public继承protected继承private继承
基类的public成员派生类的public成员派生类的protected成员派生类的private成员
基类的protected成员派生类的protected成员派生类的protected成员派生类的private成员
基类的private成员在派生类中不可见在派生类中不可见在派生类中不可见
// 实例演示三种继承关系下基类成员的各类型成员访问关系的变化  
class Person
{
public :
 	void Print ()
 	{
 		cout<<_name <<endl;
 	}
protected :
	// public/protected继承在子类中可见，private继承在子类中不可见
 	string _name ; 
private :
 	int _age ; // 在子类中不可见，但是被继承了
};

//class Student : protected Person
//class Student : private Person
class Student : public Person
{
protected :
 	int _stunum ; // 学号
};

总结：

  1. 基类private成员在子类中无论什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
  2. 基类private成员在派生类中是不能被访问的，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected，可以看出保护成员限定符就是因继承才出现的。
  3. 基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。
  4. 使用关键字class的默认继承方式是private，使用struct默认继承方式是public，不过最好显式的写出继承方式。
  5. 在实际运用中一般使用public继承，很少使用protected/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。（继承本就是为了复用，私有代码就不能服用了）

二、基类和派生类对象赋值转换

  • 派生类对象可以赋值给基类的对象、基类的指针、基类的引用。 在派生类对象赋值转换时，有个形象的说法叫切片或者切割，即把派生类中的父类那部分切来赋值过去。
  • 基类对象不能赋值给派生类对象。
  • 基类的指针或者引用可以通过强制类型转换赋值个派生类的指针或者引用；但是必须是基类的指针且指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI(RunTime Type Information)的dynamic_cast 来进行识别后进行安全转换。（这里只需先了解一下）

在这里插入图片描述

class Person
{
public:
    Person(string name = "", int age = 0)
    {
        _name = name;
        _age = age;
    }
        
    void Print()
    {
        cout << _name << endl;
    }

protected:
    string _name; // 姓名
    int _age; // 年龄
};

class Student : public Person
{
public:
    Student(int stunum = 0)
        :Person()
    {
        _stunum = stunum;
    }

    void Show()
    {
        cout << _name << endl;
        cout << _age << endl;
        cout << _stunum << endl;
    }

protected:
    int _stunum; // 学号
};


int main()
{
    Student s;
    s.Show();

    Person* per = &s;   //发生切片
    //Person per = s;
    //Person& per = s;
    per->Print();

	 // 3.基类的指针可以通过强制类型转换赋值给派生类的指针
    per = &s;
    Student* ps1 = (Student*)per; // 这种情况转换时可以的。

	per = &pobj;
 	Student* ps2 = (Student*)per; // 这种情况转换时虽然可以，但是会存在越界访问的问题
    return 0;
}

在这里插入图片描述

三、继承中的作用域

  1. 在继承体系中基类和派生类都有独立的作用域。
  2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况称为隐藏，也叫重定义。
  3. 注意：如果是成员函数的隐藏，只需要函数名相同就可以构成隐藏。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
  4. 实际中，在继承体系里最好不要定义同名成员。
class Person
{
protected:
	string _name = "小李子"; // 姓名
	int _num = 111;   // 身份证号
};

class Student : public Person
{
public:
	void Print()
	{
		cout << " 姓名:" << _name << endl;
		cout << " 身份证号:" << Person::_num << endl;
		cout << " 学号:" << _num << endl;
	}
protected:
	int _num = 999; // 学号
};

Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是非常容易混淆；子类中必须显示访问才能使用隐藏成员。
在这里插入图片描述
再来看看成员函数的隐藏：

class A
{
public:
	void fun()
	{
		cout << "func()" << endl;
	}
};

class B : public A
{
public:
	void fun(int i)
	{
		A::fun();
		cout << "func(int i)->" << i << endl;
	}
};

void Test()
{
	B b;
	b.fun(10);
};

B中的fun和A中的fun不是构成重载，因为不是在同一作用域；B中的fun和A中的fun构成隐藏，成员函数满足函数名相同就构成隐藏。
在这里插入图片描述

四、派生类的默认成员函数

6个默认成员函数，“默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类中，这几个成员函数是如何生成的呢？

  1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
  2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
  3. 派生类的operator=必须要调用基类的operator=完成基类的复制。
  4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
  5. 派生类对象初始化先调用基类构造再调派生类构造。
  6. 派生类对象析构清理先调用派生类析构再调基类的析构。
  7. 因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同(暂时先了解)。那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。

在这里插入图片描述
在这里插入图片描述
通过上述说明，我们能总结一下几点：

  • 派生类当中的基类部分是使用自己的构造函数初始化，子类调用其默认构造函数，没有默认构造就必须显示调用父类构造；对基类数据的操作一般调用基类的成员函数。
  • 派生类的模型是基类在前，派生类的成员在后，且父类先构造后析构，子类后构造先析构；这是由于栈的特性所决定的，栈是先入后出的。
class Person
{
public:
	Person(const char* name = "peter")
		: _name(name)
	{
		cout << "Person()" << endl;
	}

	Person(const Person& p)
		: _name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}

	Person& operator=(const Person& p)
	{
		cout << "Person operator=(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;

		return *this;
	}

	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name; // 姓名
};

class Student : public Person
{
public:
	Student(const char* name, int num)
		: Person(name)
		, _num(num)
	{
		cout << "Student()" << endl;
	}

	Student(const Student& s)
		: Person(s)
		, _num(s._num)
	{
		cout << "Student(const Student& s)" << endl;
	}

	Student& operator = (const Student& s)
	{
		cout << "Student& operator= (const Student& s)" << endl;
		if (this != &s)
		{
			Person::operator =(s);
			_num = s._num;
		}
		return *this;
	}

	~Student()
	{
		cout << _num;
		cout << ":~Student()" << endl;
	}

protected:
	int _num; //学号
};
void Test()
{
	Student s1("jack", 18);
	Student s2(s1);
	Student s3("rose", 17);
	s1 = s3;
}

int main()
{
	Test();
	return 0;
}

在这里插入图片描述

五、继承–友元和静态成员

5.1 继承与友元

友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员 。

class Student;  //声明，Display函数向上查找Student
class Person
{
public:
	friend void Display(const Person& p, const Student& s);
protected:
	string _name; // 姓名
};
class Student : public Person
{
protected:
	int _stuNum; // 学号
};

void Display(const Person& p, const Student& s)
{
	cout << p._name << endl;
	cout << s._stuNum << endl;
}
void test()
{
	Person p;
	Student s;
	Display(p, s);
}

程序无法运行成功，Student成员变量_stuNum是保护成员，在基类Person的友元中是无法被访问的。
在这里插入图片描述

5.2 继承与static静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例 。

六、复杂的菱形继承及菱形虚拟继承

6.1 单继承和多继承

一个子类只有一个直接父类时称这个继承关系为单继承。

前面我们看到的都是单继承，单继承并不是说只有两个类，而是类之间的基础关系是线性的，即一个父亲只有一个儿子，如下图：

在这里插入图片描述

一个子类有两个或两个以上直接父类时称这个继承关系为多继承。

在这里插入图片描述

6.2 菱形继承

菱形继承是多继承的一种特殊情况。

在这里插入图片描述

class Person
{
protected:
	string _name; // 姓名
};

class Student : public Person
{
protected:
	int _stuNum; // 学号
};

class Teacher : public Person
{
protected:
	int _id; // 职工编号
};

class Assistant : public Student, public Teacher

{
protected:
	string _majorCourse;  // 主修课程
};

通过监视窗口观察到，子类对象中存在两份Person数据，如下图：
在这里插入图片描述

在C++中支持多继承，因此就会存在菱形继承；菱形继承就是子类继承的多个父类当中继承了相同的类。这里就存在一个问题：当子类继承的多个父类中继承了相同的类，那么就子类应该继承那一个呢，还是说两个继承。

从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题，在Assistant的对象中Person成员会有两份。

在这里插入图片描述
C++提供了virtual关键字，用来定义虚拟函数和虚继承；虚拟继承可以解决菱形继承的二义性和数据冗余问题。如上面的继承关系，在Student和Teacher继承Person时使用虚拟继承即可解决问题。注意：虚拟继承不要在其他地方去使用。

class Person
{
public:
	string _name; // 姓名
};
class Student : virtual public Person //虚拟继承
{
protected:
	int _num; //学号
};
class Teacher : virtual public Person
{
protected:
	int _id; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; // 主修课程
};

6.3 虚拟继承解决数据冗余和二义性的原理

为了研究虚拟继承原理，我们给出了一个简化的菱形继承继承体系，再借助内存窗口观察对象成员的模型。

class A
{
public:
	int _a;
};

class B : public A
// class B : virtual public A
{
public:
	int _b;
};

class C : public A
	// class C : virtual public A
{
public:
	int _c;
};

class D : public B, public C
{
public:
	int _d;
};

int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
	return 0;
}

下图是菱形继承的内存对象成员模型，可以看到数据冗余：
在这里插入图片描述

下图是菱形虚拟继承的内存对象成员模型：这里可以分析出D对象中将A放到的了对象组成的最下面，这个A同时属于B和C，那么B和C如何去找到公共的A呢？这里是通过了B和C的两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A。
在这里插入图片描述

B和C通过对象中的虚基表指针找到偏移量，再通过偏移量找到A。
在这里插入图片描述

下面是上面的Person关系菱形虚拟继承的原理解释：
在这里插入图片描述

七、继承的总结

  1. C++语法复杂，多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承，否则在复杂度及性能上都有问题。

  2. 继承和组合

    • public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
    • 组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。
    • 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
    • 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
    • 实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。
// Car和BMW Car和Benz构成is-a的关系
class Car
{
protected:
   string _colour = "白色"; // 颜色
   string _num = "陕ABIT00"; // 车牌号
};
   
class BMW : public Car
{
public:
   void Drive() {cout << "好开-操控" << endl;}
};
   
class Benz : public Car
{
public:
   void Drive() {cout << "好坐-舒适" << endl;}
};
   
// Tire和Car构成has-a的关系
   
class Tire
{
protected:
      string _brand = "Michelin";  // 品牌
      size_t _size = 17;         // 尺寸
   
};
   
class Car
{
protected:
   string _colour = "白色"; // 颜色
   string _num = "陕ABIT00"; // 车牌号
    Tire _t; // 轮胎
};

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/374789.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

C/C++每日一练(20230227)

C/C++每日一练(20230227)

目录 1. 按要求排序数组 ★ 2. Z 字形变换 ★★ 3. 下一个排列 ★★ 1. 按要求排序数组 给你一个整数数组 arr 。请你将数组中的元素按照其二进制表示中&#xff0c;数字 1 的数目升序排序。 如果存在多个数字二进制中 1 的数目相同&#xff0c;则必须将它们按照数值大小…
阅读更多...
新型智慧城市顶层规划及智慧应用综合解决方案

新型智慧城市顶层规划及智慧应用综合解决方案

【版权声明】本资料来源网络&#xff0c;知识分享&#xff0c;仅供个人学习&#xff0c;请勿商用。【侵删致歉】如有侵权请联系小编&#xff0c;将在收到信息后第一时间删除&#xff01;完整资料领取见文末&#xff0c;部分资料内容&#xff1a; 业务需求分析系统功能需求分析 …
阅读更多...
一文了解虚拟人主播

一文了解虚拟人主播

这两年&#xff0c;相信很多人都能在抖音、快手、微视等平台看到虚拟人主播的视频&#xff0c;形象逼真&#xff0c;表情动作自然&#xff0c;语言流畅&#xff0c;乍一看&#xff0c;就是一位真人&#xff01;那为什么会有这么多人或者企业选择用虚拟人来做主播呢&#xff1f;…
阅读更多...
12万字数字政府县级智慧政务云平台建设方案WORD

12万字数字政府县级智慧政务云平台建设方案WORD

【版权声明】本资料来源网络&#xff0c;知识分享&#xff0c;仅供个人学习&#xff0c;请勿商用。【侵删致歉】如有侵权请联系小编&#xff0c;将在收到信息后第一时间删除&#xff01;完整资料领取见文末&#xff0c;部分资料内容&#xff1a; 1.1 总体方案设计 云平台是云计…
阅读更多...
评论对软件品牌很重要：有效地生成和管理评论

评论对软件品牌很重要：有效地生成和管理评论

评论已成为几乎所有产品类别购买过程中的重要组成部分。 客户评论数据告诉我们&#xff0c;92% 的消费者使用在线评论来指导他们的大部分普通购买决策&#xff0c;软件也不例外。B2B 买家在做出购买决定之前会进行大量研究。 为什么评论对软件品牌很重要 B2B 买家特别希望听到已…
阅读更多...
对IDEA中断点Suspend 属性理解

对IDEA中断点Suspend 属性理解

suspend的类型分为 1、ALL&#xff1a;有线程进入该断点时&#xff0c;暂停所有线程 2、Thread&#xff1a;有线程进入该断点时&#xff0c;只暂停该线程 讨论下不同线程在同一时间段都遇到断点时&#xff0c;idea的处理方法。假如在执行时间上&#xff0c;thread1会先进入断…
阅读更多...
Android实现连线题效果

Android实现连线题效果

效果图全部正确&#xff1a;有对有错&#xff1a;结果展示&#xff0c;纯黑色&#xff1a;支持图片&#xff1a;实现思路仔细分析可以发现&#xff0c;连线题的布局可以分为两部分&#xff0c;一个是左右两列矩形&#xff0c;另一个是他们之间的连线。每个矩形的宽高都一样&…
阅读更多...
并非从0开始的c++ day8

并非从0开始的c++ day8

并非从0开始的c day8结构体结构体嵌套二级指针练习结构体偏移量内存对齐内存对齐的原因如何内存对齐文件操作文件的概念流的概念文本流二进制流文件缓冲区文件打开关闭文件关闭fclose文件读写函数回顾按格式化读写文件文件读写注意事项结构体 结构体嵌套二级指针练习 需求&am…
阅读更多...
Delphi 中 FireDAC 数据库连接（定义连接）

Delphi 中 FireDAC 数据库连接（定义连接）

一、定义连接&#xff08;FireDAC&#xff09;概述连接定义是一组参数&#xff0c;它定义了如何使用特定的FireDAC驱动将一个应用程序连接到DBMS。它相当于一个BDE别名、ADO UDL&#xff08;存储的OLEDB连接字符串&#xff09;或ODBC数据源名称&#xff08;DSN&#xff09;。关…
阅读更多...
Vue下载安装步骤的详细教程(亲测有效) 1

Vue下载安装步骤的详细教程(亲测有效) 1

目录 一、【准备工作】nodejs下载安装(npm环境) 1 下载安装nodejs 2 查看环境变量是否添加成功 3、验证是否安装成功 4、修改模块下载位置 &#xff08;1&#xff09;查看npm默认存放位置 &#xff08;2&#xff09;在 nodejs 安装目录下&#xff0c;创建 “node_global…
阅读更多...
Spring中AOP的使用以及举例

Spring中AOP的使用以及举例

1.AOP的简介 1.1 什么是AOP? AOP(Aspect Oriented Programming)面向切面编程&#xff0c;一种编程范式&#xff0c;指导开发者如何组织程序结构。 OOP(Object Oriented Programming)面向对象编程 我们都知道OOP是一种编程思想&#xff0c;那么AOP也是一种编程思想&#xf…
阅读更多...
模块电源DC/DC直流隔离升压稳压HRB系列5v12v24v转50v100v110v200v220v250v300v400v

模块电源DC/DC直流隔离升压稳压HRB系列5v12v24v转50v100v110v200v220v250v300v400v

特点效率高达80%以上1*1英寸标准封装单电压输出稳压输出工作温度: -40℃~85℃阻燃封装&#xff0c;满足UL94-V0 要求温度特性好可直接焊在PCB 上应用HRB 0.2~10W 系列模块电源是一种DC-DC升压变换器。该模块电源的输入电压分为&#xff1a;4.5~9V、9~18V、及18~36VDC标准&#…
阅读更多...
中小企业数字化自动化转型的方法

中小企业数字化自动化转型的方法

自动化是我们国内未来的趋势。智能制造的实现主要依托两个基础能力&#xff0c;一个是工业制造技术&#xff0c;另一个就是工业互联网。而自动化是工业制造技术的重要组成部分&#xff0c;是高度智能制造装备的核心部分&#xff0c;与承接着制造单元与工业互联网这两大核心。懂…
阅读更多...
Polkadot 基础

Polkadot 基础

Polkadot Polkadot联合并保护了一个不断增长的专业区块链生态系统&#xff0c;称为parachains。Polkadot上的应用程序和服务可以安全地跨链通信&#xff0c;形成真正可互操作的去中心化网络的基础。 真正的互操作性 Polkadot支持跨区块链传输任何类型的数据或资产&#xff0c;…
阅读更多...
基于51单片机和proteus的智能调速风扇设计

基于51单片机和proteus的智能调速风扇设计

此智能风扇是基于51单片机和proteus的仿真设计&#xff0c;功能如下&#xff1a; 1. Timer0 PWM控制电机转速 2. DHT11采集温湿度 3. LCD1602显示温湿度及电机状态 4. 按键控制电机加减速启停等 5. 串口控制电机加减速启停等 功能框图如下&#xff1a; Proteus仿真界面如下…
阅读更多...
EasyExcel使用与详细说明，EasyExcel工具类

EasyExcel使用与详细说明，EasyExcel工具类

文章目录1.Apache POI1.1 学习使用成本较高1.2 POI的内存消耗较大1.3 特点2. 初识EasyExcel2.1 重写了POI对07版Excel的解析2.2 特点3.快速入门3.1 导入依赖坐标3.2 最简单的读3.2.1 需求、准备工作3.2.2 编写导出数据的实体3.2.3 读取Excel的监听器&#xff0c;用于处理读取产…
阅读更多...
rabbitmq在linux系统下安装步骤

rabbitmq在linux系统下安装步骤

第一步&#xff1a;登录官网 官网地址&#xff1a;www.rabbitmq.com,点击Get Started 重要信息&#xff1a;RabbitMQ Tutorials手册&#xff0c;描述了工作模式 第二步&#xff1a;点击Download Installation下载 重要信息&#xff1a;rabbitmq是用erlang语言开发的&#xff0…
阅读更多...
C++类与对象（上）【详析】

C++类与对象（上）【详析】

目录1.面向过程和面向对象初步认识2.类的引入3.类的定义4.类的访问限定符及封装4.1访问限定符4.2封装5.类的作用域6.类的实例化7.类对象模型7.1 如何计算类对象的大小8.this关键字如果说我们对C的初步认识&#xff0c;是觉得C是对C语言不足之处的进行修补&#xff0c;在认识完类…
阅读更多...
Vue-router 3.x 版本中路由守卫钩子函数解析

Vue-router 3.x 版本中路由守卫钩子函数解析

目录概念&#xff1a;分类全局前置守卫 &#xff08; router.beforeEach &#xff09;全局解析守卫 &#xff08; router.beforeResolve &#xff09;全局后置守卫 &#xff08; router.afterEach &#xff09;路由独享守卫 &#xff08; beforeEnter &#xff09;组件内的守卫…
阅读更多...
有哪些办法可以降低 Redis 的内存使用情况

有哪些办法可以降低 Redis 的内存使用情况

在逛知乎时&#xff0c;看到这样一个问题&#xff0c;觉得挺不错的&#xff0c;将自己个人的见解分享给大家。问题是:有哪些办法可以降低 Redis 的内存使用情况&#xff1f;个人也对Redis做了一个比较全面的问题汇总&#xff0c;希望对大家有所帮助。Redis面试题汇总要降低内存…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023