c++多态的使用

news2024/10/7 0:05:21

为什么要使用多态

项目需求：

因为各种不确定原因，包括人为原因，ODU设备会自动的切换到其它类型的设备，而切换后的设备，和原设备有很多不同的地方。如何完美的实现这个切换呢？

解决方案：

使用多态。

聚会案例：

Demo.cpp

#include <iostream>
using namespace std;

class Father {
public:
	void play() {
		cout << "到KTV唱歌..." << endl;
	}
};

class Son :public Father {
public:
	void play() {
		cout << "一起打王者吧！" << endl;
	}
};

void party(Father **men, int n) {
	for (int i = 0; i<n; i++) {
		men[i]->play();
	}
}
int main(void) {
	Father father;
	Son son1, son2;
	Father* men[] = { &father, &son1, &son2 };

	party(men, sizeof(men) / sizeof(men[0]));

	system("pause");
	return 0;
}

解决方案:
通过虚函数，实现多态。

在这里插入图片描述在这里插入图片描述

项目多态-虚函数

多态的本质：

形式上，使用统一的父类指针做一般性处理，

但是实际执行时，这个指针可能指向子类对象，

形式上，原本调用父类的方法，但是实际上会调用子类的同名方法。

【注意】

程序执行时，父类指针指向父类对象，或子类对象时，在形式上是无法分辨的！

只有通过多态机制，才能执行真正对应的方法。

基础-虚函数的使用

虚函数的定义：

在函数的返回类型之前使用virtual

只在成员函数的声明中添加virtual, 在成员函数的实现中不要加virtual

虚函数的继承：

l 如果某个成员函数被声明为虚函数，那么它的子类【派生类】，以及子类的子类中，所继承的这个成员函数，也自动是虚函数。

l *如果在子类中重写这个虚函数，可以不用再写virtual, 但是仍建议写virtual, 更可读！*

虚函数表

单个类的虚函数表

#include <iostream>
using namespace std;

class Father {
public:
	virtual void func1() { cout << "Father::func1" << endl; }
	virtual void func2() { cout << "Father::func2" << endl; }
	virtual void func3() { cout << "Father::func3" << endl; }
	void func4() { cout << "非虚函数：Father::func4" << endl; }
public:  //为了便于测试，特别该用public
	int x = 100;
	int y = 200;
	static int z;
};

typedef void (*func_t)(void);
int Father::z = 1;
int main(void) {
	Father father;

	// 含有虚函数的对象的内存中，最先存储的就是“虚函数表”
	cout << "对象地址：" << (int*)&father << endl;

	int* vptr = (int*)*(int*)&father;
	cout << "虚函数表指针vptr：" << vptr << endl;

	cout << "调用第1个虚函数: ";
	((func_t) * (vptr + 0))();

	cout << "调用第2个虚函数：";
	((func_t) * (vptr + 1))();

	cout << "调用第3个虚函数: ";
	((func_t) * (vptr + 2))();

	
	cout << "第1个数据成员的地址: " << endl;
	cout <<  &father.x << endl;
	cout << std::hex << (int)&father + 4 << endl;
	cout << "第1个数据成员的值：" << endl;
	cout << std::dec <<  father.x << endl;
	cout << *(int*)((int)&father + 4) << endl;

	cout << "第2个数据成员的地址: " << endl;
	cout << &father.y << endl;
	cout << std::hex << (int)&father + 8 << endl;
	cout << "第2个数据成员的值：" << endl;
	cout << std::dec << father.y << endl;
	cout << *(int*)((int)&father + 8) << endl;

	cout << "sizeof(father)==" << sizeof(father) << endl;

	Father father2;
	cout << "father的虚函数表：";
	cout << *(int*)(*(int*)&father) << endl;
	cout << "father2的虚函数表：";
	cout << *(int*)(*(int*)&father2) << endl;

	system("pause");
	return 0;
}

执行效果
在这里插入图片描述

VS的对象内存分布分析：

