C++多态、虚函数以及抽象类

目录

1.多态的概念

2.多态的定义及实现

2.1多态的构成条件

2.1.1实现多态还有两个必要条件

2.1.2虚函数 

2.1.3虚函数的重写/覆盖 

2.1.4多态场景的题目

2.1.5虚函数重写的一些其他问题

2.1.5.1协变(了解) 

2.1.5.2析构函数的重写 

2.1.6override和final关键字 

2.1.7重载/重写/隐藏的对比 

3.纯虚函数和抽象类 

4.多态的原理 

4.1虚函数表指针

4.2多态是如何实现的

4.3动态绑定与静态绑定

4.4虚函数表 


1.多态的概念

        多态(polymorphism)的概念:通俗来说,就是多种形态。多态分为编译时多态(静态多态)和运⾏时多态(动态多态)

        编译时多态(静态多态)主要就是我们前⾯讲的函数重载和函数模板,他们传不同类型的参数就可以调⽤不同的函数,通过参数不同达到多种形态,之所以叫编译时多态,是因为他们实参传给形参的参数匹配是在编译时完成的,我们把编译时⼀般归为静态,运⾏时归为动态。

        运⾏时多态,具体点就是去完成某个⾏为(函数),可以传不同的对象就会完成不同的⾏为,就达到多种形态。⽐如买票这个⾏为,当普通⼈买票时,是全价买票;学⽣买票时,是优惠买票(5折或75折);军⼈买票时是优先买票。

2.多态的定义及实现

2.1多态的构成条件

        多态是⼀个继承关系的下的类对象,去调⽤同⼀函数(虚函数),产⽣了不同的⾏为。⽐如Student继承了Person。Person对象买票全价,Student对象优惠买票。

2.1.1实现多态还有两个必要条件

        (1)必须是基类的指针或引用来调用虚函数。(2)被调用的函数必须是虚函数。

        说明:要实现多态效果,第一必须是基类的指针或引用对虚函数进行调用,因为只有基类的指针或引用才即能指向基类对象又能指向派生类对象;第二派生类必须对基类的虚函数进行重写/覆盖,重写/覆盖了之后派生类才能有不同与基类的虚函数,多态的不同形态效果才能达到。

#include <iostream>
using namespace std;class Person
{
public://加virtual关键字写成虚函数virtual void BuyTicket() { cout << "买票-全价" << endl; }
};class Student : public Person
{
public://派生类的虚函数不加virtual关键字也能构成重写,但是不建议这样使用virtual void BuyTicket() { cout << "买票-半价" << endl; }
};void Func(Person* ptr)    //通过父类的指针或引用调用虚函数
{//这里可以看到虽然都是Person指针Ptr在调用BuyTicket//但是跟ptr没关系,而是又ptr指向的对象决定的。ptr->BuyTicket();
}int main()
{Person ps;Student st;Func(&ps);Func(&st);return 0;
}

2.1.2虚函数 

         类成员函数前⾯加virtual修饰,那么这个成员函数被称为虚函数。注意⾮成员函数不能加virtual修饰。

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

2.1.3虚函数的重写/覆盖 

        虚函数的重写/覆盖:派⽣类中有⼀个跟基类完全相同的虚函数(即派⽣类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同),称派⽣类的虚函数重写了基类的虚函数。

        注:(1) 在重写基类虚函数时,派⽣类的虚函数在不加virtual关键字时,虽然也可以构成重写(因为继承后基类的虚函数被继承下来了在派⽣类依旧保持虚函数属性),但是该种写法不是很规范,不建议这样使⽤。(2) 虚函数的重写本质上是重写函数体,参数列表中的缺省值不重写。

        下面用父类(Person类),子类(Student类)以及子类的子类(Pupil类)来演示一些场景。

        场景一:Person类里面的BuyTicket()函数不加virtual,Student类里面的BuyTicket()函数加上或者不加virtual,此时,这两个同名函数构成隐藏关系,使用Person类指针或引用调用时都是调用Person类的BuyTicket()函数。

