【C++】从零开始认识多态

在这里插入图片描述

送给大家一句话：
一个犹豫不决的灵魂，奋起抗击无穷的忧患，而内心又矛盾重重，真实生活就是如此。 ​​​​ – 詹姆斯・乔伊斯 《尤利西斯》

_φ(*￣ω￣)ﾉ_φ(*￣ω￣)ﾉ_φ(*￣ω￣)ﾉ
_φ(*￣ω￣)ﾉ_φ(*￣ω￣)ﾉ_φ(*￣ω￣)ﾉ
_φ(*￣ω￣)ﾉ_φ(*￣ω￣)ﾉ_φ(*￣ω￣)ﾉ

从零开始认识多态

  • 1 前言
  • 2 什么是多态
  • 3 多态的构成
    • 3.1 协变
    • 3.2 析构函数的重写
    • 3.3 语法细节
    • 3.4 C++11 override 和 final
    • 3.5 重写（覆盖） - 重载 - 重定义（隐藏）
  • 4 多态的底层实现
    • 4.1 底层实现
    • 4.2 验证虚表
  • 5 抽象类
  • 6 多继承中的多态
    • 一般的多继承
    • 菱形继承和菱形虚拟继承
  • Thanks♪(･ω･)ﾉ谢谢阅读！！！
  • 下一篇文章见！！！

1 前言

面向对象技术（oop）的核心思想就是封装，继承和多态。通过之前的学习，我们了解了什么是封装，什么是继承。

封装就是对将一些属性装载到一个类对象中，不受外界的影响，比如：洗衣机就是对洗衣服功能，甩干功能，漂洗功能等的封装，其功能不会受到外界的微波炉影响。

继承就是可以将类对象进行继承，派生类会继承基类的功能与属性，类似父与子的关系。比如水果和苹果，苹果就有水果的特性。

接下来我们就来了解学习多态！

2 什么是多态

多态是面向对象技术（OOP）的核心思想，我们把具有继承关系的多个类型称为多态类型，通俗来讲：就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

举个例子：就拿刚刚结束的五一假期买票热为例，买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。同样一个行为在不同的对象上就有不同的显现。

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。


#include<iostream>using namespace std;class Person 
{
public:virtual void BuyTicket() { cout << "买票->全价" << endl; }
};class Student : public Person
{
public:virtual void BuyTicket() { cout << "买票->半价" << endl; }
};void Func(Person& p)
{p.BuyTicket();
}int main()
{Person p;Student s;//同一个函数对不同对象有不同效果Func(p);Func(s);return 0;
}

比如Student继承了Person。Person对象买票全价，Student对象买票半价。我们运行看看：
在这里插入图片描述

  • 多态调用：运行时，到指定对象的虚表中找虚函数来调用（指向基类调用基类的虚函数，指向子类调用子类的虚函数）
  • 普通调用：编译时，调用对象是哪个类型，就调用它的函数。

乍一看还挺复杂，接下来我们就来了解多态的构成。

3 多态的构成

继承的情况下才有虚函数，才有多态！！！

多态构成的条件：

  1. 必须通过基类的指针或者引用调用虚函数（virtual修饰的类成员函数）
  2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写（父子虚函数要求三同）
    • 虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数

看起来很是简单，当时其实有很多的坑！！！一不小心就会掉进去。

3.1 协变

上面我们说了多态的条件：父子虚函数要求三同。但是却有这样一个特殊情况：协变！
协变：派生类重写基类虚函数时，与基类虚函数返回值类型不同：

  1. 基类虚函数返回基类对象的指针或者引用
  2. 派生类虚函数返回派生类对象的指针或者引用

这样的情况称为协变。

#include<iostream>using namespace std;class A {};
class B : public A {};
//这里明显返回类型不同但是结构仍然正常
class Person 
{
public:virtual A* BuyTicket() { cout << "买票->全价" << endl; return nullptr; }
};class Student : public Person
{
public:virtual B* BuyTicket() { cout << "买票->半价" << endl; return nullptr; }
};