项目的命令行配置中添加： /d1 reportSingleClassLayoutFather
在这里插入图片描述

手绘内存分布：在这里插入图片描述

对象内，首先存储的是“虚函数表指针”，又称“虚表指针”。

然后再存储非静态数据成员。

对象的非虚函数，保存在类的代码中！

对象的内存，只存储虚函数表和数据成员

（类的静态数据成员，保存在数据区中，和对象是分开存储的）

添加虚函数后，对象的内存空间不变！仅虚函数表中添加条目

多个对象，共享同一个虚函数表！

使用继承的虚函数表

#include <iostream>
using namespace std;

class Father {
public:
	virtual void func1() { cout << "Father::func1" << endl; }
	virtual void func2() { cout << "Father::func2" << endl; }
	virtual void func3() { cout << "Father::func3" << endl; }
	void func4() { cout << "非虚函数：Father::func4" << endl; }
public:  //为了便于测试，特别该用public
	int x = 100;
	int y = 200;
};

class Son : public Father {
public:
	void func1() { cout << "Son::func1" << endl; }
	virtual void func5() { cout << "Son::func5" << endl; }
};

typedef void (*func_t)(void);

int main(void) {
	Father father;
	Son  son;

	// 含有虚函数的对象的内存中，最先存储的就是“虚函数表”
	cout << "son对象地址：" << (int*)&son << endl;

	int* vptr = (int*)*(int*)&son;
	cout << "虚函数表指针vptr：" << vptr << endl;

	for (int i = 0; i < 4; i++) {
		cout << "调用第" << i + 1 << "个虚函数：";
		((func_t) * (vptr + i))();
	}
	
	for (int i = 0; i < 2; i++) {
		// +4 是因为先存储了虚表指针
		cout << *(int*)((int)&son + 4 + i * 4) << endl;
	}

	system("pause");
	return 0;
}

在这里插入图片描述

内存分布
在这里插入图片描述

补充：
在这里插入图片描述

多重继承的虚函数表

#include <iostream>

using namespace std;

class Father {
public:
	virtual void func1() { cout << "Father::func1" << endl; }
	virtual void func2() { cout << "Father::func2" << endl; }
	virtual void func3() { cout << "Father::func3" << endl; }
	void func4() { cout << "非虚函数：Father::func4" << endl; }
public:
	int x = 200;
	int y = 300;
	static int z;
};

class Mother {
public:
	virtual void handle1() { cout << "Mother::handle1" << endl; }
	virtual void handle2() { cout << "Mother::handle2" << endl; }
	virtual void handle3() { cout << "Mother::handle3" << endl; }
public: //为了便于测试，使用public权限
	int m = 400;
	int n = 500;
};

class Son : public Father, public Mother {
public:
	void func1() { cout << "Son::func1" << endl; }
	virtual void handle1() { cout << "Son::handle1" << endl; }
	virtual void func5() { cout << "Son::func5" << endl; }
};

int Father::z = 0;

typedef void(*func_t)(void);

int main(void) {
	Son son;
	int* vptr = (int*) * (int*)&son;
	cout << "第一个虚函数表指针：" << vptr << endl;

	for (int i = 0; i < 4; i++) {
		cout << "调用第" << i + 1 << "个虚函数:";
		((func_t) * (vptr + i))();
	}

	for (int i = 0; i < 2; i++) {
		cout << *(int*)((int)&son + 4 + i * 4) << endl;
	}

	int* vptr2 = (int*) * ((int*)&son + 3);
	for (int i = 0; i < 3; i++) {
		cout << "调用第" << i + 1 << "个虚函数:";
		((func_t) * (vptr2 + i))();
	}

	for (int i = 0; i < 2; i++) {
		cout << *(int*)((int)&son + 16 + i * 4) << endl;
	}

	system("pause");
	return 0;
}

在这里插入图片描述
在这里插入图片描述

内存分布

在这里插入图片描述

