设计模式复习

单例模式

确保一个类最多只有一个实例，并提供一个全局访问点。

（某个类的对象有且仅有一个，单例的对象充当的是全局变量的角色，为什么在C++里面不直接使用全局变量，而是使用单例来代替全局变量，因为如果直接使用全局变量会破坏类的封装，全局变量没有被封装，他的访问权限是不受限制的，任何模块在任意位置都可以对全局变量进行读或者写的操作，如果在程序中大量使用全局变量，全局变量在一个位置被恶意篡改，在其他位置获取全局变量会产生影响，其他模块在工作的时候就得不到正确的值了，解决方案就是使用单例模式，全局变量被封装到一个类里面，并且被private修饰，就不会在类外被随意访问，在单例模式的类里面提供对私有成员的访问函数，对变量的读和写设定指定的规则，这样类里面的数据不是直接被访问的，而是间接被访问的，间接的通过单例模式的类提供的成员函数进行访问，这样既把数据进行了封装又可以保证数据的安全性）

创建一个单例模式的类

构造拷贝构造私有，提供静态公有的获取方法 

类外new来创建对象已经不行了，只能通过类名得到对象，所以对象是静态的

饿汉模式 ：定义类的时候创建单例对象

还没有使用该单例对象，该单例对象就已经被加载到内存了，在对象过多时会造成内存浪费，在多线程模式下，饿汉模式没有线程安全问题

#include<iostream>
using namespace std;

//饿汉模式->定义类的时候创建单例对象
//定义一个单例模式的任务队列
class TaskQueue
{
public:
	static TaskQueue* getInstance()
	{
		return m_taskQ;
	}
	void pirntf() {
		cout << "sss" << endl;
	}

private:
	TaskQueue() = default;
	TaskQueue(const TaskQueue& t) = default;

	static TaskQueue* m_taskQ;
};
TaskQueue* TaskQueue::m_taskQ = new TaskQueue;

int main() {
	TaskQueue* taskQ = TaskQueue::getInstance();
	taskQ->pirntf();

	return 0;
}

懒汉模式：什么时候使用这个单例对象，在使用的时候再去创建对应的实例

解决了饿汉式内存浪费问题，但是线程不安全的，可以通过互斥量mutex.lock()和mutex.unlock()来解决 

#include<iostream>
using namespace std;

//定义一个单例模式的任务队列
class TaskQueue
{
public:
	static TaskQueue* getInstance()
	{
        if(m_taskQ == nullptr)
        {
            m_taskQ = new TaskQueue;
        }
		return m_taskQ;
	}
	void pirntf() {
		cout << "sss" << endl;
	}

private:
	TaskQueue() = default;
	TaskQueue(const TaskQueue& t) = default;

	static TaskQueue* m_taskQ;
};
TaskQueue* TaskQueue::m_taskQ = nullptr;

int main() {
	TaskQueue* taskQ = TaskQueue::getInstance();
	taskQ->pirntf();

	return 0;
}

类加载的时候，没有立刻实例化，第一次调用getInstance()的时候,才真的实例化.

如果要是代码一整场都没有调用getInstance，此时实例化的过程也就被省略掉了，

我们一般成懒汉模式为“懒加载”或者“延时加载”，“懒汉模式"比“饿汉模式"效率更高，有很大的可能是“实例用不到",此时就节省了实例化的开销。

饿汉模式，懒汉模式线程安全吗？
了解了线程安全之后，对于饿汉模式来说，多线程同时调用getInstance()，由于getInstance()里只做了一件事：读取instance实例的地址，也就是多个线程在同时读取同一个变量，并没有构成多个线程同时修改同一个变量这一情况，所以说饿汉模式是线程安全的。

而对于懒汉模式来说，多线程调用getInstance()，getInstance()做了四件事情~

1.读取 instance 的内容

2.判断 instance 是否为 null

3.如果 instance 为null，就 new实例 （这就会修改 intance 的值）

4.返回实例的地址

由于懒汉模式造成了多个线程同时修改同一个变量这一情况，所以说懒汉模式是线程不安全的。

懒汉模式-使用双重检查锁定解决线程安全问题 

比如说三个线程A B C 同时访问 ，第一次判空，到锁那阻塞，A先进去第二次判空创建对象 B C等A完事锁解开才能进去 第一次ABC是一个接一个进去，如果再来三个线程的话会直接判断非空，直接到return m_taskQ了，使程序的效率提升。

