C++:多态究竟是什么?为何能成为面向对象的重要手段之一?

C++:多态究竟是什么?为何能成为面向对象的重要手段之一?

  • 前言
  • 一、多态的概念
  • 二、多态的定义及实现
    • 2.1 多态的构成条件
    • 2. 2 虚函数
    • 2.3 虚函数的重写
      • 2.3.1 虚函数重写的例外1:协变(基类与派生类虚函数返回值类型不同)
      • 2.3.2 虚函数重写的例外2:析构函数的重写(基类与派生类析构函数的名字不同)
    • 2.4 C++11 override 和 final
      • 2.4.1 final
      • 2.4.2 override
    • 2.5 重载、覆盖(重写)、隐藏(重定义)的对比
  • 三、抽象类
    • 3.1 概念
    • 3.2 接口继承和实现继承
  • 四、虚函数及虚函数表
    • 4.1 虚函数表
    • 4.2 虚函数重写覆盖虚表
    • 4.3 虚函数存在哪的?虚表存在哪的?
  • 五、多态原理
    • 5.1 多态调用过程及原理
    • 5.2 多态运行时确定?
    • 5.3 动态绑定与静态绑定
  • 六、单继承和多继承关系的虚函数表
    • 6.1 单继承中的虚函数表
  • 6.2 多继承中,子类新增虚函数存入那个虚表?
  • 6.3 总结
  • 七、菱形继承、菱形虚拟继承

前言

本篇博客基于VS2019X86环境下,后续关于多态原理相关验证都是基于vsX86环境,而虚表本质上是一个虚函数指针数组,在X86环境下VS编译器会在数组最后放一个unllptr!!

一、多态的概念

多态的概念:通俗来说,就是多种形态,具体点就是去完成某个行为,当不同的对象去完成时会产生出不同的状态。
比如买票这个行为,当普通人买票时,是全价买票;学生买票时,是半价买票;军人买票时是优先买票。

二、多态的定义及实现

2.1 多态的构成条件

多态是在不同继承关系的类对象,去调用同一函数,产生了不同的行为。
但在继承中要构成多态还有两个条件:(后续会具体介绍其细节)

  1. 必须通过基类指针或者引用调用虚函数。
  2. 被调用的函数必须是虚函数,且派生类必须对基类的虚函数进行重写。

比如Student继承了Person。Person对象买票全价,Student对象买票半价:

class Person
{
public:virtual void BuyTicket()//被virtual修饰的类成员函数称为虚函数{cout << "买票全价" << endl;}
};class Student : public Person
{
public:virtual void BuyTicket()//对基类虚函数重写{cout << "买票半价" << endl;}
};void Func(Person& people)
{people.BuyTicket();
}int main()
{Person p;Func(p);//涉及赋值兼容规则,后续会介绍。Student s;Func(s);return 0;
}

【运行结果】:
在这里插入图片描述

2. 2 虚函数

虚函数:即被virtual修饰的类成员函数称为虚函数

class Person {
public://BuyTicket()为虚函数virtual void BuyTicket() { cout << "买票-全价" << endl;}
};

2.3 虚函数的重写

虚函数的重写(覆盖):派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同),称子类的虚函数重写了基类的虚函数。
tips:这里派生类的虚函数在不加virtual关键字时,我们认为也构成重写。原因在于,我们认为虚函数的重写继承了基类虚函数的接口,在派生类中重写实现

class Person {
public:virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:virtual void BuyTicket() { cout << "买票-半价" << endl; }/*注意:在重写基类虚函数时,派生类的虚函数在不加virtual关键字时,虽然也可以构成重写(因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性),但是该种写法不是很规范,不建议这样使用*//*void BuyTicket() { cout << "买票-半价" << endl; }*/
};
void Func(Person& p)
{p.BuyTicket();
}
int main()
{Person p;Student s;Func(p);Func(s);return 0;
}

2.3.1 虚函数重写的例外1:协变(基类与派生类虚函数返回值类型不同)

派生类重写基类虚函数时,与基类虚函数返回值类型可以不同,但必须是父子类关系的指针或者引用。即基类虚函数返回基类对象的指针或者引用,派生类虚函数返回派生类对象的指针或者引用,称为协变。

