c++ 设计模式 的课本范例

( 0 ) 这里补充面向对象设计的几个原则：
开闭原则OCP ： 面向增补开放，面向代码修改关闭。其实反映到代码设计上就是类的继承，通过继承与多态，可以不修改原代码，又增加新的类似的功能。
依赖倒置原则 Dependency Inversion Principle DIP ： 面向父类的虚函数编程，可以节省代码量与减少重复。

（1） 框架设计模式 model mode ： 算法的框架不变，算法的细节可以改变。主要依赖多态。

class Player
{
protected:
	int life;
	int magic;
	int attack;

	virtual void effect_self() {}
	virtual void effect_enemy() {}
	virtual bool can_burn() = 0;
public:
	Player(int life, int magic, int attack) : life(life), magic(magic), attack(attack) {}
	virtual Player(){}

	void play_effect_burn() { cout << "play_effect_burn\n"; }

	void burn()    // 模板模式：算法的框架不变，细节可以变
	{
		if (can_burn())
		{
			effect_enemy();
			effect_self();
			play_effect_burn();
		}
	}
};

class Fighter : public Player
{
public:
	Fighter() : Player(100, 100, 50) {}

	void effect_self() override { this->life -= 30; }
	void effect_enemy() override { cout << "敌人被燃烧 40 血\n"; }
	bool can_burn() override 
	{ 
		if (this->life >= 40)  return true;
		else                   return false; 
	}
};

（2）简单工厂模式：不要直接使用 new A（） 创建对象，一旦对类 A 增删和修改参数，会紧耦合，牵一发动全身，用一个函数集中使用 new A ，返回创建好的对象，如同工厂批量生产产品一样。对构造对象时 的修改也限制在工厂方法里。

class Player  // 角色父类
{
protected:
	int life;
	int magic;
	int attack;

public:
	Player(int life, int magic, int attack) : life(life), magic(magic), attack(attack) {}
	virtual Player(){}
};

class Fighter : public Player   // 战士
{
public:
	Fighter() : Player(100, 100, 50) {}
};

class Master : public Player  // 法师
{
public:
	Master() : Player(50, 300, 150) {}
};

class Create   // 把 new 语句集中在产生对象的函数里，减小代码以后升级时需要修改的范围
{
public:
	static Player* createPlayer(string str)
	{
		if(str == "fighter") 
			return new Fighter();
		else if(str == "master")
			return new Master();
	}	
};

int main()
{
	auto pFighter = Create::createPlayer("fighter");
	auto pMaster = Create::createPlayer("master");

	delete pFighter;
	delete pMaster;
	return 0;
}

但工厂函数里的 if 选择，如果要创建新类，会修改原代码。面向对象的 OCP 原则：更新代码时，尽量追加新代码，而不是修改原代码，向增加开放，向修改关闭。如此引出工厂模式。

（3） 工厂模式：符合 OCP 规则的 用工厂方式生产对象：

class Player  // 角色父类
{
protected:
	int life;
	int magic;
	int attack;

public:	Player(int life, int magic, int attack) : life(life), magic(magic), attack(attack) {}
	virtual Player(){}
};

class Fighter : public Player   // 战士
{
public:	Fighter(int life, int magic, int attack) : Player(life , magic , attack) {}
};

class Master : public Player  // 法师
{
public:	Master(int life, int magic, int attack) : Player(life, magic, attack) {}
};

class Create   // 制造生产对象的虚基类
{
public:	virtual Player* createPlayer() = 0;
	virtual Create(){}
};

class Create_Fighter : public Create  // 对应对象的工厂类
{
public:	Player* createPlayer() override { return new Fighter(50,50,50); }
};

class Create_Monster : public Create
{
public:	Player* createPlayer() override { return new Master(60,60,60); }
};

int main()
{
	auto pFactFight = new Create_Fighter();
	auto pFighter = pFactFight->createPlayer();

	auto pFactMaster = new Create_Monster();
	auto pMastr = pFactMaster->createPlayer();

	delete pFactFight;
	delete pFactMaster;
	delete pFighter;
	delete pMastr;
	return 0;
}