#include<iostream>
#include<mutex>
using namespace std;

//定义一个单例模式的任务队列
class TaskQueue
{
public:
	static TaskQueue* getInstance()
	{
		if (m_taskQ == nullptr) {
			m_mutex.lock();
			if (m_taskQ == nullptr) {
				m_taskQ = new TaskQueue;
			}
			m_mutex.unlock();
		}
        return m_taskQ;
	}
	void pirntf() {
		cout << "sss" << endl;
	}

private:
	TaskQueue() = default;
	TaskQueue(const TaskQueue& t) = default;

	static TaskQueue* m_taskQ;
	static mutex m_mutex;
};
TaskQueue* TaskQueue::m_taskQ = nullptr;
mutex TaskQueue::m_mutex;

int main() {
	TaskQueue* taskQ = TaskQueue::getInstance();
	taskQ->pirntf();

	return 0;
}

工厂模式

主要是对对象的创建进行了一个封装，提供了一种创建对象的方式。

（1）在没有工厂的时代，如果客户需要一款宝马车，那么就需要客户去创建一款宝马车，然后拿来用。

（2）简单工厂模式：后来出现了工厂，用户不再需要去创建宝马车，由工厂进行创建，想要什么车，直接通过工厂创建就可以了。比如想要320i系列车，工厂就创建这个系列的车。

（3）工厂方法模式：为了满足客户，宝马车系列越来越多，如320i、523i等等系列，一个工厂无法创建所有的宝马系列，于是又单独分出来多个具体的工厂，每个具体工厂创建一种系列，即具体工厂类只能创建一个具体产品。但是宝马工厂还是个抽象，你需要指定某个具体的工厂才能生产车出来。

（4）抽象工厂模式：随着客户要求越来越高，宝马车必须配置空调，于是这个工厂开始生产宝马车和需要的空调。最终是客户只要对宝马的销售员说：我要523i空调车，销售员就直接给他523i空调车了。而不用自己去创建523i空调车宝马车。

简单工厂模式

简单工厂模式的结构组成：

1. 工厂类：工厂模式的核心类，会定义一个用于创建指定的具体实例对象的接口。

2. 抽象产品类：是具体产品类的继承的父类或实现的接口。

3. 具体产品类：工厂类所创建的对象就是此具体产品实例

#include<iostream>
using namespace std;

// 产品类的父亲 - 人造恶魔果实
class AbstractSmile
{
public:
	virtual void transform() = 0;
	virtual void ability() = 0;
	virtual ~AbstractSmile(){}
};

class SheepSmile :public AbstractSmile
{
public:
	void transform() override
	{
		cout << "变身-山羊形态。。" << endl;
	}
	void ability() override
	{
		cout << "将手臂变成羊角。。" << endl;
	}
};

class LionSmile :public AbstractSmile
{
public:
	void transform() override
	{
		cout << "变身-狮子人形态。。" << endl;
	}
	void ability() override
	{
		cout << "火遁。。" << endl;
	}
};

class BatSmile :public AbstractSmile
{
public:
	void transform() override
	{
		cout << "变身-蝙蝠人形态。。" << endl;
	}
	void ability() override
	{
		cout << "吸血。。" << endl;
	}
};

//定义工厂类
enum class Type:char{Sheep,Lion,Bat};
class SmileFactory
{
public:
	AbstractSmile* createSmile(Type type)
	{
		AbstractSmile* ptr = nullptr;
		switch (type)
		{
		case Type::Sheep:
			ptr = new SheepSmile;
			break;
		case Type::Lion:
			ptr = new LionSmile;
			break;
		case Type::Bat:
			ptr = new BatSmile;
			break;
		default:
			break;
		}
		return ptr;
	}
};

int main()
{
	SmileFactory* factroy = new SmileFactory;
	AbstractSmile* obj = factroy->createSmile(Type::Lion);
	obj->transform();
	obj->ability();
	return 0;
}

可以看到，简单工厂可以做到，让用户创建对象的时候只需要知道对象的名称（BMW、AUDI）就好，而不需要关心创建对象的细节（BMW是如何建造的、型号是什么等等细节）。

当然缺点也很明显：
每当我们想要扩展对象的时候（增加BENZ的对象）就需要在SimpleFactory类中添加代码，增加switch后面的case选项。这样一来，就需要修改源代码。灵活性非常的差！！！

那么，能不能做到添加对象的时候，不对现有代码进行修改呢？（也就是我们开发软件时候需要遵守的开-闭原则）