class A {};
class B : public A {};class Person 
{
public:virtual A* f() { return new A; }
};class Student : public Person 
{
public:virtual B* f() { return new B; }
};

2.3.2 虚函数重写的例外2:析构函数的重写(基类与派生类析构函数的名字不同)

如果基类的析构函数为虚函数,此时派生类析构函数只要定义,无论是否加virtual关键字,都与基类的析构函数构成重写。虽然函数名不相同,看起来违背了重写的规则,其实不然,这里可以理解为编译器对析构函数的名称做了特殊处理,编译后析构函数的名称统一处理成destructor。

【实例】:

class Person {
public:virtual ~Person() { cout << "~Person()" << endl; }
};class Student : public Person {
public:virtual ~Student() { cout << "~Student()" << endl; }
};
// 只有派生类Student的析构函数重写了Person的析构函数,下面的delete对象调用析构函
//数,才能构成多态,才能保证p1和p2指向的对象正确的调用析构函数。int main()
{Person* p1 = new Person;Person* p2 = new Student;delete p1;// delete p1编译器处理为: p1->destrutor() + operator delete(p1)delete p2;// delete p2编译器处理为: p2->destrutor() + operator delete(p2)return 0;
}

tips:大多数情况析构函数是不需要重写的。只有上述在上述情况下,如果普通析构函数,则p1、p2delete时调用的都是Person类的析构。但实际上p2指向的是Student类对象,原则上因该调用Student类的析构函数。所以为了正确调用析构函数,需要将析构实现为虚函数并重写。(记住上述情况,只有这种情况下才需要重写析构函数)

2.4 C++11 override 和 final

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

2.4.1 final

final:修饰虚函数,表示该虚函数不能再被重写。

class Car
{
public:virtual void Drive() final {}
};class Benz :public Car
{
public:virtual void Drive() { cout << "Benz-舒适" << endl; }
};

2.4.2 override

override: 检查派生类虚函数是否重写了基类某个虚函数,如果没有重写编译报错。

class Car {
public:virtual void Drive() {}
};class Benz :public Car {
public:virtual void Drive() override { cout << "Benz-舒适" << endl; }
};

2.5 重载、覆盖(重写)、隐藏(重定义)的对比

在这里插入图片描述

三、抽象类

3.1 概念

在虚函数的后面写上 =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();
}

3.2 接口继承和实现继承

普通函数的继承是一种实现继承,派生类继承了基类函数,可以使用函数,继承的是函数的实现。虚函数的继承是一种接口继承,派生类继承的是基类虚函数的接口,目的是为了重写,达成多态,继承的是接口。所以如果不实现多态,不要把函数定义成虚函数。

四、虚函数及虚函数表

4.1 虚函数表

在了解虚函数前,我们先来看看这段代码中类对象的大小(X86环境下)

class Base
{
public:virtual void Func1(){cout << "Func1()" << endl;}
private:int _b = 1;
};int main()
{Base b1;cout << sizeof(b1) << endl;return 0;
}

【运行结果】:

在这里插入图片描述