很明显派生类与基类的返回值不同（注意一定是：基类返回“基类”，派生类返回“派生类”）：
但是结果确实正常的，依然构成多态，这样的情况就称为协变！！！

3.2 析构函数的重写

析构函数在编译阶段都会转换成：destructor（），所以表面析构函数名字不同，但是实质上是一致的。这样就会构成多态。

来看正常情况下的析构：

 
#include<iostream>
using namespace std;class Person
{
public:~Person() { cout << "~Person()" << endl; }
};class Student : public Person
{
public:~Student() { cout << "~Student()" << endl; }
};
int main()
{Person p;Student s;return 0;
}

这样会正常的调用析构函数（子类析构会自动调用父类析构->先子后父）：
在这里插入图片描述
再来看：

int main()
{//Person p;//Student s;//基类可以指向基类 也可以指向派生类的基类部分Person* p1 = new Person ;//通过切片来指向对应内容Person* p2 = new Student;delete p1;delete p2;return 0;
}

如果是这样呢？
在这里插入图片描述
这样调用的析构不对啊！Student对象没有调用自身的析构函数，而是调用Person的，为什么会出现这样的现象呢？？？

这样就可能会引起一个十分严重的问题：内存泄漏

#include<iostream>using namespace std;class Person
{
public:~Person() { cout << "~Person()" << endl; }
};
class Student : public Person
{
public:Student() { int* a = new int[100000000]; }~Student() { cout << "~Student()" << endl; }
};
int main()
{for(int i = 0; i< 100000 ; i++){Person* p2 = new Student;delete p2;}return 0;
}

如果我们在Student中申请一个空间，而析构的时候却不能调用其析构函数俩把申请的空间free这样就导致了内存泄漏！！！
在这里插入图片描述
这就十分危险了！！！
而我们希望的是指向谁就调用谁的析构：指向基类调用基类析构，指向派生类调用派生类析构。
那我们怎么做到呢 ----> 当然就是多态了！！！
那我们来看看现在满不满足多态的条件：

  1. 必须通过基类的指针或者引用调用虚函数（virtual修饰的类成员函数）
  2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写（父子虚函数要求三同）

在编译的时候，析构函数都会变成destructor，这样满足三同！构成重写
那么我们就只需要将析构函数变为虚函数就可以了：

class Person
{
public:virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person
{
public:virtual ~Student() { cout << "~Student()" << endl; }
};

来运行看看：
在这里插入图片描述
老铁 OK了！！！应该释放的空间全都释放了！！！

所以建议析构函数设置为虚函数，避免出现上述的情况。

3.3 语法细节

  1. 派生类(基类必须写)的对应函数可以不写virtual（这个语法点非常奇怪！建议写上virtual）
  2. “重写”的本质是重新写函数的实现，函数声明（包括缺省参数的值）与基类一致

来看一道面试题：
以下程序输出结果是什么（）

#include<iostream>using namespace std;class A
{
public:virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }virtual void test() { func(); }
};
class B : public A
{
public:void func(int val = 0) { std::cout << "B->" << val << std::endl; }
};
int main(int argc, char* argv[])
{B* p = new B;p->test();return 0;
}

A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确

答案是：B 为什么呢？

  1. 首先：
    • A类与B类构成继承关系
    • func函数是虚函数（B类是派生类，可以不写virtual），并且AB 中满足三同。构成多态。
    • test函数的参数是基类指针（A* this 成员函数的默认参数），满足多态条件。
  2. 然后：
    • 主函数中调用test函数，因为B是子类，没有test函数，所以会在父类A中寻找。
    • test函数调用 func函数，参数this指向的是B类(指向谁调用谁)，所以就会调用B类的func函数B->
    • 重写的本质是对函数的实现进行重写，函数的结构部分（包括参数，缺省值，函数名，返回值等）与基类一致。所以是 1