工厂模式

工厂方法模式将工厂抽象化，并定义一个创建对象的接口。每增加新产品，只需增加该产品以及对应的具体实现工厂类，由具体工厂类决定要实例化的产品是哪个，将对象的创建与实例化延迟到子类，这样工厂的设计就符合“开闭原则”了，扩展时不必去修改原来的代码。在使用时，用于只需知道产品对应的具体工厂，关注具体的创建过程，甚至不需要知道具体产品类的类名，当我们选择哪个具体工厂时，就已经决定了实际创建的产品是哪个了。

        但缺点在于，每增加一个产品都需要增加一个具体产品类和实现工厂类，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。

工厂方法模式的结构组成：

1. 抽象工厂类：工厂方法模式的核心类，提供创建具体产品的接口，由具体工厂类实现。

2. 具体工厂类：继承于抽象工厂，实现创建对应具体产品对象的方式。

3. 抽象产品类：它是具体产品继承的父类（基类）。

4. 具体产品类：具体工厂所创建的对象，就是此类。

（自己理解就是，工厂模式相当于简单工厂模式，如果需要增加新产品，只需要增加新的产品类继承抽象产品类，再增加生产该类型产品的工厂继承抽象工厂类，只需要拓展代码而不需要更改原先的代码）

#include<iostream>
using namespace std;

// 产品类的父亲 - 人造恶魔果实
class AbstractSmile
{
public:
	virtual void transform() = 0;
	virtual void ability() = 0;
	virtual ~AbstractSmile(){}
};

class SheepSmile :public AbstractSmile
{
public:
	void transform() override
	{
		cout << "变身-山羊形态。。" << endl;
	}
	void ability() override
	{
		cout << "将手臂变成羊角。。" << endl;
	}
};

class LionSmile :public AbstractSmile
{
public:
	void transform() override
	{
		cout << "变身-狮子人形态。。" << endl;
	}
	void ability() override
	{
		cout << "火遁。。" << endl;
	}
};

class BatSmile :public AbstractSmile
{
public:
	void transform() override
	{
		cout << "变身-蝙蝠人形态。。" << endl;
	}
	void ability() override
	{
		cout << "吸血。。" << endl;
	}
};

//定义工厂类  - 父类
class AbstractFactory
{
public:
	virtual AbstractSmile* createSmile() = 0;
	virtual ~AbstractFactory(){}
};

// 生产山羊的恶魔果实
class SheepFactory:public AbstractFactory
{
public:
	AbstractSmile* createSmile()
	{
		return new SheepSmile;
	}
	~SheepFactory()
	{
		cout << "SheepFactory 被析构了。。" << endl;
	}
};

// 生产狮子的恶魔果实
class LionFactory :public AbstractFactory
{
public:
	AbstractSmile* createSmile()
	{
		return new LionSmile;
	}
	~LionFactory()
	{
		cout << "LionFactory 被析构了。。" << endl;
	}
};

// 生产蝙蝠的恶魔果实
class BatFactory :public AbstractFactory
{
public:
	AbstractSmile* createSmile()
	{
		return new BatSmile;
	}
	~BatFactory()
	{
		cout << "BatFactory 被析构了。。" << endl;
	}
};

int main()
{
	AbstractFactory* factroy = new LionFactory;
	AbstractSmile* obj = factroy->createSmile();
	obj->transform();
	obj->ability();

	delete obj;
	delete factroy;
	return 0;
}

抽象工厂模式

抽象工厂模式的结构组成（和工厂方法模式一样）：

1. 抽象工厂类：工厂方法模式的核心类，提供创建具体产品的接口，由具体工厂类实现。

2. 具体工厂类：继承于抽象工厂，实现创建对应具体产品对象的方式。

3. 抽象产品类：它是具体产品继承的父类（基类）。

4. 具体产品类：具体工厂所创建的对象，就是此类。

抽象工厂模式的特点：

提供一个接口，可以创建多个产品族中的产品对象。比如船工厂，可以创建基础款船，升级款船

#include<iostream>
using namespace std;

//船体
class shipBody
{
public:
	virtual string getBody() = 0;
	virtual ~shipBody(){}
};

//木头船体
class WoodBody :public shipBody
{
public:
	string getBody() override
	{
		return "使用<木头>制作船体";
	}
};

//钢铁船体
class IronBody :public shipBody
{
public:
	string getBody() override
	{
		return "使用<钢铁>制作船体";
	}
};


