C++必修：深入理解继承与虚继承

✨✨ 欢迎大家来到贝蒂大讲堂✨✨

🎈🎈养成好习惯，先赞后看哦~🎈🎈

所属专栏：C++学习
贝蒂的主页：Betty’s blog

1. 继承的概念与定义

1.1. 继承的概念

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，而继承是类设计层次的复用。

比如说一个人，他具有身高，年龄，姓名等个人信息，然后利用这些信息我们可以定义一个Person类。而当我们想定义一个学生Student类时，学生首先肯定是一个人，所以这时候我们可以复用Person类。但是学生除了具备一个人的基本信息外，还具有学号，专业等特有信息，这时候我们就需要在Student类中继续添加。

img

1.2. 继承的定义

继承的用法十分简单，如下：

class derived - class : access - specifier base - class

  • derived-class：被称为父类，也叫作基类。
  • access-specifier：是继承方式限定符，分为public，protected，private继承。
  • **base-class：**被称为子类，也叫作派生类。

下面是一个Student类继承Person类的具体实例：

class Person
{
public:
	void Print()
	{
		cout << _height << endl;
		cout << _age << endl;
		cout << _name << endl;
	}
protected:
	double _height = 1.73;//身高
	int _age = 18 ;//年龄
	string _name ="betty";//姓名
};
class Student:public Person
{
private:
	int _stuid = 123456;//学号
	int _grade = 10;//年级
};

img

从上图就可以看出Student类继承了Person类的成员与函数。

当然不同继承方式的继承效果也就不同：

类成员/继承方式public继承protected继承private继承
基类的public成员派生类的public成员派生类的protected成员派生类的private成员
基类的protected成员派生类的protected成员派生类的protected成员派生类的private成员
基类的private成员在派生类中不可见在派生类中不可见在派生类中不可见
  • 不可见是指基类的私有成员虽然被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
class Person
{
private:
	void Print()
	{
		cout << _height << endl;
		cout << _age << endl;
		cout << _name << endl;
	}
	double _height = 1.73;//身高
	int _age = 18 ;//年龄
	string _name ="betty";//姓名
};

class Student :public Person//默认为public继承
{
public:
	void Print()//类里不可访问
	{
		cout << _height << endl;
		cout << _age << endl;
		cout << _name << endl;
	}
private:
	int _stuid = 123456;//学号
	int _grade = 10;//年级
};

int main()
{
	Student s;
	s.Print();//类外不可访问
	return 0;
}

img

通过上表我们也可以总结出以下规律：

  1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私 有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面 都不能去访问它。
  2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在 派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
  3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他 成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected>private。
  4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过 最好显示的写出继承方式。
  5. 在实际运用中一般使用都是public继承，几乎很少使用protetced / private继承，也不提倡 使用protetced / private继承，因为protetced / private继承下来的成员都只能在派生类的类里 面使用，实际中扩展维护性不强。
  • 特别需要注意的是：当我们不显示声明派生类的继承方式时，编译器会采用默认继承方式。其中关键字class时默认的继承方式是private，struct时默认的继承方式是public。
class Student:Person//默认为private继承
struct Student:Person//默认为public继承

2. 基类与派生类的赋值转换

我们在前面的学习知道相近类型之间是能够赋值，因为他们之间会发生隐式类型转换。

	int a = 1;
	//a产生一个double的临时变量赋值给b
	double b = a;
	//这个临时变量具有常性
	double& c = a;//error
	//要用const引用，否则会引起权限的放大
	const double& d = a;

那么基类与派生类直接是否也遵循这个转换规则呢，接下来让我们以Person类与Student类来验证一下吧。

2.1. 派生类对象赋值给基类对象

派生类对象是可以基类对象的，因为派生类对象本就存在基类成员。相反，基类成员就无法赋值给派生类成员，因为有些成员派生类有，而基类没有。

	Person p;
	Student s;
	p = s;//ok
    s = p;//error

img

2.2. 派生类对象的引用赋值给基类对象

派生类对象的引用赋值能够给基类对象，其中引用不许需要const，证明其赋值之间并没有发生隐式类型转换，产生临时对象。

	Student s;
	Person& rp = s;//ok

img

2.3. 派生类对象的指针赋值给基类对象

派生类对象的指针能够赋值给基类对象，这种情况与引用十分类似。

	Student s;
	Person* pp = &s;//ok

img

2.4. 基类指针赋值给派生类指针

基类指针能够通过强转赋值给派生类指针，但是也可能造成越界访问。

	Person p;
	Student *sp = (Student*) & p;//ok