所以就可以判断是B选项。
当然实际中不能这么写代码奥！！！会有生命危险（Doge）

3.4 C++11 override 和 final

从上面可以看出，C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮助用户检测是否重写。

  1. final：
    • 修饰类(最终类)，表示该类不能被继承。（C++98直接粗暴使用private来做到不能继承）
      class car final { };
    • 修饰虚函数，表示该虚函数不能再被继承。
      virtual void func() final { }
  2. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。
class Car {
public:virtual void Drive() {}
};class Benz :public Car {
public:virtual void Drive() override { cout << "Benz-舒适" << endl; }
};

3.5 重写（覆盖） - 重载 - 重定义（隐藏）

我们来区分一下这三个类似的概念：

  1. 重载 ：
    • 两个函数作用在同一作用域
    • 函数名相同，参数不同
  2. 重写（覆盖）：
    • 两个函数分别在基类作用域好派生类作用域
    • 函数名、参数、返回值都一样（协变例外）
    • 两个函数必须是虚函数！
  3. 重定义：
    • 两个函数分别在基类作用域好派生类作用域
    • 仅仅函数名相同
    • 两个基类和派生类的同名函数不是重写就是重定义

在这里插入图片描述
重定义包含重写！！！

4 多态的底层实现

4.1 底层实现

首先我们来看一下具有多态属性的类的大小：


#include<iostream>
using namespace std;class Base
{
public:virtual void Func1(){cout << "Func1()" << endl;}
private:int _b = 1;char _ch = 'x';
};int main(int argc, char* argv[])
{cout << sizeof(Base) << endl;return 0;
}

Base的大小在x86环境下是12字节。这十二字节是怎么组成的呢？
首先类里面有一个虚函数表指针_vfptr：
在这里插入图片描述
只要有虚函数就会有虚表指针，这个是实现多态的关键！！！
我们来探索一下：
通过VS的调试，我们可以发现：
在这里插入图片描述
那么如何实现传基类调用基类的虚函数，传派生类调用派生类的虚函数？
当然是使用切片了！

1. 首先每个实例化的类（如果有虚函数）会有一个虚函数表。
2. 传基类调用基类的虚函数，就正常在基类虚表中寻找其对应函数
3. 传派生类，因为多态函数时基类的指针，那么就会切片出来一个基类（虚函数表是派生类的），那么就会在派生类虚表调用对应虚函数。

这样就实现了执行谁就调用谁！！！
运行过程中去虚表中找对应的虚函数调用。具体的汇编语言实现还是比较直白的。

注意同类型的虚表是一样的！！！

  • 满足多态，那么运行时汇编指令会去指向对象的虚表中找对应虚函数进行调用！！！
  • 不满足多态，编译链接时直接根据对象类型，确定调用的函数，确定地址！！！

这里需要分辨一下两个概念：虚表与虚基表

  • 虚表：虚函数表，存的是虚函数，用来形成多态！！！
  • 虚基表：存的是距离虚基类的位置的偏移量，用来解决菱形继承的数据冗余和二义性！！！

注意：虚函数不是存在虚表中的 , 虚表中存的是虚函数的指针。那虚函数存在哪里呢？
来验证一下：

class Person
{
public:virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person
{
public:virtual ~Student() { cout << "~Student()" << endl; }
};int main()
{int i = 0;static int j = 1;int* p1 = new int;const char* p2 = "xxxxxxxx";printf("栈:%p\n", &i);printf("静态区:%p\n", &j);printf("堆:%p\n", p1);printf("常量区:%p\n", p2);Person p;Student s;Person* p3 = &p;Student* p4 = &s;printf("Person虚表地址:%p\n", *(int*)p3);printf("Student虚表地址:%p\n", *(int*)p4);return 0;
}

运行可以看到：
在这里插入图片描述
虚表地址与常量区最接近，那可以推断出虚表储存在常量区！！！

4.2 验证虚表

我们来看：

class Base {
public:virtual void func1() { cout << "Base::func1" << endl; }virtual void func2() { cout << "Base::func2" << endl; }
private:int a;
};
class Derive :public Base {
public:virtual void func1() { cout << "Derive::func1" << endl; }virtual void func3() { cout << "Derive::func3" << endl; }virtual void func4() { cout << "Derive::func4" << endl; }
private:int b;
};

梳理一下结构：