//引擎
class Engine
{
public:
	virtual string getEngine() = 0;
	virtual ~Engine(){}
};

class Human :public Engine
{
public:
	string getEngine()
	{
		return "船体动力方式是<手动>";
	}
};

class Diesel :public Engine
{
public:
	string getEngine()
	{
		return "船体动力方式是<内燃机>";
	}
};


//船
class Ship
{
public:
	Ship(shipBody*body,Engine* engine):
		m_body(body),m_engine(engine){}
	~Ship()
	{
		delete m_body;
		delete m_engine;
	}
	string getProperty()
	{
		string Info = m_body->getBody() + m_engine->getEngine();
		return Info;
	}

private:
	shipBody* m_body;
	Engine* m_engine;
};

//工厂类 - 抽象
class AbstractFactory
{
public:
	virtual Ship* createShip() = 0;
	virtual ~AbstractFactory(){}
};

class BasicFactory :public AbstractFactory
{
public:
	Ship* createShip() override
	{
		Ship* ship = new Ship(new WoodBody, new Human);
		cout << "<基础形>海贼船已经打造完毕" << endl;
		return ship;
	}
};

class StandardFactory :public AbstractFactory
{
public:
	Ship* createShip() override
	{
		Ship* ship = new Ship(new IronBody, new Diesel);
		cout << "<标准形>海贼船已经打造完毕" << endl;
		return ship;
	}
};

int main()
{
	//下单标准型海贼船
	AbstractFactory* factory = new StandardFactory;
	Ship* ship = factory->createShip();
	cout<<ship->getProperty();
	delete ship;
	delete factory;
	return 0;
}

抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型的情况下，能够创建多个产品族的产品对象

工厂模式只能生产一个产品。例如：产品要么香蕉、要么苹果，但抽象工厂可以一下生产一个产品族，如水果、动物、蔬菜等

#include<iostream>
using namespace std;


class AbstractFactory;

//抽象产品族Tea，茶可以是都匀毛尖、铁观音、普洱等品种。
class Tea{
public:
	virtual void getName() = 0;
};

//抽象产品族Fruit
class Fruit{
public:
	virtual void getName() = 0;
};

//抽象工厂，声明具体可以生产的产品族
class AbstractFactory{
public:
	virtual Tea* CreateTea() = 0;//生产产品族Tea
	virtual Fruit* CreateFruit() = 0 ;//生产产品族Fruit
};

//水果族的具体水果
class AppleFruit:public Fruit{
public:
	void getName(){
	    cout<<"I'm Apple"<<endl;
	}
};
class BananaFruit:public Fruit{
public:
	void getName(){
	    cout<<"I'm Banana"<<endl;
	}
};

//茶族的具体茶
class DuyunTea:public Tea{
public:
	void getName(){
	    cout<<"I'm maojianTea"<<endl;
	}
};
class PuerhTea:public Tea{
public:
	void getName(){
	    cout<<"I'm PuerhTea"<<endl;
	}
};

//具体工厂,都匀工厂
class DunyunFactory:public AbstractFactory{
public:
	Tea* CreateTea(){
		return new DuyunTea;
	}
	Fruit* CreateFruit(){
		return new BananaFruit();
	}
};
//具体工厂，云南工厂
class YunnanFactory:public AbstractFactory{
public:
	Tea* CreateTea(){
		return new PuerhTea;
	}
	Fruit* CreateFruit(){
		return new AppleFruit();
	}
};
int main(){

	AbstractFactory* factory = nullptr;
	Fruit *fruit = nullptr;
	Tea   *tea = nullptr;

	//都匀工厂
	factory = new DunyunFactory;
	tea = factory->CreateTea();
	tea->getName();
	delete tea;
	fruit = factory->CreateFruit();
	fruit->getName();
	delete fruit;

	delete factory;

	//云南工厂
	factory = new YunnanFactory;
	tea = factory->CreateTea();
	tea->getName();
	delete tea;
	fruit = factory->CreateFruit();
	fruit->getName();
	delete fruit;

	delete factory;
	return 0;
}

 

以上只是我的学习过程，真正写的牛逼还清晰的还是下边这个 。。。。。

C++ 深入浅出工厂模式（初识篇） - 知乎 (zhihu.com)

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【C++学习手札】多态：掌握面向对象编程的动态绑定与继承机制（初识）

【C++学习手札】多态：掌握面向对象编程的动态绑定与继承机制（初识）