我们发现b的大小竟然是8bytes。为什么呢?这就不得不提到虚函数表了。
原来Base对象中,除了_b成员,还多一个__vfptr放在对象的前面(注意有些平台可能会放到对象的最后面,这个跟平台有关),对象中的这个指针我们叫做虚函数表指针(v代表virtual,f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针,因为虚函数的地址要被放到虚函数表中,虚函数表也简称虚表。

在这里插入图片描述

4.2 虚函数重写覆盖虚表

我们再来看看下面这段代码:

// 1.我们增加一个派生类Derive去继
// 2.Derive中重写Func1
// 3.Base再增加一个虚函数Func2和
class Base
{
public:virtual void Func1(){cout << "Base::Func1()" << endl;}virtual void Func2(){cout << "Base::Func2()" << endl;}void Func3(){cout << "Base::Func3()" << endl;}
private:int _b = 1;
};class Derive : public Base
{
public:virtual void Func1(){cout << "Derive::Func1()" << endl;}
private:int _d = 2;
};int main()
{Base b;Derive d;return 0;
}

在这里插入图片描述
通过观察和测试,我们发现了以下几点问题:

  1. 派生类对象d中也有一个虚表指针,d对象由两部分构成,一部分是父类继承下来的成员,虚表指针也就是存在部分的另一部分是自己的成员。
  2. 基类b对象和派生类d对象虚表是不一样的,这里我们发现Func1完成了重写,所以d的虚表中存的是重写的Derive::Func1,所以虚函数的重写也叫作覆盖,覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法,覆盖是原理层的叫法。
  3. 派生类的虚表生成总结:a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生类重写了基类中某个虚函数,用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

4.3 虚函数存在哪的?虚表存在哪的?

后续所有代码都是基于vsX86环境,而虚表本质上是一个虚函数指针数组,VS编译器会在数组最后放一个unllptr!!
虚函数存在哪的?虚表存在哪的?比较简单的方法就是将虚函数、虚表以及每个存储区间地址都打印出来进行比较。

比如:

class Base {
public:virtual void func1() { cout << "Base::func1" << endl; }virtual void func2() { cout << "Base::func2" << endl; }
private:int _a;
};void func()
{cout << "void func()" << endl;
}int main()
{Base b1;int a;int* a2 = new int;//const int a3 = 1;const char* s = "hello world";static int d4 = 0;printf("栈:%p\n", &a);printf("堆:%p\n", a2);printf("静态区:%p\n", &d4);//printf("代码段:%p\n", &a3);printf("代码段:%p\n", s);printf("虚表:%p\n", *(int*)(&b1));//在类域中的函数地址比较特殊,要加&printf("虚函数地址:%p\n", &Base::func1);printf("普通函数地址:%p\n", func);return 0;
}

【运行结果】:
在这里插入图片描述
我们发现虚表和代码段的存储在一起,虚函数和普通函数存储在一起,而普通函数又是存在代码段的。

总结:

  1. 虚函数和普通函数以及虚表都是存在代码段的!!!

五、多态原理

5.1 多态调用过程及原理

多态的原理到底是什么?为啥指向不同对象,能调用不同函数呢?
我们来看看开头的这段代码:

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 Mike;Func(Mike);Student Johnson;Func(Johnson);return 0;
}

在这里插入图片描述
多态实现过程:

  1. 观察下图的红色箭头我们看到,p是指向mike对象时,p->BuyTicket在mike的虚表中找到虚函数是Person::BuyTicket。
  2. 观察下图的蓝色箭头我们看到,p是指向johnson对象时,p->BuyTicket在johson的虚表中找到虚函数是Student::BuyTicket。
  3. 这样就实现出了不同对象去完成同一行为时,展现出不同的形态。

5.2 多态运行时确定?

多态运行时确定还是编译时确定?我们接着看:
在这里插入图片描述

void Func(Person* p)
{p->BuyTicket();
}
int main()
{Person mike;Func(&mike);mike.BuyTicket();return 0;
}
// 以下汇编代码中跟你这个问题不相关的都被去掉了
void Func(Person* p)
{
...p->BuyTicket();
// p中存的是mike对象的指针,将p移动到eax中
001940DE  mov         eax,dword ptr [p]
// [eax]就是取eax值指向的内容,这里相当于把mike对象头4个字节(虚表指针)移动到了edx
001940E1  mov         edx,dword ptr [eax]
// [edx]就是取edx值指向的内容,这里相当于把虚表中的头4字节存的虚函数指针移动到了eax
00B823EE  mov         eax,dword ptr [edx]
// call eax中存虚函数的指针。这里可以看出满足多态的调用,不是在编译时确定的,是运行起来
以后到对象的中取找的。
001940EA  call        eax  
001940EC  cmp         esi,esp  
}
int main()
{
... 
// 首先BuyTicket虽然是虚函数,但是mike是对象,不满足多态的条件,所以这里是普通函数的调
用转换成地址时,是在编译时已经从符号表确认了函数的地址,直接call 地址mike.BuyTicket();
00195182  lea         ecx,[mike]
00195185  call        Person::BuyTicket (01914F6h)  
... 
}
  1. 满足多态以后的函数调用,不是在编译时确定的,是运行起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的。