  1. Base作为基类 ， Derive作为派生类！
  2. 派生类Derive重写了func1函数，构成多态！
  3. 其余函数均不构成多态。

然后我们来探索一下：

int main()
{Base b;Derive d;return 0;
}

通过监视窗口可以查看一下虚表的内容：
在这里插入图片描述

这是VS调试的一点BUG，导致监视中派生类的虚表不能显示。在内存窗口里存在4个函数指针，接下来我们来验证一下他们是不是对应的虚函数。

虚函数表本质是一个函数指针数组！
那么如何定义一个函数指针和函数指针数组呢？

//这样定义 
//返回值是void 所以写void
void(*p)( //函数里面的参数 );
void(*p[10])( //函数里面的参数 )

当然可以使用typedef来简化（这个typedef也很特别）

typedef void(*VFPTR)();
VFPTR p1;
VFPTR p2[10];

那么如果我们想要打印出虚表，我们可以设置一个函数：

//因为是函数指针数组，所以传参是函数指针的指针（int arr[10] 传入 int*）。
void PrintVFT(VFPTR* vft )
{for(size_t i = 0 ; i < 4 ; i++){printf("%p\n" , vft[i]);}}

这样就可以打印了，那么现在就需要解决如何获取虚表的首地址。虚表首地址是类的头4个字节（x86环境），我们如何取出来了呢?
直接把类强转为int类型不就4个字节了吗！？但是没有联系的类型是不能强转的。那怎么办呢？？？
C/C++中指针可以直接互相强转（BUG级别的操作！！！）,整型与指针也可以互相转换。

VFPTR* p =  (VFPTR*) *( (int*)&d );//这样就变成4个字节了！
  1. &d 是取类的指针
  2. （int*)&d将类指针强转为int*指针！
  3. *( (int*)&d ) 将 int * 解引用为int
  4. (VFPTR*) *( (int*)&d ) 将int转换为VFPTR*,取到虚表首地址！！！

那么我们来验证一下：

class Base {
public:virtual void func1() { cout << "Base::func1" << endl; }virtual void func2() { cout << "Base::func2" << endl; }
private:int a;
};
class Derive :public Base {
public:virtual void func1() { cout << "Derive::func1" << endl; }virtual void func3() { cout << "Derive::func3" << endl; }virtual void func4() { cout << "Derive::func4" << endl; }
private:int b;
};
typedef void(*VFPTR)();void PrintVFT(VFPTR* vft)
{for (size_t i = 0; i < 4; i++){printf("%p  ->", vft[i]);(*(vft[i]))();}}int main()
{Base b;Derive d;VFPTR* p = (VFPTR*)*((int*)&d);//这样就变成4个字节了！PrintVFT(p);return 0;
}

来看：
在这里插入图片描述
这样就成功获取到了虚标的内容，验证了虚表的内容中存在4个虚函数！！！

5 抽象类

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类）

抽象类不能实例化出对象。派生类继承后也不能实例化出对象。只有重写纯虚函数，派生类才能实例化出对象。

纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

//抽象类
class Car
{
public: //纯虚函数virtual void Drive() = 0;
};int main()
{Car c;return 0;
}

这样一个抽象类是不可以实例化的，进行实例化就会报错：
在这里插入图片描述
如果派生类进行了重新那么就可以正常使用：

class Car
{
public: virtual void Drive() = 0;
};class Benz :public Car
{
public:virtual void Drive(){cout << "Benz-舒适" << endl;}
};
class BMW :public Car
{
public:virtual void Drive(){cout << "BMW-操控" << endl;}
};
void Test()
{//各种调用自身的虚函数Car* pBenz = new Benz;pBenz->Drive();Car* pBMW = new BMW;pBMW->Drive();
}
int main()
{Test();return 0;
}

抽象类与override关键字的区别：

  1. 抽象类间接强制了派生类必须进行虚函数重写
  2. override是在已经重写的情况下，帮助进行重写的语法检查

6 多继承中的多态

多继承我们讲过，是一种很危险的继承，很容易导致菱形继承，引起数据冗余和二义性。那么我们再来看看多态在多继承中是然如何实现的 。

一般的多继承

class Base1 {
public:virtual void func1() { cout << "Base1::func1" << endl; }virtual void func2() { cout << "Base1::func2" << endl; }
private:int b1;
};class Base2 {
public:virtual void func1() { cout << "Base2::func1" << endl; }virtual void func2() { cout << "Base2::func2" << endl; }
private:int b2;
};class Derive : public Base1, public Base2 {
public:virtual void func1() { cout << "Derive::func1" << endl; }virtual void func3() { cout << "Derive::func3" << endl; }
private:int d1;
};

分析一下继承关系：

  1. 有两个基类：Base1类与Base2类
  2. Derive继承两个基类，对func1函数进行了重写构成多态

来看看Derive类的大小是多大：
我们分析一下:Base1类应该有一个虚表指针和一个int类型数据，所以应该为8字节。Base2同理8字节。
那么Derive由于多继承的缘故会包含两个基类，所以应该为16 + 4 = 20字节：
在这里插入图片描述
运行一下，看来我们的分析没有问题！也就是有两张虚表，func1重写会改变两个虚表（因为两个基类都有func1函数），func3是放在Base1的虚表中的，通过虚表验证：

typedef void(*VFPTR) ();void PrintVTable(VFPTR vTable[])
{cout << " 虚表地址>" << vTable << endl;for (int i = 0; vTable[i] != nullptr; ++i){printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);VFPTR f = vTable[i];f();}cout << endl;
}
int main()
{Derive d;VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);PrintVTable(vTableb1);//通过切片获取Base2 b2 = d;VFPTR* vTableb2 = (VFPTR*)(*(int*)&b2);PrintVTable(vTableb2);return 0;
}