&#x1f3ac;慕斯主页&#xff1a;修仙—别有洞天 ♈️今日夜电波&#xff1a;世界上的另一个我 1:02━━━━━━️&#x1f49f;──────── 3:58 &#x1f504; ◀️ ⏸ ▶️ ☰ &am…
阅读更多...
删除链表的倒数第N个节点

删除链表的倒数第N个节点

删除链表的倒数第N个节点 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 进阶&#xff1a;你能尝试使用一趟扫描实现吗&#xff1f; 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5] 示例…
阅读更多...
信息安全认证 | CISP证书怎么样？值得考吗？

信息安全认证 | CISP证书怎么样？值得考吗？

HCIE考证研究所的朋友们&#xff0c;新年快乐&#xff01; 今天给大家说说CISP证书&#xff0c;新的一年祝大家逢考必过啊~ 01 考注册信息安全工程师证书的用处 CISP证书可作为学识和技能证明&#xff1b;求职、任职、晋升、加薪的资格凭证&#xff1b;用人单位招聘、录用劳动…
阅读更多...
Python函数（一）

Python函数（一）

目录 一、定义函数 &#xff08;一&#xff09;向函数传递信息 &#xff08;二&#xff09;实参和形参 二、传递实参 &#xff08;一&#xff09;位置实参 &#xff08;二&#xff09;关键字实参 &#xff08;三&#xff09;默认值 &#xff08;四&#xff09;等效的函…
阅读更多...
【监控】spring actuator源码速读

【监控】spring actuator源码速读

目录 1.前言 2.先搂一眼EndPoint 3.EndPoint如何被注入 4.EndPoint如何被暴露 4.1.如何通过http暴露 4.2.如何通过jmx暴露 5.EndPoint是怎么实现监控能力的 6.知道这些的意义是什么 1.前言 版本&#xff1a;spring-boot-starter-actuator 2.6.3 阅读源码一定要带着疑…
阅读更多...
【C++学习手札】多态：掌握面向对象编程的动态绑定与继承机制（深入）

【C++学习手札】多态：掌握面向对象编程的动态绑定与继承机制（深入）

&#x1f3ac;慕斯主页&#xff1a;修仙—别有洞天 ♈️今日夜电波&#xff1a;世界上的另一个我 1:02━━━━━━️&#x1f49f;──────── 3:58 &#x1f504; ◀️ ⏸ ▶️ ☰ &am…
阅读更多...
VQ30 广告点击的高峰期（order by和limit的连用）

VQ30 广告点击的高峰期（order by和limit的连用）

代码 select hour(click_time) as click_hour ,count(hour(click_time)) as click_cnt from user_ad_click_time group by click_hour order by click_cnt desc limit 1知识点 order by和limit的连用&#xff0c;取出所需结果 YEAR() 返回统计的年份 MONTH() 返回统计的月份 D…
阅读更多...
渗透测试练习题解析 4（CTF web）

渗透测试练习题解析 4（CTF web）

1、[GXYCTF2019]禁止套娃 1 考点&#xff1a;git 泄露 进入靶场后只有一串文字&#xff0c;源代码、抓包之类的都没有敏感信息出现&#xff0c;直接用 kali 的 dirsearch 扫描 发现存在 .git 目录&#xff0c;猜测应该是源码泄露&#xff0c;使用 GitHack 扒一下源码&#xff0…
阅读更多...
什么是生产排产管理系统？哪个最好用？

什么是生产排产管理系统？哪个最好用？

阅读本文&#xff0c;你将了解&#xff1a;一、生产排产管理系统是什么&#xff1b;二、生产排产管理系统的功能&#xff1b;三、盘点五款好用的生产排产管理系统&#xff1b;四、生产排产管理系统的优势。 一、生产排产管理系统是什么 生产排产&#xff0c;也叫生产计划排程…
阅读更多...
详解Sora，为什么是AGI的又一个里程碑时刻？

详解Sora，为什么是AGI的又一个里程碑时刻？

文&#xff5c;郝 鑫 编&#xff5c;王一粟、刘雨琦 2024年伊始&#xff0c;OpenAI再向世界扔了一枚AI炸弹——视频生成模型Sora。 一如一年前的ChatGPT&#xff0c;Sora被认为是AGI&#xff08;通用人工智能&#xff09;的又一个里程碑时刻。 “Sora意味着AGI实现将从1…
阅读更多...
基于Doris构建亿级数据实时数据分析系统

基于Doris构建亿级数据实时数据分析系统

