【C++从入门到踹门】第十三篇：多态

最新推荐文章于 2024-10-02 22:25:35 发布
最新推荐文章于 2024-10-02 22:25:35 发布
阅读量1.6k 收藏 3
点赞数 9
分类专栏： C++ 文章标签： c++ 多态
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43041053/article/details/124414469
版权

目录


在这里插入图片描述

1.多态概念

看上去用的是一个函数，实际上一个函数可以有多种形态。

目前我们接触过的多态有 函数重载 和 运算符重载。

如果以现实生活举例子，去游乐园购票就类似于多态行为：

  • 成人购票全价
  • 学生购票半价
  • 儿童购票免费

购票这同一行为，当不同的个体去进行调用的时候它就体现出不同的行为特征。

2.多态实现

2.1 构成多态的条件

  1. 必须通过父类的指针或者引用调用虚函数
  2. 被调用的函数必须是虚函数，且子类必须对父类的虚函数进行重写

构成多态可以让父类的指针（及引用）具有了多种行为。

2.2 虚函数的重写

虚函数重写（又称覆盖）：子类有一个与父类完全相同的虚函数（两者函数名，参数列表，返回值完全一致）,且继承了父类的属性（访问限定符）。

class Person
{
public:
	virtual void Buy()//父类虚函数
	{
		cout << "全价票" << endl;
	}
};

class Student :public Person
{
public:
	virtual void Buy()//子类对父类虚函数的重写
	{
		cout << "半价票" << endl;
	}
};

class Child :public Person
{
public:
	virtual void Buy()//子类对父类虚函数的重写
	{
		cout << "免费" << endl;
	}
};

被virtual修饰的才能称为虚函数，子类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继承后父类的虚函数被继承下来了在子类依旧保持虚函数属性),但是该种写法不规范，不建议这样使用。

而且必须要使用父类的指针或者引用去调用子类对象的虚函数，如果子类对象直接给父类对象赋值然后再调用，结果将直接是调用父类的虚函数。

原因将在后面介绍。

虚函数重写特例

  1. 协变

父类虚函数的返回值与子类的返回值可以不同，但是必须满足：

  • 父类虚函数返回父类（当前类或者其他类）对象的指针或引用，子类虚函数返回子类对象的指针或引用。

见下例

class A
{};
class B:public A
{};
class Person
{
public:
    virtual A* func()
    {
        cout<<"Person::func()"<<endl;
        return new A;
    }
};
class Student:public Person
{
public:
    virtual B* func()
    {
        cout<<"Student::func()"<<endl;
        return new B;
    }
};
int main()
{
	Person p;
	Student s;
	Person* ptr = &p;
	ptr->func();
	ptr = &s;
	ptr->func();
	return 0;
}

2.析构函数的重写(父类与子类析构函数的名字不同)

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

在普通场景下，父子的析构函数重写与不重写没有差别：

在父类指针new了两者的对象，delete的场景下，父子的析构函数重写就起了大作用：

子类析构不重写的话，只会调用父类的析构函数，析构的只是子类中的父类成员，于是可能会造成内存泄漏（子类成员需要释放空间的情况）。

2.3 虚函数性质

  1. 只有类的非静态成员函数才可以是虚函数，普通函数不可以。

  2. 虚函数与虚继承没有关系。

    虚函数是为了实现多态。

    虚继承是为了解决菱形继承的数据冗余和二义性。

  3. 虚表指针在什么阶段初始化的？虚表是在什么阶段生成的？

    构造函数的初始化列表阶段生成虚表指针。虚表在编译时就生成了

  4. 虚函数在虚表里吗？

    并不是，虚表里存放的是虚函数而定指针，而函数的实现代码存放在代码段里。

  5. 子类的虚表如何而来？

    拷贝父类的虚表，如果有重写，就覆盖虚表中的相应内容。如果有新增虚函数则添加在之后。

  6. 虚表存在哪里？

    虚表存放在代码段中。

  7. 获得虚表中虚函数的地址

    虚表以nullptr作为结束，而且虚表存放于对象的内存中的起始位置。

    我们试用程序，罗列出虚表中的元素（虚函数指针）：

    由于指针大小是4字节，被我们强转成（int*）

    int main()
{
	A a;
	A* pa = &a;
	printf("vfptr:%p\n", *((int*)pa));

	int* ptr = (int*)(*(int*)pa);
	while (1)
	{
		printf("%p\n", *ptr);
		ptr += 1;
		if(*ptr==0)
			break;
	}

}

    注意：执行这段程序前需要先清理解决方案。