运行看看：
在这里插入图片描述
多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中

菱形继承和菱形虚拟继承

实际中我们不建议设计出菱形继承及菱形虚拟继承，一方面太复杂容易出问题，另一方面这样的模型，访问基类成员有一定得性能损耗。所以菱形继承、菱形虚拟继承我们的虚表我们就不看了，一般我们也不需要研究清楚，因为实际中很少用。这里简单叙述一下：
先看菱形继承：

class A
{
public:virtual void func1() { cout << "A::func1" << endl; }int _a;
};class B : public A
{
public:virtual void func2() { cout << "B::func2" << endl; }int _b;
};class C : public A
{
public:virtual void func3() { cout << "C::func3" << endl; }int _c;
};
class D : public B, public C
{
public:virtual void func4() { cout << "D::func4" << endl; }int _d;
};
int main()
{D d;cout<< sizeof(d) << endl;return 0;
}

先来看一下这个类有多大：
在这里插入图片描述

28 字节，这个是怎么得到的，来分析一下：

  1. A类有一个虚函数表指针和一个整型 ，应该是8字节
  2. B类继承于A类 ，包含A类的内容，B的虚函数储存在A的虚表中，所以B类一个为8 + 4 = 12
  3. C类同理
  4. D类继承于B类和C类，那么就包含B类与C类，D类的虚函数储存在B类的虚表中（A的虚表）