（4） 抽象工厂模式，比工厂模式密度更高的生产对象的模式：一个工厂类包含了多个生产对象的函数：

class Player  // 角色父类
{
protected:
	int life;
	int magic;
	int attack;

public:	Player(int life, int magic, int attack) : life(life), magic(magic), attack(attack) {}
	virtual Player(){}
};

class Fighter_Land : public Player   // 陆上战士 
{
public:	Fighter_Land(int life, int magic, int attack) : Player(life , magic , attack) {}
};

class Fighter_Sea : public Player   // 海洋战士
{
public:	Fighter_Sea(int life, int magic, int attack) : Player(life, magic, attack) {}
};

class Master_Land : public Player  // 陆上法师 ，游戏新版本，不同的游戏场景
{
public:	Master_Land (int life, int magic, int attack) : Player(life, magic, attack) {}
};

class Master_Sea : public Player  // 海洋法师
{
public:	Master_Sea(int life, int magic, int attack) : Player(life, magic, attack) {}
};

class Create   // 制造生产对象的虚基类
{
public:	
	virtual Player* createPlayer() = 0;
	virtual Player* createMaster() = 0;
	virtual Create(){}
};

class Create_Land : public Create  // 不同场景下的角色生产工厂
{
public:
	Player* createPlayer() override { return new Fighter_Land(10,10,10); }
	Player* createMaster() override { return new Master_Land(20,20,20); }
};

class Create_Sea : public Create
{
public:
	Player* createPlayer() override { return new Fighter_Sea(10,10,10); }
	Player* createMaster() override { return new Master_Sea(20, 20, 20); }
};

int main()
{
	auto pCreate_Land = new Create_Land();
	auto pFighter_Land = pCreate_Land->createPlayer();;
	auto PMaster_Land = pCreate_Land->createMaster();

	auto pCreate_Sea = new Create_Sea();
	auto pFighter_Sea = pCreate_Sea->createPlayer();
	auto pMaster_Sea = pCreate_Sea->createMaster();

	delete pCreate_Land; delete pFighter_Land; delete PMaster_Land;
	delete pCreate_Sea;  delete pFighter_Sea;  delete pMaster_Sea;

	return 0;
}

工厂模式不要忘记 delete 这些指针，包括在堆区创建的工厂对象和工厂生产的类对象，都要在最后 delete 掉，释放掉。

（5） 原型模式：通过对象原型来产生新的对象。主要是把工厂类里生产对象的方法转移到了对象类里。 clone() 函数

class Player  // 角色父类
{
protected:
	int life;
	int magic;
	int attack;

public:	
	Player(int life, int magic, int attack) : life(life), magic(magic), attack(attack) {}
	Player(const Player& p) :life(p.life), magic(p.magic), attack(p.attack) {}
	~Player() {}    // 父类应有的虚析构函数

	virtual Player* clone() = 0;
};

class Fighter_Land : public Player   // 陆上战士 
{
public:	
	Fighter_Land(int life, int magic, int attack) : Player(life , magic , attack) {}
	Fighter_Land(const Fighter_Land& p) : Player(p) {}

	Player* clone() override { return new Fighter_Land(* this); }
};

（6） 建造者模式( builder )：与工厂模式的区别是：工厂模式生产的对象简单，可以直接交付。若生产的对象复杂，比如还要组装游戏角色，加工后再返回对象 ； 或者把前端页面里的报表（有头部，主体和尾部）组合转换为 txt 、 xmL、json 格式交给后端处理。只有经过对对象的加工处理，才可以得到复杂的对象，就是建造者模式，建造二字突出其是要创建复杂对象，突出建造的复杂性。而且可以把加工建造对象的过程单独拎出来实现批量建造。

class Player  // 角色父类
{
protected:
	int life;
	int magic;
	int attack;
public:
	virtual ~Player() {}    // 父类应有的虚析构函数
	Player(int life, int magic, int attack) : life(life), magic(magic), attack(attack) {}
};