子类的虚函数表

  • 直接复制父类的虚函数表
  • 如果子类重写了父类的某个虚函数，那么就在这个虚函数表中进行相应替换
  • 如果子类添加了新的虚函数，那么就把这个虚函数添加到虚函数表中（末尾添加）

final

用来修饰类，让该类不能被继承

理解：使得该类终结！

在这里插入图片描述

用来修饰类的虚函数，使得该虚函数在子类中，不能被重写

理解：使得该功能终结

class XiaoMi {
public:
	virtual void func() final;
};

void XiaoMi::func() { //不需要再写final
	cout << "XiaoMi::func" << endl; 
}

class XiaoMi2 : public XiaoMi  {
public:
	void func() {}; // 错误！不能重写func函数
};

override

override仅能用于修饰虚函数。

作用：

  1. 提示程序的阅读者，这个函数是重写父类的功能。

    2 .防止程序员在重写父类的函数时，把函数名写错

#include <iostream>
using namespace std;

class XiaoMi {
public:
	virtual void func() { cout << "XiaoMi::func" << endl; };
};

class XiaoMi2 : public XiaoMi  {
public:
	void func() override {}
	//void func() override;  告诉程序员func是重写父类的虚函数
	//void func1() override{} 错误！因为父类没有func1这个虚函数
};

int main(void) {
	XiaoMi2 xiaomi;
	return 0;
}

override只需在函数声明中使用，不需要在函数的实现中使用。

遗失的子类析构函数

#include <iostream>
#include <Windows.h>

using namespace std;

class Father {
public:
	Father(const char* addr = "中国") {
		cout << __FUNCTION__ << endl;
		int len = strlen(addr) + 1;
		this->addr = new char[len];
		strcpy_s(this->addr, len, addr);

	}

	~Father() {
		cout << __FUNCTION__ << endl;
		if (addr) {
			delete addr;
			addr = NULL;

		}
	}
private:
	char* addr;

};

class Son :public Father{
public:
	Son(const char *game = "吃鸡",const char *addr = "中国"):Father(addr) {
		cout << "执行了Son的构造函数" << endl;
		int len = strlen(game) + 1;
		this->game = new char[len];
		strcpy_s(this->game, len, game);
	}

	~Son() {
		cout << __FUNCTION__ << endl;
		if (game) {
			delete game;
			game = NULL;
		}
	}
private:
	char* game;




};


int main(void) {

	cout << "--------case1---------" << endl;
	Father* father = new Father();
	delete father;

	cout << "----case2----" << endl;
	Son* son = new Son();
	delete son;

	cout << "----case3----" << endl;
	father = new Son();
	delete father;

	return 0;

}

在这里插入图片描述

解决方案析构函数加上virtual关键字

在这里插入图片描述

把Father类的析构函数定义为virtual函数时，如果对Father类的指针使用delete操作时，就会对该指针使用动态析构（如果这个指针指向的时子类对象，那么先调用子类对象的析构函数，再调用Father类的（自己类）析构函数）

为了防止内存泄露，最好是在基类析构函数上添加virtual关键字，使基类析构函数为虚函数

目的在于，当使用delete释放基类指针时，会实现动态的析构：

如果基类指针指向的是基类对象，那么只调用基类的析构函数

如果基类指针指向的是子类对象，那么先调用子类的析构函数，再调用父类的析构函数

纯虚也有用：纯虚函数与抽象类

什么时候使用纯虚函数

某些类，在现实角度和项目实现角度，都不需要实例化（不需要创建它的对象），

这个类中定义的某些成员函数，只是为了提供一个形式上的接口，准备让子类来做具体的实现。

此时，这个方法，就可以定义为“纯虚函数”， 包含纯虚函数的类，就称为抽象类。

#include <iostream>
#include <string>
#include <Windows.h>

using namespace std;

class Shape {
public:
	Shape(const string& color = "white") {
		this->color = color;
	}
	//把area定义为“纯虚函数”
	virtual float area() = 0;
	string getColor() { return color; }
private:
	string color;
};