2.4 override 、final （C++11）

  1. final：修饰虚函数，表示该虚函数不能再被重写。修饰类，表示该类不能继承。
class Car
{
public:
	virtual void Drive() final {}
};
class Benz :public Car
{
public:
	virtual void Drive() {cout << "Benz-舒适" << endl;}//此处报错，Drive不能被重写
};

class Car final
{
public:
	virtual void Drive()  {}
};
class Benz :public Car//报错，Car不能被继承
{
public:
	virtual void Drive() {cout << "Benz-舒适" << endl;}
};

在C++11以前防止继承的做法

  • 单例模式
class A
{
private:
	A(int a=0):_a(a)//构造函数为私有便不能继承，因为子类对象构造时需要调用父类的构造，但是不可见
	{
	}
public:
	static A CreatA(int a=0)//A类自己调用构造需要使用静态，因为构造前没有对象，需要用类域调用
	{
		return A(a);
	}
protected:
	int _a;
};

int main()
{
	A aa=A::CreatA(10);
	return 0;
}
  1. override: 检查子类虚函数是否重写了基类某个虚函数，如果没有重写编译报错
class Car{
public:

};
class Benz :public Car {
public:
	virtual void Drive() override {cout << "Benz-舒适" << endl;}//此处报错，因为父类没有Drive虚函数，这里不构成重写
};

2.5 重载、覆盖（重写）、隐藏（重定义）的区别

3.抽象类

抽象是从众多的事物中抽取出共同的、本质性的特征，而舍弃其非本质的特征的过程。

3.1 抽象类的概念

  • 在虚函数的后面写上 =0 ，则这个函数为纯虚函数。
  • 包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。
  • 子类继承后也不能实例化出对象，只有重写纯虚函数，子类才能实例化出对象。
  • 纯虚函数规范了子类必须重写，另外纯虚函数更体现出了接口继承。
//动物类为抽象
class Animal
{
public:
	virtual void Eat() = 0;
};

//猫为实体
class Cat :public Animal
{
public:
	virtual void Eat()
	{
		cout << "cat eat fish" << endl;
	}
};

int main()
{
	Animal* pa;
	Cat c;//Cat类的实例化
	pa = &c;
	pa->Eat();
	return 0;
}

3.2 接口继承和实现继承

  • 普通成员函数的继承是一种实现继承，子类继承了父类，同时也继承了函数的实现。
  • 虚函数的继承是一种接口继承，子类继承的是父类的虚函数接口，目的是为了重写达成多态。

如果不是为了实现多态就不要把成员函数定义为虚函数。

4.多态的原理

我们来计算一个包含虚函数的类A的大小

发现和普通类的大小不一样，调试一下：

其中多了一个 _vfptr的“成员”，它实际上是一个虚函数表指针，指向了虚函数表 。

4.1 虚函数表

对象中的 _vfptr指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。

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

class Student :public Person
{
public:
	virtual void Buy()
	{
		cout << "半价票" << endl;
	}
};

class Child :public Person
{
public:
	virtual void Buy()
	{
		cout << "免费" << endl;
	}
};
int main()
{
	Person p;
	Student s;
	Child c;
	return 0;
}

当子类对虚函数重写，就会将重写的虚函数覆盖掉虚函数表中的原虚函数：

如果不重写虚函数，则虚函数表中指向的函数将不变

注意：即使子类缺省virtual的同名同参的成员函数还是会默认重写（因为父类写的是虚函数，子类将默认成为虚函数），我们说的不重写是完全不写这个函数。此时不构成多态。

虚函数表中元素依旧是指向父类的虚函数的地址，没有达到多态的要求。所以父类一旦写了虚函数，为构成多态就要在子类中去重写它。

总结：

  1. 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。

  2. 总结一下子类的虚表生成：

    a. 先将父类中的虚表内容拷贝一份到子类虚表中

    b. 如果子类重写了父类中某个虚函数，用子类自己的虚函数覆盖虚表中父类的虚函数

    c. 子类自己新增加的虚函数按其在子类中的声明次序增加到子类虚表的最后。

⚠ 注意：

虚继承和虚函数没有关系，使用场景不一样，解决的也是完全不同的问题。

虚函数表区别于虚继承的虚基表：

虚基表中存放的是 virtual继承的子类与父类成员的偏移量。

4.2 多态原理

构成多态：父类指针或者引用调用虚函数时，不是编译时确定的，而是运行时到指向对象的虚表中去找虚函数进行调用。指向哪一个对象，当然就调用哪一个对象的虚函数。所以多态与对象相关。