class Fighter : public Player   // 战士 
{
public:
	Fighter(int life, int magic, int attack) : Player(life, magic, attack) {}
};

class Create   // 制造生产对象的虚基类
{
protected:
	Player* ptrPlayer;
public:
	virtual ~Create() { if (ptrPlayer) delete ptrPlayer; }  // 这里析构函数要释放指针

	Player* getPlayer() { return std::exchange(ptrPlayer, nullptr); }

	virtual void loadHead() = 0;
	virtual void loadTrunk() = 0;
	virtual void loadFeet() = 0;
};

class Create_Fight : public Create  // 制造战士的工厂
{
public:
	Create_Fight() :Create() { ptrPlayer = new Fighter(10, 10, 10); }
	void loadHead()  override { cout << "load head\n"; }
	void loadTrunk() override { cout << "load trunk\n"; }
	void loadFeet()  override { cout << "load feet\n"; }
};

class Assemble
{
private:
	Create* ptrCreate;
public:
	Assemble(Create* t) : ptrCreate(t) {}
	Player* assemble()
	{
		ptrCreate->loadHead();
		ptrCreate->loadTrunk();
		ptrCreate->loadFeet();

		return ptrCreate->getPlayer();
	}
};

int main()
{
	auto pFighterCreate = new Create_Fight();
	auto pAssemble = new Assemble(pFighterCreate);
	auto pFight = pAssemble->assemble();

	delete pFighterCreate;  // 经测试没有内存泄露
	delete pAssemble;
	delete pFight;

	return 0;
}

本模式另举一例：根据前端页面的报表来构造完整的数据报表，供后端使用：

在这里插入图片描述

相关代码如下：

class Head  // 日报头
{
private:
	string department;
	string date;
public:
	Head(const string& dep, const string& time) : department(dep), date(time) {}
	string& getDepart() { return department; }
	string& getDate()   { return date; }
};

class Content  // 日报内容
{
private:
	string content;
	double totalTime;
public:
	Content(const string& cont, const double& time) : content(cont), totalTime(time) {}
	string& getContent() { return content; }
	double& getTotalTime() { return totalTime; }
};

class Foot   // 日报尾
{
private:
	string name;
public:
	Foot(const string& name) :name(name) {}
	string& getName() { return name; }
};

class Builder   // 建造完整的日报
{
protected:
	string result;
public:
	virtual ~Builder() { }

	virtual void buildHead( Head * ) = 0;
	virtual void buildCont(vector<Content* >& vec) = 0;
	virtual void buildFoot(Foot*) = 0;
    string& getRes() { return result; }  // 返回左值引用
};

class Txt_builder : public Builder  // 建造 txt 型日报
{
public:
	void buildHead(Head* pHead) override
	{		
		result += pHead->getDepart() + " , " + pHead->getDate() + "\n";
	}
	void buildCont(vector<Content* >& vec) override
	{
		for (auto iter = vec.begin(); iter != vec.end(); iter++)
		{
			ostringstream oss;  // 此对象在每次 for 循环中都会被创建和释放，
			oss << (*iter)->getTotalTime();  // 所以输入到 oss 中的内容并不会积累。
			result += (*iter)->getContent() + " ,花费小时：" + oss.str() + '\n';
		}
	}
	void buildFoot(Foot* pFoot) override
	{
		result += "报告人：" + pFoot->getName() + '\n';
	}
};

class Assemble   // 本类可以组装各种日报： txt 、 xmL 、 Json
{
private: 
	Builder* builder;
public:
	Assemble(Builder* builder) : builder(builder) {}
	string& assemble(Head * head , vector<Content * >& vec , Foot * foot)
	{
		builder->buildHead(head);
		builder->buildCont(vec);
		builder->buildFoot(foot);

		return builder->getRes();
	}
};