#include <iostream>
using namespace std;class Person
{
public:void BuyTicket() { cout << "买票-全价" << endl; }
};class Student : public Person
{
public://void BuyTicket() { cout << "买票-半价" << endl; }virtual void BuyTicket() { cout << "买票-半价" << endl; }
};void Func(Person* ptr)
{ptr->BuyTicket();
}int main()
{Person ps;Student st;Func(&ps);Func(&st);return 0;
}

        场景二: Person类里面的BuyTicket()函数加上virtual,Student类里面的BuyTicket()函数加上或者不加virtual,此时,这两个同名虚函数构成重写/覆盖关系,这时构成多态。Func()函数中ptr指向Person对象调用Person类的BuyTicket()函数,指向Student对象调用Student类的BuyTicket()函数。

#include <iostream>
using namespace std;class Person
{
public:virtual void BuyTicket() { cout << "买票-全价" << endl; }
};class Student : public Person
{
public://void BuyTicket() { cout << "买票-半价" << endl; }virtual void BuyTicket() { cout << "买票-半价" << endl; }
};void Func(Person* ptr)
{ptr->BuyTicket();
}int main()
{Person ps;Student st;Func(&ps);Func(&st);return 0;
}

        场景三: Person类里面的BuyTicket()函数加上virtual,Student类里面的BuyTicket()函数加上或者不加virtualPupil类里面的BuyTicket()函数加上或者不加virtual,此时,这三个同名虚函数构成重写/覆盖关系,这时构成多态。Func()函数中ptr指向Person对象调用Person类的BuyTicket()函数,指向Student对象调用Student类的BuyTicket()函数,指向Pupil对象调用Student类的BuyTicket()函数。将Func函数中ptr改为Student*类型,此时父类对象不能传给子类指针或引用,所以不传指向Person对象的指针,但是此时ptr指向Student对象调用Student类的BuyTicket()函数,指向Pupil对象调用Student类的BuyTicket()函数。

#include <iostream>
using namespace std;class Person
{
public:virtual void BuyTicket() { cout << "买票-全价" << endl; }
};class Student : public Person
{
public://void BuyTicket() { cout << "买票-半价" << endl; }virtual void BuyTicket() { cout << "买票-半价" << endl; }
};class Pupil : public Student
{
public://void BuyTicket() { cout << "买票-免费" << endl; }virtual void BuyTicket() { cout << "买票-免费" << endl; }
};void Func(Person* ptr)
{ptr->BuyTicket();
}int main()
{Person ps;Student st;Pupil p;Func(&ps);Func(&st);Func(&p);return 0;
}

void Func(Student* ptr)
{ptr->BuyTicket();
}int main()
{Student st;Pupil p;Func(&st);Func(&p);return 0;
}

        场景四: Person类里面的BuyTicket()函数不加virtual,此时Student类和Pupil类构成相对的父子关系,它们的多态关系是否构成与Person类就没有关系了,就是将上述场景一和场景二中的Person换为Student,Student换为Pupil。

        总结:

        (1)基类中的函数加上virtual,子类中不管该同名函数加不加virtual都重写/覆盖了基类的虚函数。

        (2)只要最开始的基类中的函数是虚函数,下面连续继承的多个类中的同名函数加不加virtual都重写/覆盖了基类的虚函数。

        (3)基类中的函数不是虚函数,此时派生类和派生类的子类中的同名函数加不加virtual都不与基类构成多态。

        (4)基类中的函数不是虚函数,此时派生类和派生类的子类的多态关系和基类无关,派生类和派生类的子类构成相对的继承关系,分析多态关系类似于分析基类和派生类的多态关系。