最后总结出基类与派生类的赋值转换遵循以下规则：

  1. 派生类对象可以赋值给基类的对象 ，基类的指针，基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。
  2. 基类对象不能赋值给派生类对象。
  3. 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI，dynamic_cast 来进行识别后进行安全转换。

3. 继承的作用域

在继承体系中基类和派生类都有独立的作用域。子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）

3.1. 同名变量

让我们先看看下面这段代码吧，基类与派生类都有同名的变量_height。

class Person
{
protected:
	double _height = 1.73;//身高
	int _age = 18 ;//年龄
	string _name ="betty";//姓名
};

class Student :public Person
{
public:
	void Print()//隐藏
	{
		cout << _height << endl;
		cout << _age << endl;
		cout << _name << endl;
	}
private:
	double _height = 1.67;//身高
	int _stuid = 123456;//学号
	int _grade = 10;//年级
};
int main()
{
	Student s;
	s.Print();
	return 0;
}

img

如果想打印派生类的_height需要使用域作用限定符：

	void Print()//隐藏
	{
		cout <<Person:: _height << endl;
		cout << _age << endl;
		cout << _name << endl;
	}

img

3.2. 同名函数

如果基类与派生类存在同名函数，那又是什么情况呢？

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

首先第一个问题，两个fun函数之间是函数重载还是隐藏的关系？当然是隐藏关系，因为函数重载针对的是同一个作用域的函数，而基类与派生类直接作用域不同。

在隐藏关系中，同名函数默认调用的当前作用域的函数，如果想调用其他作用域的函数，则需要使用域作用限定符。

img

	B b;
	b.A::fun();//访问A中的fun函数

4. 派生类的默认成员函数

我们知道在类中有6个默认成员函数，如果不显示定义，编译会自动生成。那么如果在派生类中，这几个成员函数是如何生成的呢？

img

  1. 派生类对象在调用构造函数时会先调用基类的构造函数，再调用派生类的构造函数。调用析构函数时会先调用派生类的析构函数，再调用基类的析构函数。
class Person
{
public:
	Person(const char* name = "peter")
		: _name(name)
	{
		cout << "Person()" << endl;
	}
	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name; // 姓名
};
class Student : public Person
{
public:
	Student()
	{
		cout << "Student()" << endl;
	}
	~Student()
	{
		cout << "~Student()" << endl;
	}
protected:
	int _num; //学号
};

int main()
{
	Student s;
	return 0;
}

img

  1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
class Person
{
public:
	Person(const char* name)//没有默认构造
		: _name(name)
	{
	}
	Person(const Person& p)
		: _name(p._name)
	{
	}
protected:
	string _name; // 姓名
};
class Student : public Person
{
public:
	Student(int num, const char* name)
		:_num(num)
		//,_name(name) error
		, Person(name)//正确初始化
	{
		;
	}
protected:
	int _num; //学号
};
  1. 编译器会对派生类与基类的析构函数名进行特殊处理，都会被处理成destrutor()，所以派生类与基类的析构函数构成隐藏关系。
	Person(const char* name)//没有默认构造
		: _name(name)
	{
		cout << "Person()" << endl;
	}
	~Person()//析构
	{
		cout << "~Person()" << endl;
	}
	Student(int num, const char* name)//构造
		:_num(num)
		//,_name(name) error
		, Person(name)//正确初始化
	{
		cout << "Student()" << endl;
	}
	~Student()
	{
		//因为构成覆盖关系，所以指定域作用限定符
		Person::~Person();
		cout << "~Student()" << endl;
	}

img

但是为什么Person的析构函数会多调用一次呢？因为编译器为了保证基类的析构最后调用，所以在调用派生类析构函数之后会自动调用基类的构造函数。所以为了保证调用的正确顺序，派生类的析构函数我们不需要显示定义。

  1. 拷贝构造与赋值重载必须调用基类的拷贝构造与赋值重载完成对基类的初始化。
//拷贝构造
Person(const Person& p)
	: _name(p._name)
{
}
//赋值重载
Person& operator=(const Person& p)
{
	if (this != &p)
		_name = p._name;

	return *this;
}
Student(const Student& s)//拷贝构造
	:_num(s._num)
	, Person(s)//派生类赋值给基类
{
	;
}
//赋值重载
Student& operator = (const Student& s)
{
	if (this != &s)
	{
		//加域作用限定，否则发生死循环
		Person::operator =(s);
		_num = s._num;
	}
	return *this;
}
  • 派生类赋值重载调用基类赋值重载时记得加域作用限定符，否则就会发生死循环。