不构成多态：编译时就根据类型确定该调用哪一个函数，跟传来的是什么对象没有关系。

首先需要确定的是，同一个类的对象的虚函数表是一样的。

上图中，当func的函数参数为父类本身（Person）时，无论我们传入的是父类对象，还是子类对象（切片只会拷贝成员变量，不会拷贝虚函数表），虚函数表将根据p本身的类型而定，p作为父类类型的对象，他的虚函数表将始终是父类的虚函数表。

可以理解为同类型对象共享一张虚表，父类有父类的虚表指针，子类有子类的虚表指针。

当子类给父类赋值，该父类的虚表指针仍是父类自己的。

所以在我们传入子类时，调用的还是父类的虚函数，没有起到多态的效果。

而func函数参数为指针或者引用，那 p访问的就是对象本身，访问的虚函数表自然也是父类或者子类本身（根据传入对象而定）的虚函数表。

4.3 动态绑定与静态绑定

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

5.单继承与多继承的虚函数表

5.1 单继承虚函数表

单继承的子类虚函数表已在上面讲述，这里贴张图解释下：

Derive 类继承了 Base1类，复制了Base1的虚表，重写的虚函数就进行覆盖，Derive新增的虚函数就添加在后面。

5.2 多继承虚函数表

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） 每个父类都有自己的虚表。

2） 子类的成员函数被放到了第一个父类的表中。（所谓的第一个父类是按照声明顺序来判断的）

这样做就是为了解决不同的父类类型的指针指向同一个子类实例，而能够调用到实际的函数。

Derive类继承了Base1和Base2，这时会有两张虚表分别对应Base1和Base2的虚函数地址。

如果Derive进行了重写，便会对虚表中原来的虚函数地址进行覆盖。如果重写的虚函数恰好出现在两个父类中，那么就同时对两个虚函数进行重写。

Derive新增的虚函数会放在第一个继承的父类的虚函数表中。（这里由于vs显示问题，没有指出Derive::func3()的存放情况，但是可以通过内存窗口查看）

5.3 打印虚表中的虚函数地址

  1. 得到Derive对象d的指针pd
  2. 将pd指向的内存的首位4字节内容强转成 int* 赋给ptr1，ptr1的值就是d中Base1的虚表指针。
  3. 将pd强转成 char*，加上sizeof(Base1)个字节后，强转int*，指向前四个字节内容，再解引用得到Base2的虚表的地址,强转int*后赋给ptr2。
int main()
{
	Derive d;
	Derive* pd = &d;

	int* ptr1 = (int*)(*(int*)pd);
	printf("Base1的vfptr:%p\n", ptr1);
	for(int i=0;*ptr1!=0;++i)
	{
		printf("vfptr[%d]:%p\n",i, *ptr1);
		ptr1 += 1;

	}
	cout << endl;

	int* ptr2 = (int*)(*(int*)((char*)pd + sizeof(Base1)));
	printf("Base2的vfptr:%p\n", ptr2);
	for (int i = 0; *ptr2 != 0; ++i)
	{
		printf("vfptr[%d]:%p\n", i, *ptr2);
		ptr2 += 1;
	}


	return 0;
}

结果：

5.3 菱形虚拟继承

我们在继承中讨论过，菱形继承为避免重复继承的情况，在中间的继承关系前加上virtual表示虚拟继承。

Derive 实例化的对象d只包含一份Ace的数据。

如果Ace中有虚函数，那么Base1和Base2同时对其重写会产生歧义，导致编译错误，因为Derive的对象中的Ace虚表不知道采用哪一个类的重写（除非Derive对Base1，2的对A继承的虚函数全部重写）。

我们看一下菱形虚继承情况下的虚函数表以及虚基表的布局情况：

我在Base1和Base2中各自添加了虚函数，Base1_self(),和Base2_self()。实验代码如下：

class Ace
{
public:
	virtual void func1()
	{
		cout << "A::func1" << endl;
	}
	virtual void func2()
	{
		cout << "A::func2" << endl;
	}
	int a;
};

class Base1 :virtual public Ace
{
public:
	virtual void Base1_self()
	{
		cout << "Base1_self" << endl;
	}

	int b1;
};

class Base2 :virtual public Ace
{
public:
	virtual void Base2_self()
	{
		cout << "Base2_self" << endl;
	}

	int b2;
};

class Derive :public Base1, public Base2
{
public:
	virtual void func1()
	{
		cout << "Derive::func1" << endl;
	}
	virtual void func3()
	{
		cout << "Derive::func3" << endl;
	}