2.1.4多态场景的题目

        题目的分析写在了代码的注释中。

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;//B类对象能调用test(),是因为test()函数被B类继承下来了//test()函数的原型是:test(A* const this)//这里虽然是传入的B类对象的指针,但是这里的test()函数并没有在B类里面进行重写或者是隐藏,所以这里传入B类的指针还是调用的父类的test()函数//所以p->test()可以看作是this->test(), 这时传给this的是一个B类的指针//里面的func()函数构成多态,this这时存储的是一个B类(子类)的指针//所以这里调用的是子类的虚函数//但是虚函数的重写,只是重写实现,缺省值不重写,所以这时B类中的虚函数原型应该是//void func(int val = 1) { std::cout << "B->" << val << std::endl; }//输出的结果是 B->1p->test();//这里的func()函数的原型是:func(B* const this, int val = 0)//这里的参数列表中不是是基类(A类)的指针和引用,所以不构成多态//相当于只是对A类中func()进行了隐藏,所以这里就是直接调用了B类中的func()函数//输出的结果是 B->0p->func();//虚函数重写时不重新定义继承而来的缺省值,但是隐藏的话缺省值是会改变的return 0;
}

2.1.5虚函数重写的一些其他问题

2.1.5.1协变(了解) 

        派⽣类重写基类虚函数时,允许与基类虚函数的返回值类型不同但基类虚函数返回基类对象的指针或者引⽤,派⽣类虚函数返回派⽣类对象的指针或者引⽤时,称为协变。协变的实际意义并不⼤,所以我们了解⼀下即可。

        注意:这里返回的基类对象的指针或引用不一定是当前虚函数所在的基类,返回的派生类对象的指针或引用也不一定是当前派生类虚函数所在的派生类,可以是外面定义的两个类,只要这两个类构成继承关系即可。

#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;}
};void Func(Person* ptr)
{ptr->BuyTicket();
}int main()
{Person ps;Student st;Func(&ps);Func(&st);return 0;
}

2.1.5.2析构函数的重写 

        基类的析构函数为虚函数,此时派⽣类析构函数只要定义,⽆论是否加virtual关键字,都与基类的析构函数构成重写,虽然基类与派⽣类析构函数名字不同看起来不符合重写的规则,实际上编译器对析构函数的名称做了特殊处理,编译后析构函数的名称统⼀处理成destructor,所以基类的析构函数加了vialtual修饰,派⽣类的析构函数就构成重写。

        下⾯的代码我们可以看到,如果~A(),不加virtual,那么delete p2时只调⽤的A的析构函数,没有调⽤B的析构函数,就会导致内存泄漏问题,因为在~B()中在释放B类申请的资源。

#include <iostream>
using namespace std;class A
{
public:virtual ~A(){cout << "~A()" << endl;}
};
class B : public A {
public://不加virtual也构成重写virtual ~B(){cout << "~B()->delete:" << _p << endl;delete _p;}
protected:int* _p = new int[10];
};int main()
{A* p1 = new A;//这里是希望父类指针在调用析构函数时,指向父类对象调父类的析构函数,指向子类对象调子类的析构函数A* p2 = new B;delete p1;//期望先调用的是子类(B类)的析构函数,在调用父类(A类)的析构函数//这里如果在A类的析构函数不加virtual,只是调用的是父类(A类)的析构函数//如果这时在子类(B类)中有额外的资源申请,只调用父类(A类)的析构函数,就会存在内存泄漏的问题delete p2;return 0;
}

2.1.6override和final关键字 

        C++对函数重写的要求⽐较严格,但是有些情况下由于疏忽,⽐如函数名写错参数写错等导致⽆法构成重载,⽽这种错误在编译期间是不会报出的,只有在程序运⾏时没有得到预期结果才来debug会得不偿失,因此C++11提供了override,可以帮助⽤⼾检测是否重写。如果我们不想让派
⽣类重写这个虚函数,那么可以⽤final去修饰。

// error C3668: “Benz::Drive”: 包含重写说明符“override”的⽅法没有重写任何基类⽅法
class Car {
public:virtual void Dirve()
{}
};
class Benz :public Car {
public:virtual void Drive() override { cout << "Benz-舒适" << endl; }
};
int main()
{return 0;
}
// error C3248: “Car::Drive”: 声明为“final”的函数⽆法被“Benz::Drive”重写
class Car
{
public:virtual void Drive() final {}
};
class Benz :public Car
{
public:virtual void Drive() { cout << "Benz-舒适" << endl; }
};
int main()
{return 0;
}