在这里插入图片描述
通过内存来验证一下：
在这里插入图片描述
可以看到只有两个虚表指针。所以菱形继承和多继承类似！

再来看菱形虚拟继承：
在这里插入图片描述
这个36字节是怎么得到的？？？

  1. 首先菱形虚拟继承会把共同的基类提取出来（也就是A被提出来了），那么B类就会有一个虚基表指针来指向这个提前出来的A类。所以B类大小为4 (虚表指针) + 4（虚基表指针） + 4（int数据） = 12
  2. C类同理，那么现在就有12 (B类) + 12（C类） + 4（A类的int）+ 4(D类的int) = 32
  3. 啊？？？这才32字节，剩下的4字节是什么？难不成还有一个虚表指针？！是的，A 里面还有一个虚表指针！！！

来看内存：
在这里插入图片描述
很明显，在A类中还有一个虚表指针！！！真滴复杂！
所以应该是：
12 (B类) + 12（C类） + 8（A类的int）+ 4(D类的int) = 36
那为什么A会有一个虚表指针，而不是D类有！？

  1. 首先派生类的成员是不会有虚表指针的，虚表指针都在基类的部分中！！！

  2. 我们这四个类都有自身的虚函数

    • 菱形继承中，B类与C类都继承于A类，所以BC是派生类，就不需要有独立的虚表指针，而是与A类共用。父类有了就与父类共用，父类没有才会独立创建。
    • 菱形虚拟继承中，B类与C类都虚拟继承于A类，A类被单独出去了，那么B类与C类的虚函数就不能放在A类里，因为A类是共享的，放进去就会产出问题！所以BC会独立创建一个虚表指针。

  3. 总结： 子类有虚函数，继承的父类有虚函数就有虚表，子类不需要单独建立虚表！！！如果父类是共享的，无论如何都有创建独立的虚表！！！

注意：虚基表中储存两个值：第一个是距离虚表位置的偏移量，第二个是距离基类位置的偏移量

Thanks♪(･ω･)ﾉ谢谢阅读！！！

下一篇文章见！！！

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

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

相关文章

Elsevier旗下双1区TOP刊，8.8分影响因子加上超低自引率，各指标领跑计算机类SCI

Elsevier旗下双1区TOP刊，8.8分影响因子加上超低自引率，各指标领跑计算机类SCI

【SciencePub学术】 今天小编给大家带来了一本计算机类的高分优刊解读&#xff0c;隶属于Elsevier出版社&#xff0c;JCR1区&#xff0c;中科院1区TOP&#xff0c;影响因子高达8.7&#xff0c;领域相符的学者可考虑&#xff01; APPLIED SOFT COMPUTING 1 期刊概况 【期刊简…
阅读更多...
3D渲染是什么？渲染100邀请码1a12

3D渲染是什么？渲染100邀请码1a12

3D渲染是把3D模型转换为2D图像或动画的过程&#xff0c;涉及到多方面知识&#xff0c;这篇文章我们就来了解下。 1、3D渲染的原理 3D渲染的原理是模拟光线在三维空间中的传播和反射&#xff0c;根据物体在空间中的分布&#xff0c;计算出每个像素的颜色和亮度等数值&#xff…
阅读更多...
⚡REST 和 SOAP 协议有什么区别？

⚡REST 和 SOAP 协议有什么区别？

原文链接&#xff1a;https://document360.com/blog/rest-vs-soap/ API 是应用程序编程接口&#xff08;Application Programming Interface&#xff09;的缩写。API 规定了不同的软件组件应如何以编程方式进行交互和通信。 最常见的 API 类型就是 Web API。网络应用&#xff…
阅读更多...
笔试强训Day19 数学知识 动态规划 模拟

笔试强训Day19 数学知识 动态规划 模拟