5. 继承中的友元与静态成员

5.1. 继承中的友元

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

class 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;
}
int main()
{
	Person p;
	Student s;
	Display(p, s);
	return 0;
}

img

5.2. 继承中的静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员，静态成员被所有类对象包括起子类和子类的子类共享。无论派生出多少个子类，都只有一个static成员实例 。

我们可以通过下面这段代码验证：

class Person
{
public:
	Person() { ++_count; }
	string _name; // 姓名
	static int _count; // 统计人的个数。
};
int Person::_count = 0;//静态成员初始化
class Student : public Person
{
protected:
	int _stuNum; // 学号
};
class Graduate : public Student
{
protected:
	string _seminarCourse; // 研究科目
};
int main()
{
	Person p;
	Student s;
	Graduate g;
	cout << &(p._name) << endl;
	cout << &(s._name) << endl;
	cout << &(g._name) << endl;
	cout << &(p._count) << endl;
	cout << &(s._count) << endl;
	cout << &(g._count) << endl;
	return 0;
}

img

从上图我们就可以看出非静态成员在不同基类与派生类中地址不同，这就说明他们在不同类是独立存在的。而非静态成员却恰恰相反，地址相同，证明基类与派生类都是用同一个静态成员。

6. 菱形继承与虚拟继承

6.1. 菱形继承

  1. 单继承：一个子类只有一个直接父类的继承关系为单继承。

img

  1. 多继承：一个子类有两个或以上直接父类。

img

  1. 菱形继承：就是继承关系近似呈一个菱形形状，如下图：

img

菱形继承会造成两个问题：数据冗余和二义性。

class Person
{
public:
	string _name; // 姓名
};
class Student : public Person
{
protected:
	int _num; //学号
};
class Teacher : public Person
{
protected:
	int _id; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; // 主修课程
};
void Test()
{
	Assistant a;
	// a._name = "peter"; 这样会产生二义性无法明确知道访问的是哪一个类
	// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";
}

img

6.2. 虚拟继承

为了解决数据二义性与冗余的问题，C++引入虚拟继承。虚拟继承用法十分简单，直接在继承前加上一个关键字：virtual。

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; // 主修课程
};
void Test()
{
	Assistant a;
	 a._name = "peter"; 
}

img

7. 虚拟继承的原理

为了更加深入了解虚拟继承，接下来我们将探究一下虚拟继承具体是如何实现的

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;
}
  • 菱形继承：

img

  • 菱形虚拟继承

img

我们通过内存观察知道，原先数据冗余的部分存放成了一个地址，而数据冗余的a则存放在了最下面。那么这个地址又是什么呢？

img

img

这里地址指向的空间存放了一个数字，这个数字我们称为**偏移量。**通过这个偏移量我们就可以找到虚继承下来的共有数据的位置。

img

通过上述分析我们明白在虚继承中，为了解决数据冗余和二义性的问题，派生类并不会直接存储基类，而是将基类放在一个公有的位置，然后在派生类中存放一个指向这公有位置偏移量的指针。这个指针我们将其称为虚基表指针，而这个偏移量存储位置我们将其称为虚基表。而每次通过派生类访问基类数据时，首先通过虚基表指针得到偏移量，然后再间接访问基类数据。

img

8. 继承与组合

8.1. is-a关系

public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。基类的内部细节对子类可见。

class A
{};

class B : public A
{};

继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为**白箱复用(white - box reuse)。**术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。

8.2. has-a关系

组合是一种has - a的关系。假设B组合了A，每个B对象中都有一个A对象。

class A
{};

class B
{
	A _aa;
};

对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black - box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。

所以一般推荐优先使用对象组合，而不是类继承 。

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

每日一题——Python实现PAT乙级1018 锤子剪刀布（举一反三+思想解读+逐步优化）五千字好文

每日一题——Python实现PAT乙级1018 锤子剪刀布（举一反三+思想解读+逐步优化）五千字好文

一个认为一切根源都是“自己不够强”的INTJ 个人主页&#xff1a;用哲学编程-CSDN博客专栏&#xff1a;每日一题——举一反三Python编程学习Python内置函数 Python-3.12.0文档解读 目录 我的写法 代码结构与逻辑 时间复杂度分析 空间复杂度分析 代码优化建议 总结 我…
阅读更多...
【java计算机毕设】美容院管理系统 项目源代码MySQL springboot vue html maven+文档 前后端可分离也可不分离

【java计算机毕设】美容院管理系统 项目源代码MySQL springboot vue html maven+文档 前后端可分离也可不分离