int main()
{
	Head head("研发部" , "7.13");
	Content conA("分析文档"  , 3.5);
	Content conB("选定语言"  , 0.5);
	Foot foot("zhangwuji");

	vector<Content*> vecCont{&conA , &conB};

	Txt_builder txtBuilter;
	Assemble assemble(&txtBuilter);
	auto strResult = assemble.assemble(&head , vecCont , &foot);
	cout << strResult << endl;
	return 0;
}

这里给出测试结果：

在这里插入图片描述

（7） 策略模式 Strategy 。类似于框架模式：策略的框架不变，实现细节会变，但比框架模式更复杂一点。还是以上面的游戏角色为例，战士和法师都可以采用回血策略，回血策略又可以分为小药回小血，中药回中血，大药回大血的不同具体策略，甚至随着游戏扩展，还有新的策略，或修订原有的策略。

class Strategy;  // 前置声明，否则编译报错
class Player;

class Strategy
{
public:
	virtual ~Strategy() {}
	virtual void heal(Player*) = 0;
};


class Player  // 角色父类
{
protected:
	int life;
	int magic;
	int attack;
	Strategy* pStrategy ;
public:	
	virtual ~Player() {}    // 父类应有的虚析构函数
	Player(int life, int magic, int attack) : life(life), magic(magic), attack(attack), pStrategy(nullptr){}

	int getLife() { return life; }
	void setLife(int t) { life = t; }
	void setStrategy(Strategy* p) { pStrategy = p; }
	void heal() { pStrategy->heal(this); }
};

class Fighter : public Player   // 战士 
{
public:	
	Fighter(int life, int magic, int attack) : Player(life , magic , attack) {}
};

class Master : public Player  // 法师 
{
public:	Master (int life, int magic, int attack) : Player(life, magic, attack) {}
};

class Strategy_Small_Medi : public Strategy
{
public:
	void heal(Player* ptr) { ptr->setLife( ptr->getLife() + 200 ); }
};

class Strategy_Middle_Medi : public Strategy
{
public:
	void heal(Player* ptr) { ptr->setLife(ptr->getLife() + 300); }
};

int main()
{
	Fighter fight(100, 100, 100);
	Strategy_Small_Medi small;
	fight.setStrategy(&small);
	fight.heal();
	return 0;
}

(8) 观察者模式observer , 也叫 发布–订阅模式，Publish – Subscribe 。 订阅者就是观察者。因为发布者的信息要群发，所以就要注意提升遍历数据库时的效率，尽可能快速的把消息发布给所有的订阅者。重在良好组织所有对象的存储方式，加快对订阅者的遍历速度： 比如 map 容器的遍历就比 list 要快。

class Player;

class Manager   // 管理，充当数据库的角色，管理玩家角色的组信息
{
public:
	virtual ~Manager() {}
	virtual void joinFamily(Player *) = 0;
	virtual void leaveFamily(Player*) = 0;
	virtual void notify(Player* , const string & ) = 0;
};

class Player  // 角色父类
{
protected:
	int id;
	int familyID;
	string name;
public:	
	virtual ~Player() {}    // 父类应有的虚析构函数
	Player(int id, const string& name) : id(id), name(name) { familyID = -1; }

	void setFamily(int t) { familyID = t; }
	int getFamily() { return familyID; }
	void speak(const string& str, Manager* maga) { maga->notify(this, str); }
	void getNotice( Player * player , const string & str ) 
	{
		cout << name << "  的电脑显示  " << player->name << "  的信息： " << str << "\n\n";
	}
};

class Fighter : public Player   // 战士 
{
public: 	Fighter(int id, const string & name) : Player(id, name) {}
};

class Master : public Player   // 法师
{
public:  	Master(int id, const string& name) : Player(id, name) {}
};

class Manager_Fighter : public Manager // 采用默认的构造函数
{
private:
	map<int, list<Player*>> allFamily;  // 管理所有的有家族的角色，以家族的方式管理角色
public:
	virtual void joinFamily(Player* player) override
	{
		int familyID = player->getFamily();

		if (familyID != -1)  // 要插入家族树的角色必须具有有效的家族 id 
		{
			auto iter = allFamily.find(familyID);

			if (iter != allFamily.end())  // 该家族已在家族树中
				iter->second.push_back(player);
			else             // 出现了新的家族，要先把家族链表 list 创建并插入 map 中
			{
				list<Player*> list;
				allFamily.insert(make_pair(familyID , list));
				allFamily[familyID].push_back(player);  // 理解难度在于 STL 库容器中 map 的成员方法的使用
			}
		}
	}