	int d1;
};

以中间类Base2为例（Base1也是同样的结构）：

与普通多继承不同的是，多态多继承内存中，子类Derive的对象d的内存中的每个父类不仅仅有虚基表指针，在其上还有虚函数表指针（虚函数表只包含该类自己的虚函数），同时Base1虚基表中的首4位字节存放了该虚基表与虚函数表的偏移量，后四个字节存放了该虚基表与它的父类（Ace）的偏移量。

6.继承与多态常见问题

  1. 重写会复用父类的函数声明，重写的只是函数定义：
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;
}

p 调用test后，p会给test的this指针赋值，于是构成多态：this->func()

this指向p（B类指针），将调用B::func(),又因为重写不理会缺省值，只要参数类型、函数名、返回值对应即可，所以延用A的缺省值val=1，所以输出 B->1

  • 虚函数表与虚函数表指针的生成时间

答： 虚函数表是在编译时生成的，虚函数表指针是运行时确定的。

  • inline函数是否可以做虚函数？

答：可以，不过编译器就忽略inline属性，这个函数就不再是inline，因为虚函数要放到虚表中去，而内联的函数不会提供函数地址。

  • 静态成员可以是虚函数吗？

答：不能，因为静态成员函数没有this指针，使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。

  • 构造函数可以是虚函数吗？

答：不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。虚函数对应一个虚指针，虚指针其实是存储在对象的内存空间的。

如果构造函数是虚函数，就需要通过虚函数表中对应的虚函数指针（编译期间生成属于类）来调用，可对象目前还没有实例化，也即是还没有内存空间，何来的虚指针，所以构造函数不能是虚函数；

虚函数的作用在于通过父类的指针或者引用来调用它的成员函数的时候，能够根据动态类型来调用子类相应的成员函数。而构造函数是在创建对象时自动调用的，不可能通过父类的指针或者引用去调用，所以构造函数不能是虚函数；

  • 析构函数可以是虚函数吗？什么场景下析构函数是虚函数？

答：可以，并且最好把基类的析构函数定义成虚函数。在delete时。

  • 对象访问普通函数快还是虚函数更快？

答：首先如果是普通对象，是一样快的。如果是指针对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找。

  • 虚函数表存在哪的？虚函数表指针存在哪里

答：虚函数表是在编译阶段就生成的，一般情况下存在代码段(常量区)的。虚函数表指针存在栈上。

青山不改 绿水长流