目录 1项目功能 2项目介绍 3项目地址 1项目功能 【java计算机毕设】美容院管理系统 项目源代码MySQL springboot vue html maven文档 前后端可分离也可不分离 2项目介绍 系统功能&#xff1a; 美容院管理系统包括管理员、用户俩种角色。 管理员功能包括个人中心模块用于修改…
阅读更多...
“论单元测试方法及应用”精选范文，软考高级论文，系统架构设计师论文

“论单元测试方法及应用”精选范文，软考高级论文，系统架构设计师论文

论文真题 1、概要叙述你参与管理和开发的软件项目,以吸你所担的主要工作。 2、结给你参与管理和开发的软件项目&#xff0c;简要叙述单元测试中静态测试和动态测试方法的基本内容。 3、结给你惨与管理和研发的软件项目,体阐述在玩测试过程中,如何确定白盒测试的覆盖标准,及如…
阅读更多...
【C语言】sizeof 关键字

【C语言】sizeof 关键字

在C语言中&#xff0c;sizeof运算符用于计算数据类型或变量的大小&#xff08;以字节为单位&#xff09;。sizeof是一个编译时运算符&#xff0c;它在编译阶段确定类型或变量的大小&#xff0c;而不是在运行时。 基本用法 sizeof可以用于计算基本数据类型、数组、结构体以及指…
阅读更多...
银湖资本与UIBE达成战略合作，共同推动股权投资领域发展

银湖资本与UIBE达成战略合作，共同推动股权投资领域发展

近日&#xff0c;全球知名私募股权投资公司银湖资本&#xff08;Silver Lake Partners&#xff09;宣布与对外经济贸易大学&#xff08;UIBE&#xff09;校友发起的“UIBE阿波罗股权投资俱乐部”达成战略合作协议。此举不仅标志着双方在股权投资领域的深度合作&#xff0c;也为…
阅读更多...
LVS-DR负载均衡

LVS-DR负载均衡

LVS-DR负载均衡 LVS—DR工作模式 原理 客户端访问调度器的VIP地址&#xff0c;在路由器上应该设置VIP跟调度器的一对一的映射关系&#xff0c;调度器根据调度算法将该请求“调度“到后端真实服务器&#xff0c;真实服务器处理完毕后直接将处理后的应答报文发送给路由器&#xf…
阅读更多...
使用 draw.io 画图

使用 draw.io 画图

尽管我非常喜欢 wps 和 office 的 ppt 画图&#xff0c;但因为它们对数学公式的糟糕支持&#xff0c;我不得不另外寻找一个画图工具。当然我也同样很喜欢 visio &#xff0c;但同样的&#xff0c;它对数学公式的支持糟糕&#xff0c;另外&#xff0c;最为重要的是&#xff0c;v…
阅读更多...
不同的llm推理框架

不同的llm推理框架

vLLM适用于大批量Prompt输入&#xff0c;并对推理速度要求比较高的场景。 实际应用场景中&#xff0c;TensorRT-LLM通常与Triton Inference Server结合起来使用&#xff0c;NVIDIA官方能够提供更适合NVIDIA GPU运行的高效Kernel。 LightLLM比较轻量、易于扩展、易于上手&…
阅读更多...
Android 抓取 CPU 资源信息

Android 抓取 CPU 资源信息

在 Android 开发中&#xff0c;使用 ADB&#xff08;Android Debug Bridge&#xff09;命令获取 CPU 资源信息有很多重要的作用。这些命令可以帮助开发者在多种情况下分析和优化应用性能、解决问题以及进行系统性调试。 以下列举一些 ABD 获取 CPU 资源信息的命令 获取 CPU 核…
阅读更多...
农作物生长环境的远程监控与智能调控

农作物生长环境的远程监控与智能调控

农作物生长环境的远程监控与智能调控 农作物生长环境的远程监控与智能调控技术&#xff0c;作为现代农业科技的核心组成部分&#xff0c;正逐步革新传统农业的生产模式&#xff0c;推动农业向精准化、智能化转型。这一技术体系综合应用了物联网、大数据、云计算以及人工智能等…
阅读更多...
C语言实战 | Flappy Bird游戏

C语言实战 | Flappy Bird游戏

Flappy Bird游戏是由一名越南游戏制作者独自开发的&#xff0c;曾经风靡全球。游戏规则非常简单&#xff0c;玩家必须控制一只小鸟&#xff0c;跨越由各种长度的水管所组成的障碍物&#xff0c;如果撞上管道游戏就结束&#xff0c;如图11.11所示。 ■ 图11.11Flappy Bird 游戏 …
阅读更多...
启明智显Model3A芯片方案7寸高清触摸屏ZX7D00CM21S：开箱、设置与实操全攻略指南