class Circle :public Shape {
public:
	Circle(float radius = 0, const string& color = "white")
		:Shape(color), r(radius) {}
	float area() { return 3.14 * r * r; }

private:
	float r;
};
纯虚函数的注意事项···

父类声明某纯虚函数后，那么它的子类。

1）要么实现这个纯虚函数 （最常见）

2）要么继续把这个纯虚函数声明为纯虚函数，这个子类也成为抽象类

3）要么不对这个纯虚函数做任何处理，等效于上一种情况（该方式不推荐）

项目实例

在这里插入图片描述

ODU.h

#pragma once
#include <iostream>
#define ODU_TYPE_331_FLAG 331
#define ODU_TYPE_335_FLAG 335
using namespace std;
//ODU类，用于处理老ODU331设备

enum class ODU_TYPE {
	OUT_TYPE_331,
	ODU_TYPE_335,
	ODU_TYPE_UNKNOWN
};

class ODU
{
public :
	ODU();
	virtual int getTxFre();//获取发射频率
	virtual bool setTxFre(int);//设置发射频率

	virtual int getRxFre();//获取接受频率
	virtual bool setRxFre(int);//设置接受频率

	virtual float getTxPower();//获取发射功率
	virtual bool setTxPower(float);//设置发射功率

	virtual float getRxL();//获取接收电频

	virtual bool heartBeat();//心跳包

	virtual string getName();//获取该设备的名字

	ODU_TYPE getODUType();//获取当前OUD类型
protected:
	int txFre;
	int rxFre;
	float txPower;
	float rxL;

	ODU_TYPE type;
};

ODU.cpp

#include "ODU.h"
#include <iostream>
#include <string>
using namespace std;

ODU::ODU()
{
	txFre = 34400;
	rxFre = 31100;
	txPower = 20;
	rxL = 0;
	type = ODU_TYPE::OUT_TYPE_331;
	cout << "调用ODU()"  << endl;


}

int ODU::getTxFre()
{

	return txFre;
}

bool ODU::setTxFre(int frequence)
{
	txFre = frequence;
	cout << getName() << "发射频率已经设置为" << txFre << "Hz" << endl;
	return true;
}

int ODU::getRxFre()
{
	return rxFre;
}

bool ODU::setRxFre(int frequence)
{
	rxFre = frequence;
	cout << getName() << "接收频率已经设置为" << rxFre << "Hz" << endl;
	return true;
	
}

float ODU::getTxPower()
{

	return txPower;
}

bool ODU::setTxPower(float power)
{
	txPower = power;
	cout << getName() << "发射功率已经设置为" << txPower << "Hz" << endl;
	return true;
}

float ODU::getRxL()
{
	return rxL;
}

bool ODU::heartBeat()
{
	cout <<getName()<< "模拟串口协议读取数据，获取心跳包的反馈...【"
		<< ODU_TYPE_331_FLAG <<"】" << endl;
	int response;
	cin >> response;
	if (response == ODU_TYPE_331_FLAG) {
		return true;	
	}

	return false;
}

string ODU::getName()
{
	string ret;
	switch (type)
	{
	case ODU_TYPE::OUT_TYPE_331:
		ret = "ODU331";
		break;
	case ODU_TYPE::ODU_TYPE_335:
		ret = "ODU335";
		break;
	case ODU_TYPE::ODU_TYPE_UNKNOWN:	
		
	default:
		ret = "ODUUNKNOWN";
		break;
	}

	return ret;
}

ODU_TYPE ODU::getODUType()
{
	return type;
}

ODU335.h

#pragma once
#include "ODU.h"

class ODU335 :public ODU
{
public:
	ODU335();
	bool heartBeat()override;
	//bool set()override;
};

ODU335.cpp

#include "ODU335.h"

ODU335::ODU335()
{
	cout << "调用ODU335" << endl;
	type = ODU_TYPE::ODU_TYPE_335;

}