5.3 动态绑定与静态绑定

  1. 静态绑定又称为前期绑定(早绑定),在程序编译期间确定了程序的行为,也称为静态多态,比如:函数重载
  2. 动态绑定又称后期绑定(晚绑定),是在程序运行期间,根据具体拿到的类型确定程序的具体行为,调用具体的函数,也称为动态多态。

六、单继承和多继承关系的虚函数表

6.1 单继承中的虚函数表

我们来看看的段代码:

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; }void func5() { cout << "Derive::func5" << endl; }
private:int b;
};class X :public Derive {
public:virtual void func3() { cout << "X::func3" << endl; }
};int main()
{Base b;Derive d;X x;return 0;
}

【监视窗口】:
在这里插入图片描述
在上述监视窗口中我们发现虚函数表中竟然只存有父类的虚函数以及相关虚函数的重写。也就是说新增的虚函数不会存储到虚表中!但真的如此吗?

真正原因在于:VS监视窗口是微软工程师处理过方便使用者观察的,但不一定是真实的!编译器的监视窗口故意隐藏了这些东西,也可以认为是他的一个小bug。要了解虚函数的地址是否一定会被放进类的虚函数,我们可以通过其真实内存,打印虚函数表来观察?

//将函数指针void (*)() 重定义为VFNC
typedef void (*VFUNC)();
//打印虚函数表
void printVFT(VFUNC* a)
{//由于VSX86环境下,编译器会在虚表结尾放一个nullptr,所以此处结束条件为a[i]!=0for (int i = 0; a[i] != 0; i++){printf("[%d]->%p ", i, a[i]);//调用a[i]中存储的函数VFUNC f = a[i];f();//(*f)()cout << endl;}
}int main()
{Base b;
// 思路:取出b、d对象的头4bytes,就是虚表的指针,前面我们说了虚函数表本质是一个存虚函数
//      指针的指针数组,这个数组最后面放了一个nullptr
// 1.先取b的地址,强转成一个int*的指针
// 2.再解引用取值,就取到了b对象头4bytes的值,这个值就是指向虚表的指针
// 3.再强转成VFPTR*,因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组。
// 4.虚表指针传递给PrintVTable进行打印虚表
// 5.需要说明的是这个打印虚表的代码经常会崩溃,因为编译器有时对虚表的处理不干净,虚表最
//后面没有放nullptr,导致越界,这是编译器的问题。我们只需要点目录栏的-生成-清理解决方案,再编译就好了。printVFT((VFUNC*)(*((int*)(&b))));printf("----------------------------------\n");Derive d;printVFT((VFUNC*)(*(int*)(&d)));printf("----------------------------------\n");X x;printVFT((VFUNC*)(*(int*)(&x)));return 0;
}

【运行结果】:
在这里插入图片描述

总结:

1.我们发现实际上虚函数的地址一定会被放进类的虚函数表。

6.2 多继承中,子类新增虚函数存入那个虚表?

和6.1一样,我们只需要将虚表中存储的值都打印出来,即可确定这个问题答案!
【代码如下】:

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;
};//打印虚函数
typedef void(*VFUNC)();
void printVFT(VFUNC* a)
{for (int i = 0; a[i] != 0; i++){printf("[%d]->%p ", i, a[i]);VFUNC f = a[i];f();}cout << endl;
}int main()
{Derive d;printVFT((VFUNC*)(*(int*)&d));printf("-----------------------------\n");//由于d对象中存有两张虚表,要打印第2张虚表,需要将&d偏移指向Base2开头,有如下几种方式//printvft((vfunc*)(*(int*)((char*)&d+sizeof(base1))));Base2* ptr = &d;printVFT((VFUNC*)(*(int*)ptr));return 0;
}

【运行结果】:
在这里插入图片描述
结论:

  1. 多继承中,子类新增虚函数存入到第一张虚表中!!

6.3 总结

  1. 虚函数的地址一定会被放进类的虚函数表。
  2. 多继承中,子类新增虚函数存入到第一张虚表中。
  3. 同一个类型共用同一张虚表,不同类型则可能存在多张虚表。(可以将虚表打印出来,各位自行验证)

七、菱形继承、菱形虚拟继承