	virtual void leaveFamily(Player * player) override
	{
		int familyID = player->getFamily();
		
		if (familyID != -1)
		{
			auto iter = allFamily.find(familyID);

			if (iter != allFamily.end())
				allFamily[familyID].remove(player);  // list 允许插入相同的节点。也会被全部删除。当然指针是不会相同的
		}
	}

	virtual void notify(Player* speaker, const string& str) override
	{
		int familyID = speaker->getFamily();
		
		if (familyID != -1)
		{
			auto iter = allFamily.find(familyID);

			if (iter != allFamily.end())
				for (auto iterList = iter->second.begin(); iterList != iter->second.end(); iterList++)
					(*iterList)->getNotice(speaker, str);
		}
	}
};


int main()
{
	Fighter zhang(10, "张三");
	Fighter zhao(11, "赵四");
	Fighter wang(12, "王五");
	Fighter ma(13, "马虎");
	Manager_Fighter managerFight;

	zhang.setFamily(100);
	zhao.setFamily(100);
	wang.setFamily(100);
	ma.setFamily(200);

	managerFight.joinFamily(&zhang);
	managerFight.joinFamily(&zhao);
	managerFight.joinFamily(&wang);
	managerFight.joinFamily(&ma);

	zhang.speak("Hello , i love you !!" , &managerFight);

	return 0;
}

以下给出测试结果：

在这里插入图片描述

（9）
谢谢

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

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

相关文章

在Mandelbrot 集中“缩放”特定区域

在Mandelbrot 集中“缩放”特定区域

1、问题背景 在创建一个快速生成 Mandelbrot 集图像的 Python 程序时&#xff0c;程序开发者遇到一个问题&#xff1a;他想要渲染该集合的一个特定区域&#xff0c;但他不知道如何修改代码中的数学部分来实现 “缩放”。 2、解决方案 第一种解决方案 问题根源是代码中的一行…
阅读更多...
qt开发-14_QListwidget 仿qq好友列表制作

qt开发-14_QListwidget 仿qq好友列表制作

QListWidget 继承 QListView。QListWidget 类提供了一个基于项的列表小部件。QListWidg et 是一个便捷的类&#xff0c;它提供了一个类似于 QListView&#xff08;下一小节将讲到&#xff09;提供的列表视图&#xff0c;但 是提供了一个用于添加和删除项目的基于项目的经典接口…
阅读更多...
智慧互联：Vatee万腾平台展现科技魅力

智慧互联：Vatee万腾平台展现科技魅力

随着科技的迅猛发展&#xff0c;我们的生活正逐渐变得智能化、互联化。在这个信息爆炸的时代&#xff0c;一个名为Vatee万腾的平台正以其独特的魅力&#xff0c;引领我们走向一个更加智能的未来。 Vatee万腾&#xff0c;这个名字本身就充满了对科技未来的憧憬与期待。作为一家专…
阅读更多...
Jacob------VBA的局限性（复杂批注的获取方式）

Jacob------VBA的局限性（复杂批注的获取方式）

问题再现&#xff1a; 同一个字段被多个批注 使用VBA代码是获取不到他们的关系的 &#xff0c;原因如下&#xff1a; 同一个字段被多个批注&#xff0c;并且每个批注都有回复是无法通过VBA语言获取的 &#xff0c;解释如下&#xff1a; ① 微软Microsoft 官方文档 提供的API …
阅读更多...
微信营销自动化(朋友圈自动点赞工具)：UIAutomation的解决方案

微信营销自动化(朋友圈自动点赞工具)：UIAutomation的解决方案