背景 随着公司业务快速发展&#xff0c;对业务数据进行增长分析的需求越来越迫切&#xff0c;与此同时我们的业务数据量也在快速激增、每天的数据新增量大概在30w 左右&#xff0c;一年就会产生1 个亿的数据&#xff0c;显然基于传统MySQL数据库已经无法支撑满足以上需求 基于上…
阅读更多...
Bonjour Print Services

Bonjour Print Services

Bonjour Print Services &#xff08;apple mobile&#xff09; https://download.csdn.net/download/spencer_tseng/88845785
阅读更多...
SQL110 插入记录（一）（插入和interval关键字的用法）

SQL110 插入记录（一）（插入和interval关键字的用法）

代码 insert into exam_record(uid,exam_id,start_time,submit_time,score) values(1001,9001,2021-09-01 22:11:12,2021-09-01 22:11:12interval 50 minute,90), (1002,9002,2021-09-04 07:01:02,null,null)知识点 interval关键字的用法 INTERVAL关键字一般使用格式为&#x…
阅读更多...
0206-1-网络层

0206-1-网络层

第 4 章 网络层 网络层提供的两种服务 虚电路服务 数据报服务 概要: 虚电路服务与数据报服务的对比 网际协议 IP 网际协议 IP 是 TCP/IP 体系中两个最主要的协议之一。与 IP 协议配套使用的还有四个协议&#xff1a; 地址解析协议 ARP (Address Resolution Protocol)逆地…
阅读更多...
【STM32】软件SPI读写W25Q64芯片

【STM32】软件SPI读写W25Q64芯片

目录 W25Q64模块 W25Q64芯片简介 硬件电路 W25Q64框图 Flash操作注意事项 状态寄存器 ​编辑 指令集 INSTRUCTIONS​编辑 ​编辑 SPI读写W25Q64代码 硬件接线图 MySPI.c MySPI.h W25Q64 W25Q64.c W25Q64.h main.c 测试 SPI通信&#xff08;W25Q64芯片简介&am…
阅读更多...
【数据结构与算法】递归、回溯、八皇后 一文打尽！

【数据结构与算法】递归、回溯、八皇后 一文打尽！

&#x1f389;&#x1f389;欢迎光临&#x1f389;&#x1f389; &#x1f3c5;我是苏泽&#xff0c;一位对技术充满热情的探索者和分享者。&#x1f680;&#x1f680; &#x1f31f;特别推荐给大家我的最新专栏《数据结构与算法&#xff1a;初学者入门指南》&#x1f4d8;&am…
阅读更多...
山西电力市场日前价格预测【2024-02-19】

山西电力市场日前价格预测【2024-02-19】

日前价格预测 预测说明&#xff1a; 如上图所示&#xff0c;预测明日&#xff08;2024-02-19&#xff09;山西电力市场全天平均日前电价为377.52元/MWh。其中&#xff0c;最高日前电价为557.55元/MWh&#xff0c;预计出现在08:15。最低日前电价为247.93元/MWh&#xff0c;预计…
阅读更多...
个人简历补充

个人简历补充

个人简历补充 1.对工作的认识2.八股文和知识面3.框架/架构角度深扒3.1 前端3.1.1 mPaaS&#xff08;移动领域&#xff09;3.1.2 普通前端项目框架3.1.3 微前端 3.2 后端 持续更新 1.对工作的认识 2.八股文和知识面 前端&#xff08;基础知识 / 开发能力 / 总结输出能力&#xf…
阅读更多...
2.18总结

2.18总结

这两天在加强对最短路径的学习&#xff0c;除了Floyed比较简单之外&#xff0c;dijkstra、bell-mandford和SPFA学起来感觉有些难&#xff0c;洛谷上的模板题卡了半天都没写出来&#xff0c;最后只能通过看题解来帮助自己完成。 SPFA 算法实现&#xff1a; 最短路径算法对比比较…
阅读更多...
嵌入式学习 C++ Day5、6

嵌入式学习 C++ Day5、6

嵌入式学习 C Day5、6 一、思维导图 二、作业 1.以下是一个简单的比喻&#xff0c;将多态概念与生活中的实际情况相联系&#xff1a; 比喻&#xff1a;动物园的讲解员和动物表演 想象一下你去了一家动物园&#xff0c;看到了许多不同种类的动物&#xff0c;如狮子、大象、猴…
阅读更多...
最新文章

Copyright @ 2022~2023