实际中我们不建议设计出菱形继承及菱形虚拟继承,一方面太复杂容易出问题,另一方面这样的模型,访问基类成员有一定得性能损耗。所以博主就不介绍了。如果感兴趣,这里附上两篇相关文章:

  1. C++ 虚函数表解析
  2. C++ 对象的内存布局

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

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

相关文章

java spring mvc 初探 web搭建过程详解

提前准备安装tomcat 设备&#xff1a;mac 第一步&#xff1a;下载 进入官网下载压缩包 注意&#xff1a;如果jdk版本是1.8&#xff0c;则tomcat需要v8才行&#xff0c;否则会报错 https://tomcat.apache.org/ 第二步&#xff1a;解压 解压后路径 /Users/you/Library/tomcat…

HAL——SPI

学习目标 掌握SPI配置方式掌握SPI读写操作 学习内容 需求 SPI配置 打开SPI1,选中全双工模式。观察下方自动生成的引脚&#xff0c;是否和自己开发板引脚对应。 修改引脚&#xff0c;来动右侧芯片引脚视图&#xff0c;找到开发板对应引脚&#xff0c;进行修改。 观察修改后的…

git秘钥过期 ERROR: Your SSH key has expired

文章目录 1、错误提示Your SSH key has expired2、登录Github确认3、重新设置秘钥 1、错误提示Your SSH key has expired 使用git命令时遇到Github 的 SSH Key秘钥过期&#xff0c;提示错误ERROR: Your SSH key has expired 2、登录Github确认 首先登录Github查看&#xff…

【STM32】STM32学习笔记-USART串口数据包(28)

00. 目录 文章目录 00. 目录01. 串口简介02. HEX数据包03. 文本数据包04. HEX数据包接收05. 文本数据包接收06. 预留07. 附录 01. 串口简介 串口通讯(Serial Communication)是一种设备间非常常用的串行通讯方式&#xff0c;因为它简单便捷&#xff0c;因此大部分电子设备都支持…

网络安全B模块(笔记详解)- Web渗透测试

Web渗透测试 1.通过渗透机Kali1.0对服务器场景PYsystem20192进行Web渗透测试(使用工具w3af的对目标Web服务器进行审计),在w3af的命令行界面下,使用命令列出所有用于审计的插件,将该操作使用的命令作为Flag值提交; 进入kali命令控制台中使用命令w3af_console进入w3af命令…

深入了解pnpm:一种高效的包管理工具

✨专栏介绍 在当今数字化时代&#xff0c;Web应用程序已经成为了人们生活和工作中不可或缺的一部分。而要构建出令人印象深刻且功能强大的Web应用程序&#xff0c;就需要掌握一系列前端技术。前端技术涵盖了HTML、CSS和JavaScript等核心技术&#xff0c;以及各种框架、库和工具…

【C++期末】酒店住宿信息管理系统(含easyX)

诚接计算机专业编程作业(C语言、C、Python、Java、HTML、JavaScript、Vue等)&#xff0c;如有需要请私信我&#xff0c;或者加我的企鹅号&#xff1a;1404293476 本文资源&#xff1a;https://download.csdn.net/download/weixin_47040861/88725363 目录 1.题目要求 2.实现效…

杨中科 .NET Core 第一部分.NET Standard

1)不讲C#基础语法和NET基础类库(不需要学过ASPNET等)。需要懂HTML、JavaScript、数据库等。后续会录制基础视频 2)使用Visual Studio 2019 .NET .NET Framework Windows 程序 .NET Core 跨平台程序 .NET Standard 上述两者 遵从的标准 .NET5 开始上述统称为 .NET 新建.NET Sta…

pve多台物理机虚拟化 pve虚拟机优势

Proxmox VE是一个运行虚拟机和容器的平台。基于Debian Linux&#xff0c;完全开源。为了获得最大的灵活性&#xff0c;实现了两种虚拟化技术——基于内核的虚拟机(KVM)和基于容器的虚拟化(LXC)。一个主要的设计目标是使管理尽可能容易。运行在单个节点上使用Proxmox VE&#xf…

龍运当头--html做一个中国火龙祝大家龙年大吉

🐉效果展示 🐉HTML展示 <body> <!-- partial:index.partial.html --> <svg><defs><g id=

格密码基础:对偶格(超全面)