文章不用看, 是AI生成的, 请直接查看下载地址 http://www.aisisoft.top . 微信朋友圈自动点赞工具, 自动群发工具 在当今的数字化营销领域&#xff0c;自动化工具成为了提升工作效率、增强客户互动的关键。本文将详细介绍一款基于UIAutomation框架与Python语言构建的微信营销自…
阅读更多...
【MySQL】如果表被锁可以尝试看一下事务

【MySQL】如果表被锁可以尝试看一下事务

今天在MySQL中删除表的时候&#xff0c;发现无法删除&#xff0c;一执行drop&#xff0c;navicat就卡死。 通过 SHOW PROCESSLIST显示被锁了 kill掉被锁的进程后依旧被锁 最后发现是由于存在为执行完的事务 SELECT * FROM INFORMATION_SCHEMA.INNODB_TRX; kill掉这些事务以…
阅读更多...
Excel 查找后隐去右边列

Excel 查找后隐去右边列

Excel 有几列数字 ABC11002042002202100102326027010841199100512100100 当给定参数时&#xff0c;请从每行找到该参数&#xff0c;隐去右边的列。如果某行不含该参数&#xff0c;则隐去整行。当参数是 100 时&#xff0c;结果如下&#xff1a; ABC710082021009119910010121…
阅读更多...
挑战极限外，交易无疆界

挑战极限外，交易无疆界

交易&#xff0c;并非是仅限于金融行业的专属舞台&#xff01;在Eagle Trader&#xff0c;我们深信&#xff0c;无论您来自何方&#xff0c;都怀揣着独特的视角和优势&#xff0c;能在交易场上展现出别具一格的策略。 我们热烈欢迎来自各行各业的交易者&#xff0c;因为正是你…
阅读更多...
随心笔记，第七更之Java 加密Jar包

随心笔记，第七更之Java 加密Jar包

目录 一、Linux搭建golang环境 二、Jar包加密 &#xff08;一&#xff09;、环境配置 &#xff08;1&#xff09;Linux &#xff08;1&#xff09;下载Go语言二进制包 &#xff08;2&#xff09;解压缩到/usr/local目录 &#xff08;3&#xff09;设置环境变量 &#x…
阅读更多...
vue3，pinia状态管理，手写插件实现持久化

vue3，pinia状态管理，手写插件实现持久化

状态管理和持久化 先简单概述一下状态管理和持久化 状态管理&#xff1a;使任意两个组件共享数据持久化&#xff1a;将共享的数据保存在本地&#xff0c;不随页面销毁而消失 要实现状态的持久化&#xff0c;可以直接采用插件的形式实现&#xff0c;插件其实就是一个函数&#…
阅读更多...
【多通道卷积终结篇，通俗易懂，清晰必读】

【多通道卷积终结篇，通俗易懂，清晰必读】

作为常识&#xff0c; 1、卷积层 输出特征图通道数 卷积核个数 与输入特征图通道数无关&#xff0c; 2、多卷积核处理多通道特征图的机制过程如下&#xff1a; 本文的参考资料为知乎&#xff1a;一文读懂Faster RCNN。 对于多通道图像多卷积核做卷积&#xff0c;计算方式如…
阅读更多...
Java 编程语言：过去、现在与未来

Java 编程语言：过去、现在与未来

引言 自 1995 年由 Sun Microsystems 发布以来&#xff0c;Java 编程语言已经走过了漫长的道路。作为一种面向对象的编程语言&#xff0c;Java 因其“一次编写&#xff0c;到处运行”的理念而广受欢迎。本文将探讨 Java 的历史、主要特点、应用领域以及未来的发展趋势。 Java…
阅读更多...
使用 Mac 数据恢复从 iPhoto 图库中恢复照片

使用 Mac 数据恢复从 iPhoto 图库中恢复照片

我们每个人都会遇到这种情况&#xff1a;在意识到我们不想丢失照片之前&#xff0c;我们会永久删除 iPhoto 图库中的一些照片。永久删除这些照片后&#xff0c;是否可以从 iPhoto 图库中恢复照片&#xff1f;本文将指导您使用免费的 Mac 数据恢复软件从 iPhoto 中恢复照片。 i…
阅读更多...
【漏洞复现】锐捷统一上网行为管理与审计系统——远程命令执行漏洞