大桑树保安队
关注
专栏目录
【C++从入门到入土】第一篇：从C到C++
qq_52145272的博客
08-21 2335
文章目录前言一、C++是什么？二、C++基础1、输入输出特点和用法2、数据类型与表达式C++中的数据类型基本数据类型构造数据类型3、动态内存管理用new运算符实现动态内存分配用delete运算符释放动态分配的内存4、函数重载函数的缺省参数5、内联函数6、引 用引用作为函数的返回值7、常 量总结 前言 面向对象是什么？很难吗？面向对象有什么好处？ 让我们先了解一下C++入门基础 一、C++是什么？ C++是C语言的继承，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对
C++从入门到精通 第十七章（终极案例）
Zevalin的博客
02-21 1235
学生可以预约未来一周内的机房使用，预约的日期为周一至周五，预约时需要选择预约时段（上午、下午）；（1）公司中职工分为普通员工、经理、老板三类，显示信息时需要显示职工编号、职工姓名、职工岗位、以及职责。②增加职工信息：实现批量添加职工功能，将信息录入到文件中，职工信息为：职工编号、姓名、部门编号。⑥当小组演讲完后，根据评分淘汰组内排名最后的三个选手，前三名晋级，进入下一轮的比赛。[4]取消预约——取消自身的预约，预约成功或审核中的预约均可取消。③比赛方式：分组比赛，每组6个人，选手每次要随机分组，进行比赛。
【初阶与进阶C++详解】第十四篇：多态（虚函数+重写（覆盖）+抽象类+单继承和多继承+override+final）
YQ20210216的博客
09-21 779
必须有基类的指针或引用调用被调用的函数必须是虚函数，其派生类必须对基类的虚函数进行重写原因1：基类和派生类都有自己的虚表，如果通过值传递的话，基类可能会拿到派生类的虚表原因2：有虚函数就有虚函数表，对象当中就会存放一个虚基表指针，通过虚基表指针指向的内容来访问对应的函数。若子类没有重写父类的虚函数内容，则子类也会调用父类的函数。下面是演示。
C++（第十二篇）：多态(虚函数、抽象类、虚函数表、虚表指针、多继承下的多态)
杨同学的博客
12-15 570
多态是在继承关系中不同的类对象，去调用同一函数，产生了不同的行为。比如 Student 继承了 Person。Person 对象买票全价，Student 对象买票半价。在继承中要构成多态构成多态的函数必须是虚函数，且派生类必须对基类的虚函数进行重写(覆盖)。必须通过基类的指针或者引用调用虚函数，通过父类的对象调用只会调用父类成员，不会构成多态。满足上述条件后，基类的指针指向基类对象则调用基类的虚函数，指向派生类对象则调用派生类的虚函数。构成多态，指向谁就调用谁的虚函数，跟对象有关。
C++从入门到入土（入土第15天）
Kunjpg的博客
05-25 664
C++基础语法； C++面向对象编程
C++从入门到精通(第5版) MRKJ视频讲解+源码+PPT
。
08-08 485
B.4 Visual Studio 2019常用快捷键 440。B.3 Visual Studio 2019菜单功能 437。附录A Visual C++ 6.0 常用快捷键 426。附录B Visual Studio 2019简介 430。B.1 安装Visual Studio 2019 430。A.2 Visual C++ 6.0常用快捷键 428。7.4.4 指向空的指针与空类型指针 128。7.4.5 指向常量的指针与指针常量 129。11.2.2 重载运算符的形式与规则 238。
C++教程从入门到实战
热门推荐
m0_67401153的博客
07-28 4万+
httpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttps。
C++入门——13多态
木木没有跶
08-19 735
多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。Person对象买票全价，Student对象买票半价。那么在继承中要构成多态还有两个条件：1.必须通过基类的指针或者引用调用虚函数2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写同一作用域下，函数名相同参数不同。两个具有继承关系的类中的函数，函数名相同。
C++菜鸟教程 - 从入门到精通 第一节
C_User1024的博客
09-04 3223
抽象是从具体的实例中提取共同的特征，形成抽象类或接口，以便于代码的复用和扩展。抽象类和接口可以让程序员专注于高层次的设计和业务逻辑，而不必关注底层的实现细节。
C++从入门到精通(国家863)
11-05
从上述知识点可以看出，《C++从入门到精通》这本书不仅覆盖了C++的基础语法，还深入介绍了面向对象编程的核心概念，以及一些高级主题如模板、异常处理等。通过系统地学习这些内容，读者可以逐步掌握C++编程，并为...
C++从入门到精通1
08-03
《C++从入门到精通1》是一本针对C++初学者的教程，旨在全面系统地讲解C++语言的基础知识和核心概念。从C++概述开始，逐步深入到面向对象编程、程序结构、编码规范以及各种重要的语法元素。下面将详细阐述其中的关键...
小朋友讲C++编程入门（1-12课）-2023.09.21.pdf
09-21
在完成GoC画图的基础教程后，课程进入C++编程的深入学习，从第十三课到第二十一课，可能涉及更复杂的主题，如类和对象的深入、继承、多态、模板、文件I/O、STL（标准模板库）等。这些内容将帮助学生掌握C++的高级...
使用socket编程来实现一个简单的C/S模型（TCP协议）
caiji0169的博客
10-02 1014
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
【C++】红黑树的封装——同时实现map和set
Mesar的博客
09-27 650
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
求n的阶乘的相反数（c语言）
scy2429828663的博客
09-26 416
【代码】求n的阶乘的相反数（c语言）
【YOLOv8改进[SPPF]】使用SPPFCSPC替换SPPF模块 + 含全部代码和详细修改方式
静谧、淡雅
09-29 203
【YOLOv8改进[SPPF]】使用SPPFCSPC替换SPPF模块 + 含全部代码和详细修改方式
第 21 章 一条记录的多幅面孔——事务的隔离级别与 MVCC
最新发布
weixin_45740473的博客
10-02 547
并发的事务在运行过程中会出现一些可能的引发一致性问题SQL 标准中有4种隔离级别版本链ReadView。
简易STL实现 | Set 的实现
AsherGu的博客
09-26 448
如何使用；代码实现及其他（包括之前红黑树可以运行实现）
C++深度探索：从入门到精通(第三版)
"C++入门到精通(经典版)，由Stanley B. Lippman和Josée Lajoie合著，是一本针对C++初学者和中高级程序员的指南，全面阐述C++基本概念和技术，强调现代C++编程风格。本书中文版由潘爱民、张丽翻译，由Addison-Wesley...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值