[编程题]小易的升级之路 题目链接&#xff1a;小易的升级之路__牛客网 思路&#xff1a; 按题目写即可 注意辗转相除法。 AC code&#xff1a; #include<iostream> using namespace std; int gcd(int a, int b) {return b ? gcd(b, a % b) : a; } int main() {int n…
阅读更多...
HCIP的学习（13）

HCIP的学习（13）

第五章&#xff0c;重发布和路由策略 重发布 ​ 在路由协议的边界设备上&#xff0c;将某一种路由协议的路由信息引入到另一种路由协议中&#xff0c;这个操作被称为路由引入或者路由重分发。----技术本质为重发布。 条件 必须存在ASBR设备&#xff08;路由边界设备&#x…
阅读更多...
算法提高之树的最长路径

算法提高之树的最长路径

算法提高之树的最长路径 核心思想&#xff1a;树形dp 枚举路径的中间节点用f1[i] 表示i的子树到i的最长距离,f2[i]表示次长距离最终答案就是max(f1[i]f2[i]) #include <iostream>#include <cstring>#include <algorithm>using namespace std;const int N …
阅读更多...
matlab

matlab

图像配准&#xff1a; %手动选择执行图片(由于程序为分开&#xff0c;此处保存的mat文件为图MRI6的信息&#xff0c;所以请选择图MRI6) [filename,pathname]uigetfile({*.jpg;*.bmp;*.tif;*.png;*.gif,All Image Files;*.*,All Files}); image imread([pathname,filename]); …
阅读更多...
本机MySQL数据库服务启动了，但是cmd登录不上10061

本机MySQL数据库服务启动了，但是cmd登录不上10061

注意&#xff1a;不建议安装MySQL8&#xff0c;建议直接使用phpstudy中自带的MySQL5.7 错误信息 ERROR 2003 (HY000): Cant connect to MySQL server on x.x.x.x (10061) 原因 可能是端口号错误。比如修改了my.ini中&#xff0c;或者phpstudy中数据库端口的配置&#xff0c;…
阅读更多...
【Linux】Linux线程

【Linux】Linux线程

一、Linux线程的概念 1.什么是线程 1.一个进程的一个执行线路叫做线程&#xff0c;线程的一个进程内部的控制序列。 2.一个进程至少有一个执行线程 3.线程在进程内部&#xff0c;本质是在进程地址空间内运行 4.操作系统将进程虚拟地址空间的资源分配给每个执行流&#xff0…
阅读更多...
【C 数据结构-动态内存管理】3. 伙伴系统管理动态内存

【C 数据结构-动态内存管理】3. 伙伴系统管理动态内存

文章目录 【 1. 伙伴系统的结构设计 】【 2. 分配算法 】【 3. 回收算法 】 伙伴系统 本身是一种动态管理内存的方法&#xff0c;和边界标识法的区别是&#xff1a;使用伙伴系统管理的存储空间&#xff0c;无论是空闲块还是占用块&#xff0c;大小都是 2 的 n 次幂&#xff08;…
阅读更多...
新火种AI|挑战谷歌，OpenAI要推出搜索引擎？

新火种AI|挑战谷歌，OpenAI要推出搜索引擎？

作者&#xff1a;一号 编辑&#xff1a;美美 在AI革新的浪潮下&#xff0c;谷歌搜索迎来了越来越多的“挑战者”。 最近&#xff0c;据多家外媒的消息&#xff0c;有知情人士透露&#xff0c;OpenAI正计划上线一款基于ChatGPT的大型产品&#xff0c;将提供一个新的搜索引擎&…
阅读更多...
[译]Elasticsearch _source Doc_values And Store Performance

[译]Elasticsearch _source Doc_values And Store Performance

原文地址 https://sease.io/2021/02/field-retrieval-performance-in-elasticsearch.html 在这篇博文中&#xff0c;我想从性能的角度探讨 Elasticsearch 为我们存储字段和查询时检索字段提供了哪些可能性。 事实上&#xff0c;Lucene&#xff08;Elasticsearch 和 Solr 构建的…
阅读更多...
【WEB前端2024】开源智体世界：乔布斯3D纪念馆-第16课-跳转私信