2.1.7重载/重写/隐藏的对比 

        因为这三个关系都是同名函数之间的关系,所以这里进行一下总结。

3.纯虚函数和抽象类 

        在虚函数的后⾯写上 =0 ,则这个函数为纯虚函数,纯虚函数不需要定义实现(实现没啥意义因为要被派⽣类重写,但是语法上可以实现),只要声明即可。包含纯虚函数的类叫做抽象类,抽象类不能实例化出对象,如果派⽣类继承后不重写纯虚函数,那么派⽣类也是抽象类。纯虚函数某种程度上强制了派⽣类重写虚函数,因为不重写实例化不出对象。

#include <iostream>
using namespace std;class Car
{
public://纯虚函数virtual void Drive() = 0;
};class BenZ : public Car
{
public://不重写这个纯虚函数,此时BenZ这个类也是抽象类virtual void Drive(){cout << "BenZ-舒适" << endl;}
};int main()
{//不能实例化对象// 编译报错:error C2259: “Car”: ⽆法实例化抽象类//Car c;//但是可以使用抽象类的指针Car* pBenZ = new BenZ;pBenZ->Drive();return 0;
}

4.多态的原理 

4.1虚函数表指针

class Base
{
public:virtual void Func1(){cout << "Func1()" << endl;}
protected:int _b = 1;char _ch = 'x';
};
int main()
{Base b;cout << sizeof(b) << endl;return 0;
}

        上⾯代码在32位机器下运⾏结果是12bytes,除了_b和_ch成员,还多⼀个__vfptr放在对象的前⾯(注意有些平台可能会放到对象的最后⾯,这个跟平台有关),对象中的这个指针我们叫做虚函数表指针(v代表virtual,f代表function)。⼀个含有虚函数的类中都⾄少都有⼀个虚函数表指针,因为⼀个类所有虚函数的地址要被放到这个类对象的虚函数表中,虚函数表也简称虚表。

4.2多态是如何实现的

class Person {
public:virtual void BuyTicket() { cout << "买票-全价" << endl; }
protected:string _name;
};
class Student : public Person {
public:virtual void BuyTicket() { cout << "买票-打折" << endl; }
protected:int _id;
};
class Soldier : public Person {
public:virtual void BuyTicket() { cout << "买票-优先" << endl; }
protected:string _codename;
};
void Func(Person* ptr)
{//这里是通过Person指针进行参数的接收,不管传的是Person指针,Student指针还是Soldier指针,//对于ptr来说指向的都是一个存有虚表指针和Person成员变量的对象。ptr->BuyTicket();
}
int main()
{// 其次多态不仅仅发⽣在派⽣类对象之间,多个派⽣类继承基类,重写虚函数后// 多态也会发⽣在多个派⽣类之间。Person ps;Student st;Soldier sr;Func(&ps);Func(&st);Func(&sr);return 0;
}

        同一类对象有相同的虚表指针,指向该类的同一个虚表(本质是一个虚函数指针数组),不同的类对象有不同的虚表指针,指向各自类的虚函数表。 

       满⾜多态条件后,底层不再是编译时通过调⽤对象确定函数的地址,⽽是运⾏时到指向的对象对应的虚表中确定对应虚函数的地址,这样就实现了指针或引⽤指向基类就调⽤基类的虚函数,指向派⽣类就调⽤派⽣类对应的虚函数。

4.3动态绑定与静态绑定

        静态绑定:对不满⾜多态条件(指针或者引⽤+调⽤虚函数)的函数调⽤是在编译时绑定,也就是编译时确定调⽤函数的地址,叫做静态绑定。

        动态绑定:满⾜多态条件的函数调⽤是在运⾏时绑定,也就是在运⾏时到指向对象的虚函数表中找到调⽤函数的地址,也就做动态绑定。

        观察下列不满足多态和满足多态的汇编代码:

4.4虚函数表 

        (1)基类的虚函数表中存放基类所有虚函数的地址。

        (2)派⽣类由两部分构成,继承下来的基类和⾃⼰的成员,⼀般情况下,继承下来的基类中有虚函数表指针,⾃⼰就不会再⽣成虚函数表指针。但是要注意的这⾥继承下来的基类部分虚函数表指针和基类对象的虚函数表指针不是同⼀个,就像基类对象的成员和派⽣类对象中的基类对象成员也独⽴的。

        (3)派⽣类的虚函数表中包含,基类的虚函数地址,派⽣类重写的虚函数地址(派生类重写基类的虚函数之后,在派生类的虚表中就用这个重写的虚函数地址替代了基类的虚函数地址),派⽣类⾃⼰的虚函数地址三个部分。

#include <iostream>
using namespace std;class Base {
public:virtual void func1() { cout << "Base::func1" << endl; }virtual void func2() { cout << "Base::func2" << endl; }void func5() { cout << "Base::func5" << endl; }
protected:int a = 1;
};
class Derive : public Base
{
public:// 重写基类的func1virtual void func1() { cout << "Derive::func1" << endl; }virtual void func3() { cout << "Derive::func1" << endl; }void func4() { cout << "Derive::func4" << endl; }
protected:int b = 2;
};
int main()
{Base b;Derive d;return 0;
}

         上述在d中这个虚表指针指向的虚表中应该还有一个Derive::fun3(void)虚函数,只是这里因为vs2022监视窗口的原因,没有显示出来。

        (4)虚函数表本质是⼀个存虚函数指针的指针数组,⼀般情况这个数组最后⾯放了⼀个0x00000000标记。(这个C++并没有进⾏规定,各个编译器⾃⾏定义的,vs系列编译器会再后⾯放个0x00000000标记,g++系列编译不会放)

        这里我们通过内存窗口看看上述b对象对应的虚函数表:

        在这里可以直观的看出b对象对应的虚表中是有三个虚函数的地址的,且数组最后放了一个0x00000000的标记。

        (5)虚函数和普通函数⼀样的,编译好后是⼀段指令,都是存在代码段的,只是虚函数的地址⼜存到了虚表中。

        (6)虚函数表存在哪的?这个问题严格说并没有标准答案C++标准并没有规定,我们写下⾯的代码可以对⽐验证⼀下。vs下是存在代码段(常量区)

#include <iostream>
using namespace std;class Base {
public:virtual void func1() { cout << "Base::func1" << endl; }virtual void func2() { cout << "Base::func2" << endl; }void func5() { cout << "Base::func5" << endl; }
protected:int a = 1;
};
class Derive : public Base
{
public:// 重写基类的func1virtual void func1() { cout << "Derive::func1" << endl; }virtual void func3() { cout << "Derive::func1" << endl; }void func4() { cout << "Derive::func4" << endl; }
protected:int b = 2;
};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);Base b;Derive d;Base* p3 = &b;Derive* p4 = &d;printf("Person虚表地址:%p\n", *(int*)p3);printf("Student虚表地址:%p\n", *(int*)p4);printf("虚函数地址:%p\n", &Base::func1);printf("普通函数地址:%p\n", &Base::func5);return 0;
}

        从结果中可以看出,虚函数表的地址和常量区的地址最接近,虚函数的地址和普通函数的地址最接近,在vs2022下可以看出,虚函数表和虚函数大概都是存在代码段(常量区)。

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

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

相关文章

【Springer上传手稿记录】《Signal, Image and Video Processing》

Springer上传手稿记录 以signal&#xff0c;image and video proecessing为例上传手稿或图片时提示上传失败无法编译成pdf错误1&#xff1a;出现Unknown theoremstyle相关错误错误2&#xff1a;command Illegal错误3&#xff1a;command I found no style file 通用问题问题1&a…

CORE MVC 过滤器 (筛选器)《2》 TypeFilter、ServiceFilter