bool ODU335::heartBeat()
{
	cout << getName() << "模拟串口协议读取数据，获取心跳包的反馈...【"
		<< ODU_TYPE_335_FLAG << "】" << endl;
	int response;
	cin >> response;
	if (response == ODU_TYPE_335_FLAG) {
		type = ODU_TYPE::ODU_TYPE_335;
		return true;
	}

	
}

main.cpp

#include <iostream>
#include <string>
#include <Windows.h>
#include <thread>
#include "ODU.h"
#include "ODU335.h"

using namespace std;
ODU* odu = NULL;

void test(ODU* odu) {
	odu->setRxFre(35588);
	cout << odu->getRxFre() << endl;
	odu->heartBeat();
}

void oduMonitorHandler() {
	while (true)
	{
		if (odu->heartBeat() == false) {
			//切换ODU
			ODU_TYPE type = odu->getODUType();
			switch (type)
			{
			case ODU_TYPE::OUT_TYPE_331:
				delete odu;
				odu = new ODU335;
				break;
			case ODU_TYPE::ODU_TYPE_335:
				delete odu;
				odu = new ODU;
				break;
			case ODU_TYPE::ODU_TYPE_UNKNOWN:	
			default:
				odu = NULL;
				return;
				break;
			}
		}
		Sleep(3000);
	}
	return;
}

int main(void) {
	
	odu = new ODU();
	//创建一个线程 对于ODU进监测
	std::thread oduMonitor(oduMonitorHandler);
	//主线程等待odumonitor的线程结束
	oduMonitor.join();
	return 0;
}

常见错误总结

  1. 虚函数的函数原型
  子类在重新实现继承的虚函数时，要和主要函数的原型一致    

  如果已经继承虚函数：

  bool heartBeat();

   那么重写虚函数时，函数原型必须保持完全一致：

  bool heartBeat();

   而且子类不能添加：
    int heartBeat();

  //因为仅函数的返回类型不同时，不能区别两个函数。

   但是可以添加：
    int heartBeat(int);

  1. 析构函数是否使用虚函数

     有子类时，析构函数就应该使用虚函数

  子类在重新实现继承的虚函数时，要和主要函数的原型一致    

  如果已经继承虚函数：

  bool heartBeat();

   那么重写虚函数时，函数原型必须保持完全一致：

  bool heartBeat();

   而且子类不能添加：
    int heartBeat();

  //因为仅函数的返回类型不同时，不能区别两个函数。

   但是可以添加：
    int heartBeat(int);

  1. 析构函数是否使用虚函数

     有子类时，析构函数就应该使用虚函数

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

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

相关文章

python opencv 深度学习 指纹识别算法实现 计算机竞赛

python opencv 深度学习 指纹识别算法实现 计算机竞赛

1 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 &#x1f6a9; python opencv 深度学习 指纹识别算法实现 &#x1f947;学长这里给一个题目综合评分(每项满分5分) 难度系数&#xff1a;3分工作量&#xff1a;4分创新点&#xff1a;4分 该项目较为新颖…
阅读更多...
【数据库系统概论】第二章关系数据库

【数据库系统概论】第二章关系数据库

2.1关系数据结构及其形式化定义 前面说过&#xff0c;数据模型由以下三部分构成 数据结构数据操作数据的完整性约束条件 而如今最为重要的数据模型便是关系模型。本书所学的关系数据库就是支持关系模型的数据库系统&#xff0c;因此本章重点研究的也是以下三个部分 一&…
阅读更多...
unity发布微信小游戏，未找到 game.json报错原因

unity发布微信小游戏，未找到 game.json报错原因

unity发布微信小游戏&#xff0c;未找到 game.json报错原因 同一个问题相隔一年遇到两次&#xff0c;两次原因都不一样&#xff0c;记录一下&#xff0c;以后不要再掉坑里 原因一&#xff1a;申请的appID是小程序不是小游戏 解决方法&#xff1a;需要在程序平台修改服务类目 如…
阅读更多...
外发文件怎么保存