【漏洞复现】锐捷统一上网行为管理与审计系统——远程命令执行漏洞

声明&#xff1a;本文档或演示材料仅供教育和教学目的使用&#xff0c;任何个人或组织使用本文档中的信息进行非法活动&#xff0c;均与本文档的作者或发布者无关。 文章目录 漏洞描述漏洞复现测试工具 漏洞描述 锐捷统一上网行为管理与审计系统naborTable/static_convert.php…
阅读更多...
AIGC遇上ChatGPT，互联网公司的创意设计师，还能做什么？

AIGC遇上ChatGPT，互联网公司的创意设计师，还能做什么？

随着科技的日新月异&#xff0c;AIGC&#xff08;人工智能生成内容&#xff09;和ChatGPT等AI技术的涌现&#xff0c;为互联网公司的创意设计师们描绘了一幅充满挑战与机遇的新图景。在这个数字化、智能化的新时代&#xff0c;创意设计师们不仅要保持敏锐的审美眼光和源源不断的…
阅读更多...
梅雨季，祛湿不健脾，湿气易反复！4个方法助您健脾胃，祛湿气！

梅雨季，祛湿不健脾，湿气易反复！4个方法助您健脾胃，祛湿气！

进入梅雨季以来&#xff0c;苏州连续降雨&#xff0c;空气湿度增加&#xff0c;我们身体内的湿气也愈加严重&#xff1a;身上胖嘟嘟、脸上油乎乎、身体困重、乏力&#xff0c;极易疲劳&#xff0c;食欲减退&#xff0c;头昏昏沉沉的&#xff0c;大便也十分黏腻…… 关于祛湿&am…
阅读更多...
东昂科技从创业板改道北交所：大客户依赖症明显，巨额分红又募投补流

东昂科技从创业板改道北交所：大客户依赖症明显，巨额分红又募投补流

《港湾商业观察》施子夫 黄懿 2024年6月24日&#xff0c;厦门东昂科技股份有限公司&#xff08;以下简称&#xff0c;东昂科技&#xff09;在北交所网站披露第二轮审核问询函的回复。自2024年1月IPO申请获北交所受理以来&#xff0c;东昂科技已经收到北交所下发的两轮审核问询…
阅读更多...
使用官方新工具手动升级 Quest 操作系统

使用官方新工具手动升级 Quest 操作系统

Meta 近期推出了一款用于手动升级 Meta Quest 系统的工具&#xff0c;为用户提供了更多选择。本文将详细介绍如何使用这一工具进行系统升级。 优势与劣势 优势&#xff1a; 安装迅速&#xff1a;升级速度相比在线自动升级快&#xff0c;且可实时查看进度 即时升级&#xff1…
阅读更多...
筛斗数据：数据提取技术，让信息海洋变得有序

筛斗数据：数据提取技术，让信息海洋变得有序

在数字化时代&#xff0c;信息如同浩渺的海洋&#xff0c;源源不断地涌入我们的生活和工作。然而&#xff0c;这个信息海洋的浩瀚与繁杂也给我们带来了挑战&#xff1a;如何在海量的数据中快速找到有价值的信息&#xff1f;数据提取技术&#xff0c;作为一种强大的工具&#xf…
阅读更多...
权威VS实战：如何权衡六西格玛培训证书的两种价值？

权威VS实战：如何权衡六西格玛培训证书的两种价值？

当我们谈论六西格玛培训证书时&#xff0c;我们不得不提到两种截然不同的“身份象征”。一种是由专业培训机构颁发的证书&#xff0c;这种证书在质量管理领域同样具有不可忽视的价值。 培训机构颁发的六西格玛证书&#xff0c;不仅代表着你已经完成了他们精心设计的培训课程&a…
阅读更多...
最新文章

Copyright @ 2022~2023