TypeFilter、ServiceFilter ServiceFilter vs TypeFilter ServiceFilter和TypeFilter都实现了IFilterFactory ServiceFilter需要对自定义的Filter进行注册&#xff0c;TypeFilter不需要 ServiceFilter的Filter生命周期源自于您如何注册&#xff08;全局、区域&#xff09;&…

【AI学习】Mamba学习(二):线性注意力

上一篇《Mamba学习&#xff08;一&#xff09;&#xff1a;总体架构》提到&#xff0c;Transformer 模型的主要缺点是&#xff1a;自注意力机制的计算量会随着上下文长度的增加呈平方级增长。所以&#xff0c;许多次二次时间架构&#xff08;指一个函数或算法的增长速度小于二次…

SpringBoot框架下校园资料库的构建与优化

1系统概述 1.1 研究背景 如今互联网高速发展&#xff0c;网络遍布全球&#xff0c;通过互联网发布的消息能快而方便的传播到世界每个角落&#xff0c;并且互联网上能传播的信息也很广&#xff0c;比如文字、图片、声音、视频等。从而&#xff0c;这种种好处使得互联网成了信息传…

10.5今日错题解析(软考)

目录 前言面向对象技术——设计模式的应用场景计算机组成与体系结构——逻辑运算 前言 这是用来记录我备考软考设计师的错题的&#xff0c;今天知识点为设计模式的应用场景、逻辑运算&#xff0c;大部分错题摘自希赛中的题目&#xff0c;但相关解析是原创&#xff0c;有自己的…

【Python】Dejavu:Python 音频指纹识别库详解

Dejavu 是一个基于 Python 实现的开源音频指纹识别库&#xff0c;主要用于音频文件的识别和匹配。它通过生成音频文件的唯一“指纹”并将其存储在数据库中&#xff0c;来实现音频的快速匹配。Dejavu 的主要应用场景包括识别音乐、歌曲匹配、版权管理等。 ⭕️宇宙起点 &#x1…

class 004 选择 冒泡 插入排序

我感觉这个真是没有什么好讲的, 这个是比较简单的, 感觉没有什么必要写一篇博客, 而且这个这么简单的排序问题肯定有人已经有写好的帖子了, 肯定写的比我好, 所以我推荐大家直接去看“左程云”老师的讲解就很好了, 一定是能看懂的, 要是用文字形式再写一遍, 反而有点画蛇添足了…

windows下安装rabbitMQ并开通管理界面和允许远程访问

如题&#xff0c;在windows下安装一个rabbitMQ server&#xff1b;然后用浏览器访问其管理界面&#xff1b;由于rabbitMQ的默认账号guest默认只能本机访问&#xff0c;因此需要设置允许其他机器远程访问。这跟mysql的思路很像&#xff0c;默认只能本地访问&#xff0c;要远程访…

Oracle架构之表空间详解

文章目录 1 表空间介绍1.1 简介1.2 表空间分类1.2.1 SYSTEM 表空间1.2.2 SYSAUX 表空间1.2.3 UNDO 表空间1.2.4 USERS 表空间 1.3 表空间字典与本地管理1.3.1 字典管理表空间&#xff08;Dictionary Management Tablespace&#xff0c;DMT&#xff09;1.3.2 本地管理方式的表空…

计算机网络(十) —— IP协议详解,理解运营商和全球网络

目录 一&#xff0c;关于IP 1.1 什么是IP协议 1.2 前置认识 二&#xff0c;IP报头字段详解 三&#xff0c;网段划分 3.1 IP地址的构成 3.2 网段划分 3.3 子网划分 3.4 IP地址不足问题 四&#xff0c;公网IP和私有IP 五&#xff0c;理解运营商和全球网络 六&#xff…

基于大数据技术的颈椎病预防交流与数据分析及可视化系统