启明智显Model3A芯片方案7寸高清触摸屏ZX7D00CM21S：开箱、设置与实操全攻略指南

一、背景 本指南将详细介绍启明智显的Model3A芯片方案下的7寸高清触摸屏ZX7D00CM21S的开箱步骤、基础设置以及实操应用。无论您是电子爱好者、开发者还是工程师&#xff0c;这份指南都能助您快速上手并充分利用这款触摸屏的各项功能。 二、硬件介绍 ZX7D00CM21S 7寸高清触摸屏是…
阅读更多...
不知几DAY的Symfony---RCE复现

不知几DAY的Symfony---RCE复现

感谢红队大佬老流氓的供稿&#xff0c;此篇文章是针对Symfony框架的一个RCE漏洞复现 ​框架简介 Symfony是一个开源的PHP Web框架&#xff0c;它现在是许多知名 CMS 的核心组件&#xff0c;例如Drupal、Joomla!、eZPlatform&#xff08;以前称为 eZPublish&#xff09;或Bolt。…
阅读更多...
7、Qt5开发及实列（笔记2）

7、Qt5开发及实列（笔记2）

文章目录 1、mainwindow.c2、mainwindow.h 说明&#xff1a;此示例包含了基本的常使用的基本小部件 效果如下 1、mainwindow.c #include "mainwindow.h" #include <QApplication>MainWindow::MainWindow(QWidget *parent): QMainWindow(parent) {widgetInit()…
阅读更多...
深度Q网络（DQN）算法技术博客

深度Q网络（DQN）算法技术博客

深度Q网络&#xff08;DQN&#xff09;是一种将深度学习与强化学习相结合的算法&#xff0c;用于解决高维状态空间的强化学习问题。本文将详细介绍DQN算法的基本原理&#xff0c;关键公式以及具体的代码实现。 一、DQN算法的基本原理 DQN算法是Q学习的一种扩展&#xff0c;利…
阅读更多...
小程序 npm 支持

小程序 npm 支持

使用 npm 包 目前小程序已经支持使用 npm 安装第三方包&#xff0c;因为 node_modules 目录中的包不会参与小程序项目的编译、 上传和打包&#xff0c;因此在小程序 项目中要使用的 npm 包&#xff0c;必须走一遍构建 npm 的过程。在构建成功以后&#xff0c;默认 会在小程序目…
阅读更多...
Python面向对象编程中的继承及其应用

Python面向对象编程中的继承及其应用

目录 1. 继承的基本概念 2. 继承的语法 3. 继承的应用场景 4. 使用示例&#xff1a;汽车销售系统 5. 总结 继承是面向对象编程中的一个重要概念&#xff0c;它允许我们根据已有类创建新类&#xff0c;并继承已有类的属性和方法。在本文中&#xff0c;我们将学习Python中的…
阅读更多...
向量数据库、主键存储引擎、高速网络 RDMA 框架……DolphinDB 版本更新啦！

向量数据库、主键存储引擎、高速网络 RDMA 框架……DolphinDB 版本更新啦！

盛夏已至&#xff0c;炎热的七月伊始&#xff0c;DolphinDB 也迎来了版本的更新。此次更新的 3.00.1 与 2.00.13 版本从多个维度进行了优化扩展&#xff0c;进一步深化了 DolphinDB 在机器学习、数据分析等领域的尝试与探索。 为了响应用户日益增长的 AI 运算需求&#xff0c;…
阅读更多...
Java基础:爬虫

Java基础:爬虫

1.本地爬虫 Pattern:表示正则表达式 Matcher:文本匹配器&#xff0c;作用按照正则表达式的规则去读取字符串&#xff0c;从头开始读取。在大串中去找符合匹配规则的子串。 1.2.获取Pattern对象 通过Pattern p Pattern.compile("正则表达式");获得 1.3.…
阅读更多...
nginx重定向

nginx重定向

nginx的重定向 location 匹配 location 匹配的就是后面的URI /wordpress location 匹配的分类和优先级** 1、精确匹配 location / 对字符串进行完全匹配&#xff0c;必须完全符合 2、正则匹配 ^~ 前缀匹配&#xff0c; 以什么开头 -区分大小写的匹配 ~*不区分大小写 …
阅读更多...
最新文章

Copyright @ 2022~2023