【WEB前端2024】开源智体世界：乔布斯3D纪念馆-第16课-跳转私信

【WEB前端2024】开源智体世界&#xff1a;乔布斯3D纪念馆-第16课-跳转私信 使用dtns.network德塔世界&#xff08;开源的智体世界引擎&#xff09;&#xff0c;策划和设计《乔布斯超大型的开源3D纪念馆》的系列教程。dtns.network是一款主要由JavaScript编写的智体世界引擎&am…
阅读更多...
Map集合的实现类~HashMap

Map集合的实现类~HashMap

存储结构&#xff1a;哈希表 键重复依据是hashCode和equals方法&#xff08;键不能重复&#xff09; 添加&#xff1a; 先创建Student类&#xff0c;那么往HashSet添加的就是Student对象作为键值&#xff0c;后面的作为值 删除&#xff1a; 判断&#xff1a; 遍历&#xff1a…
阅读更多...
就业班 第三阶段（redis） 2401--5.7 day2 redis2 哨兵（前提是做好了主从）+redis集群

就业班 第三阶段（redis） 2401--5.7 day2 redis2 哨兵（前提是做好了主从）+redis集群

1、设置密码&#xff08;redis&#xff09; 先在redis.conf里面找到这个 后面写上要设置的密码即可 2、哨兵模式 监控redis集群中master状态的的工具 在做了主从的前提下 主 从1 从2 作用 1)&#xff1a;Master状态检测 2)&#xff1a;如果Master异常&#xff0c;则会进行…
阅读更多...
(四)JSP教程——request内置对象

(四)JSP教程——request内置对象

request对象是将客户端浏览器数据提交给服务器端JSP页面的唯一数据通道&#xff0c;通过该通道JSP页面能够获取浏览器信息、form表单信息、URL参数信息等。 1.from表单向JSP文件传递数据 form表单是浏览器向服务器传递数据的一种基本机制&#xff0c;包含两种方式&#xff1a;…
阅读更多...
C/C++开发环境配置

C/C++开发环境配置

配置C/C开发环境 1.下载和配置MinGW-w64 编译器套件 下载地址&#xff1a;https://sourceforge.net/projects/mingw-w64/files/mingw-w64/mingw-w64-release/ 下载后解压并放至你容易管理的路径下&#xff08;我是将其放在了D盘的一个software的文件中管理&#xff09; 2.…
阅读更多...
快速找出存（不存在）在某个（或多个）文件的文件夹

快速找出存（不存在）在某个（或多个）文件的文件夹

首先&#xff0c;需要用到的这个工具&#xff1a; 度娘网盘 提取码&#xff1a;qwu2 蓝奏云 提取码&#xff1a;2r1z 想要找出有下面这个文件存在的文件夹 切换到批量文件复制版块&#xff0c;快捷键Ctrl5 右侧&#xff0c;搜索添加 选定范围&#xff0c;勾选搜索文件夹、包…
阅读更多...
【牛客】值周

【牛客】值周

原题链接&#xff1a;登录—专业IT笔试面试备考平台_牛客网 目录 1. 题目描述 2. 思路分析 3. 代码实现 1. 题目描述 2. 思路分析 差分。 因为l<100000000,所以数组开1e8。 唯一需要注意的点就是前面给b[0]单独赋值为1&#xff08;因为如果在循环中给b[0]赋值&…
阅读更多...
网络基础（全）

网络基础（全）

协议 ”协议“就是一种约定。那么协议需要需要管理吗&#xff1f;答案是当然需要管理呀。 操作系统要进行协议管理——先描述&#xff0c;在组织协议本质就是软件&#xff0c;软件是可以进分层的协议在设计的时候&#xff0c;就是被层状的划分的为什么要划分为层状结呢&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023