目录 一. 对偶格的格点 1.1 基本定义 1.2 对偶格的例子 1.3 对偶格的图形理解 二. 对偶格的格基 2.1 基本定义 2.2 对偶格的格基证明 三. 对偶格的行列式 3.1 满秩格 3.2 非满秩格 四. 重复对偶格 五. 对偶格的转移定理&#xff08;transference theorem&#xff…

现代 C++ 及 C++ 的演变

C 活跃在程序设计领域。该语言写入了许多新项目&#xff0c;而且据 TIOBE 排行榜数据显示&#xff0c;C 的受欢迎度和使用率位居第 4&#xff0c;仅次于 Python、Java 和 C。 尽管 C 在过去二十年里的 TIOBE 排名都位居前列&#xff08;2008 年 2 月排在第 5 名&#xff0c;到…

GPT实战系列-大模型为我所用之借用ChatGLM3构建查询助手

GPT实战系列-https://blog.csdn.net/alex_starsky/category_12467518.html 如何使用大模型查询助手功能&#xff1f;例如调用工具实现网络查询助手功能。目前只有 ChatGLM3-6B 模型支持工具调用&#xff0c;而 ChatGLM3-6B-Base 和 ChatGLM3-6B-32K 模型不支持。 定义好工具的…

【Gin实战教程】快速入门

Gin是一个轻量级的Web框架&#xff0c;使用Go语言开发。它具有高性能、易用性和灵活性的特点&#xff0c;是构建可扩展的Web应用程序的理想选择。 首先&#xff0c;Gin是一个高性能的框架。它基于Go语言的原生HTTP包进行开发&#xff0c;利用了Go语言的并发特性和协程模型&…

聊聊 Java 集合框架中的 ArrayList

其实 Java 集合框架也叫做容器&#xff0c;主要由两大接口派生而来&#xff0c;一个是 collection,主要存放对象的集合。另外一个是Map, 存储着键值对&#xff08;两个对象&#xff09;的映射表。 下面就来说说 List接口&#xff0c;List存储的元素是有序、可重复的。其下有三个…

JAVA实现文件上传至阿里云

注册阿里云账号后,开通好对象存储服务&#xff08;OSS&#xff09;&#xff0c;三个月试用 阿里云登录页 (aliyun.com) 目录 一.创建Bucket 二.获取AccessKey&#xff08;密钥&#xff09; 三.参考官方SDK文件&#xff0c;编写入门程序 1.复制阿里云OSS依赖&#xff0c;粘贴…

Swift单元测试Quick+Nimble

文章目录 使用QuickNimble1、苹果官方测试框架XCTest的优缺点2、选择QuickNimble的原因&#xff1a;3、QuickNimble使用介绍集成&#xff1a;Quick关键字说明&#xff1a;Nimble中的匹配函数等值判断&#xff1a;使用equal函数是否是同一个对象&#xff1a;使用beIdenticalTo函…

【Verilog】期末复习——分别画出下面两个程序综合后的电路图/reg型数据和wire型数据的区别

系列文章 数值&#xff08;整数&#xff0c;实数&#xff0c;字符串&#xff09;与数据类型&#xff08;wire、reg、mem、parameter&#xff09; 运算符 数据流建模 行为级建模 结构化建模 组合电路的设计和时序电路的设计 有限状态机的定义和分类 期末复习——数字逻辑电路分…

基于ssm基于协同过滤技术的网上书城的开发与研究+jsp论文

摘 要 社会发展日新月异&#xff0c;用计算机应用实现数据管理功能已经算是很完善的了&#xff0c;但是随着移动互联网的到来&#xff0c;处理信息不再受制于地理位置的限制&#xff0c;处理信息及时高效&#xff0c;备受人们的喜爱。本次开发一套基于协同过滤技术的网上书城有…

大数据毕业设计:图书推荐系统+可视化+Django框架 图书管理系统 (附源码+论文)✅

毕业设计&#xff1a;2023-2024年计算机专业毕业设计选题汇总&#xff08;建议收藏&#xff09; 毕业设计&#xff1a;2023-2024年最新最全计算机专业毕设选题推荐汇总 &#x1f345;感兴趣的可以先收藏起来&#xff0c;点赞、关注不迷路&#xff0c;大家在毕设选题&#xff…