作者&#xff1a;计算机学姐 开发技术&#xff1a;SpringBoot、SSM、Vue、MySQL、JSP、ElementUI、Python、小程序等&#xff0c;“文末源码”。 专栏推荐&#xff1a;前后端分离项目源码、SpringBoot项目源码、Vue项目源码、SSM项目源码 精品专栏&#xff1a;Java精选实战项目…

【优选算法】(第二十一篇)

目录 外观数列(medium) 题目解析 讲解算法原理 编写代码 数⻘蛙&#xff08;medium&#xff09; 题目解析 讲解算法原理 编写代码 外观数列(medium) 题目解析 1.题目链接&#xff1a;. - 力扣&#xff08;LeetCode&#xff09; 2.题目描述 给定⼀个正整数n&#xff0…

算法篇1:双指针思想的运用(1)--C++

一.算法解析 双指针&#xff0c;顾名思义就是两个指针&#xff0c;常见的算法中&#xff0c;我们可以看到两种&#xff1a; 1.对撞指针&#xff1a;一般用于顺序结构&#xff0c;也称为左右指针。 对撞指针从两端向中间移动。一个指针从最左端开始&#xff0c;另一个从最右端…

Yolov8轻量级网络改进GhostNet

1,理论部分 由于内存和计算资源有限,在移动设备上部署卷积神经网络 (CNN) 很困难。我们的目标是通过利用特征图中的冗余,为 CPU 和 GPU 等异构设备设计高效的神经网络,这在神经架构设计中很少被研究。对于类 CPU 设备,我们提出了一种新颖的 CPU 高效 Ghost (C-Ghost) …

Mysql:数据库和表增删查改基本语句

一、数据库操作 1&#xff09;、数据库创建 创建数据库本质就是创建一个目录&#xff08;ubuntu&#xff0c;创建的目录文件存放在/var/lib/mysql&#xff09;&#xff1b;后续创建表本质就是在该目录下创建文件&#xff08;不同存储引擎&#xff0c;会创建的文件数目是不同的…

PASCAL VOC 2012数据集 20类物体,这些物体包括人、动物(如猫、狗、鸟等)、交通工具(如车、船、飞机等)以及家具(如椅子、桌子、沙发等)。

VOC2012数据集是PASCAL VOC挑战赛官方使用的数据集之一&#xff0c;主要包含20类物体&#xff0c;这些物体包括人、动物&#xff08;如猫、狗、鸟等&#xff09;、交通工具&#xff08;如车、船、飞机等&#xff09;以及家具&#xff08;如椅子、桌子、沙发等&#xff09;。每个…

计算机网络:物理层 —— 物理层下的传输媒体

文章目录 传输媒体导向性媒体同轴电缆双绞线光纤光纤分类中心波长光纤规格光纤的优缺点 非导向性媒体ISM 频段无线电波微波激光红外线可见光 传输媒体 传输媒体是计算机网络设备之间的物理通路&#xff0c;也称为传输介质或传输媒介&#xff0c;并不包含在计算机网络体系结构中…

github项目——系统设计入门

今天的github趋势&#xff0c;有几个项目印象感觉很有意思&#xff0c;之后可能会用的上&#xff0c;记录一下 系统设计入门 书籍教程类项目&#xff0c;有中文文档&#xff0c;刚好需要。 https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md…

Linux之实战命令26:timeout应用实例(六十)

简介&#xff1a; CSDN博客专家、《Android系统多媒体进阶实战》一书作者 新书发布&#xff1a;《Android系统多媒体进阶实战》&#x1f680; 优质专栏&#xff1a; Audio工程师进阶系列【原创干货持续更新中……】&#x1f680; 优质专栏&#xff1a; 多媒体系统工程师系列【…

postgresql|数据库|postgis编译完成后的插件迁移应该如何做(postgis插件最终章)

一、 本文的写作理由 postgis插件一般是编译安装&#xff0c;编译安装的原因是可以选择自己喜欢的版本&#xff0c;但编译的难度也是比较高的&#xff0c;因为有各种依赖&#xff0c;依赖之间还有依赖&#xff0c;非常容易形成依赖循环&#xff0c;因此&#xff0c;失败率是比…