外发文件怎么保存

文件外发是企业日常业务中常见的场景&#xff0c;外发整个流程涉及外发的渠道、外发文件的大小、外发的效率、外发的合规性、文件的保存和管理等一系列的过程。外发文件的保存可以从两个角度着手&#xff1a; 一、接收方 接收方首先要对接收到的文件进行分级和分类&#xff0…
阅读更多...
第P9周-YOLOv5Backbone模块

第P9周-YOLOv5Backbone模块

CSP Bottleneck块和C3 类的设计使其非常适合目标检测任务&#xff0c;充分考虑了多尺度特征融合、梯度流动和计算效率等因素。C3 类以及CSP&#xff08;Cross Stage Partial&#xff09; Bottleneck块作为YOLOv5中的一部分&#xff0c;具有以下优势&#xff0c;相对于传统的普通…
阅读更多...
京东商品品牌数据采集接口，京东商品详情数据接口，京东API接口

京东商品品牌数据采集接口，京东商品详情数据接口，京东API接口

采集京东商品品牌数据的方法如下&#xff1a; 打开网页。在首页【输入框】中输入目标网址批量输入多个关键词并搜索。创建【循环列表】&#xff0c;采集所有商品列表中的数据。编辑字段。创建【循环翻页】&#xff0c;采集多页数据。设置滚动和修改【循环翻页】XPath。启动采集…
阅读更多...
日常开发中的图片处理系列工具

日常开发中的图片处理系列工具

一键保存谷歌浏览器当前网页的图片和视频等的插件。 视频图片音乐下载助手_3.1.3_chrome扩展插件下载_极简插件 可高效实现下载管理&#xff0c;网页图片&#xff0c;视频&#xff0c;音频等内容的嗅探和下载&#xff0c;同时扩展集成多个网站的智能脚本&#xff0c;快速提取你…
阅读更多...
1600*C. Hamburgers（二分贪心）

1600*C. Hamburgers（二分贪心）

Problem - 371C - Codeforces 解析&#xff1a; 二分答案&#xff0c;每次check当前能做的蛋糕数量&#xff0c;判断剩余材料和金钱能否做出来。 注意check中的乘积可能会爆long long&#xff0c;所以二分右边界需要设置1e14以内&#xff08;因为可能会乘一个10000&#xff09;…
阅读更多...
element-plus el-cascader 级联组件清空所选数据方法

element-plus el-cascader 级联组件清空所选数据方法

话不多说直接上代码 import {ref, Ref, reactive} from vue; const cascaderOrg:Ref ref<any>(null) //获取级联组件的ref ref名称即cascaderOrg cascaderOrg.value.cascaderPanelRef.clearCheckedNodes(); //清空所选数据借用官方文档展示该方法 相关细节描述及全…
阅读更多...
3.简单场景构建

3.简单场景构建

在新建的项目中&#xff0c;默认存在 Main Camera 和 Directional Light两个对象。若是缺失&#xff0c;可通过选择菜单中的 Game Object->Camera 和 Geme Object->Light->Directional Light进行创建。 1.添加地形及底图 通过在Cesium面板中选择 Cesium World Terrai…
阅读更多...
redis如何实现缓存预热

redis如何实现缓存预热

在业务系统中&#xff0c;我们需要在程序启动的时候加载一些常用的数据到内存数据库中&#xff0c;从而减少业务数据库的压力。这就是我们常提到的缓存预热。官方一点的解释是这样的&#xff1a; 缓存预热是一种在程序启动或缓存失效之后&#xff0c;主动将热点数据加载到缓存中…
阅读更多...
使用注解新开事务 @Transactional

使用注解新开事务 @Transactional

使用注解新开事务 Transactional(propagation Propagation.REQUIRES_NEW)
阅读更多...
QSS样式表的使用

QSS样式表的使用

QSS样式表的使用 Chapter1 【Qt】样式表的使用——设置样式的方法一、简述二、开始总结1、先谈谈我们设置样式有几种方法2、再谈谈这几种设置样式方法的优缺点 个人建议 Chapter2 Qt样式表总结Chapter3 【QT】史上最全最详细的QSS样式表用法及用例说明Chapter4 Qt样式表使用总结…
阅读更多...
计算机的计算单位

计算机的计算单位

文章目录 前言一、容量单位二、速度单位1.网络速度2.CPU频率 总结 前言 今天给大家介绍计算机的计算单位&#xff0c;分为两个板块&#xff1a;容量单位、速度单位。 一、容量单位 对于容量单位&#xff0c;大家在日常生活中应该都有所了解&#xff0c;比如说 768M 的光盘、4…
阅读更多...
内网穿透的应用-使用eXtplorer本地搭建免费在线文件管理器并实现远程登录

内网穿透的应用-使用eXtplorer本地搭建免费在线文件管理器并实现远程登录

文章目录 1. 前言2. eXtplorer网站搭建2.1 eXtplorer下载和安装2.2 eXtplorer网页测试2.3 cpolar的安装和注册 3.本地网页发布3.1.Cpolar云端设置3.2.Cpolar本地设置 4.公网访问测试5.结语 1. 前言 通过互联网传输文件&#xff0c;是互联网最重要的应用之一&#xff0c;无论是…
阅读更多...
PMP考试知识点（干货码住）

PMP考试知识点（干货码住）

一、需要记忆的公式 1. 三点估算是指通过期望值、标准差和方差来进行估算的方法&#xff1b; 2. 关键路径计算包括ES、EF、LS、LF、总浮动时间和自由浮动时间等指标&#xff1b; 3. 挣值计算是一种常用的项目管理方法&#xff0c;包括CPI、SPI、ETC、EAC和TCPI等指标&#x…
阅读更多...
为什么MyBatis是Java数据库持久层的明智选择

为什么MyBatis是Java数据库持久层的明智选择

在Java应用程序的开发中&#xff0c;选择合适的数据库持久层框架至关重要。一个明智的选择可以帮助开发人员更好地管理数据库交互、提高性能和简化开发工作。 &#xff08;一&#xff09;为什么要选MyBatis JDBCHibernate / JPAMyBatis简单直接ORM轻量动态SQL关联查询开发效率…
阅读更多...
VAE模型（详细推导+实例代码）

VAE模型（详细推导+实例代码）

文章目录 EM算法思路E步M步直观感觉 GMM模型VAEVAE思想从GMM到VAE公式推导重参数VAE神经网络另一个视角的VAE思想为什么引入encoder为什么要重参数噪声与重建 Discrete VAE 本文会从EM算法&#xff0c;GMM模型一步一步的的推导&#xff0c;在过渡到VAE模型&#xff0c;如果有熟…
阅读更多...
博华网龙设备命令执行漏洞复现 [附POC]

博华网龙设备命令执行漏洞复现 [附POC]

文章目录 博华网龙设备命令执行漏洞复现 [附POC]0x01 前言0x02 漏洞描述0x03 影响版本0x04 漏洞环境0x05 漏洞复现1.访问漏洞环境2.构造POC3.复现 0x06 修复建议 博华网龙设备命令执行漏洞复现 [附POC] 0x01 前言 免责声明&#xff1a;请勿利用文章内的相关技术从事非法测试&…
阅读更多...
【Vue】之Vuex的入门使用，取值，修改值，同异步请求处理---保姆级别教学

【Vue】之Vuex的入门使用，取值，修改值，同异步请求处理---保姆级别教学

一&#xff0c;Vuex入门 1.1 什么是Vuex Vuex是一个专门为Vue.js应用程序开发的状态管理库。它用于管理应用程序中的共享状态&#xff0c;它采用集中式存储管理应用的所有组件的状态&#xff0c;使得状态的管理变得简单和可预测 官方解释&#xff1a;Vuex 是一个专为 Vue.js 应…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023