设计模式学习记录

设计模式23种

  • 创建型
    • 抽象工厂模式
    • 工厂模式
    • 生成器模式
    • 原型模式
    • 单例模式
  • 结构型
    • 适配器模式
    • 桥接模式
    • 组合模式
    • 装饰模式
    • 外观模式
    • 享元模式
    • 代理模式
  • 行为型
    • 责任链模式
    • 命令模式
    • 解释器模式
    • 迭代器模式
    • 中介者模式
    • 备忘录模式
    • 观察者模式
    • 状态模式
    • 策略模式
    • 模版方法模式
    • 访问者模式

创建型

与对象的创建有关

抽象工厂模式

提供一个创建一系列相关或相互依赖的对象的接口

//来1张1费卡  1张2费卡 一系列相关
class Card {
public:virtual void out() = 0;
};
//还可以定义更多的卡牌
class CardCost1:public Card {
public:virtual void out() {cout << "我是1费卡" << endl;}
};class CardCost2 :public Card {
public:virtual void out() {cout << "我是2费卡" << endl;}
};class Factory {
public:virtual Card* CreateCost1() = 0;virtual Card* CreateCost2() = 0;
};
//还可以定义更多的工厂来组合
class CardFactory:public Factory {
public:Card* CreateCost1() {//来一张1费卡return new CardCost1();}Card* CreateCost2() {//来一张2费卡return new CardCost2();}
};
class CardFamaly
int main() {CardFactory *fac = new CardFactory();Card* cost1 = fac->CreateCost1();Card* cost2 = fac->CreateCost2();cost1->out();cost2->out();delete cost1;delete cost2;delete fac;return 0;
}

工厂模式

定义一个用于创建对象的接口,让子类决定实例化哪个类
//和抽象工厂区别是 1个和多个?

class Card {
public:virtual void out() = 0;
};class CardCost1:public Card {
public:virtual void out() {cout << "我是1费卡" << endl;}
};class CardCost2 :public Card {
public:virtual void out() {cout << "我是2费卡" << endl;}
};
class Factory {
public:virtual Card* Create() = 0;
};class CardCost1Factory:public Factory {
public:Card* Create() {return new CardCost1();}
};class CardCost2Factory :public Factory {
public:Card* Create() {return new CardCost2();}
};
int main() {CardCost1Factory* fac1 = new CardCost1Factory();CardCost2Factory* fac2 = new CardCost2Factory();Card* cost1 = fac1->Create();Card* cost2 = fac2->Create();cost1->out();cost2->out();delete cost1;delete cost2;delete fac1;delete fac2;return 0;
}

生成器模式

在某些情况下,一个对象的创建过程非常复杂,涉及多个步骤,每个步骤都可能有不同的实现方式。如果将所有创建逻辑放在一个类中,会导致该类变得庞大且难以维护。此外,如果需要创建不同的变体对象,就需要在该类中添加更多的逻辑,使得代码变得混乱。

原型模式

克隆

单例模式

就是单例

结构型

适配器模式

将一个类的接口转变为另外一个希望的接口

template<typename Type>
void permutation(Type first, int len) {int val = 1;for (int i = 0; i < len; i++) {*first = val;val++;first++;}
}int main() {vector<int> a;//本来vector 不能用 = int 赋值 ++//把vector =>back_insert_iterator(重载++ = ) 调用vector push_backpermutation(back_inserter(a), 10);int b[20];permutation(b, 10);return 0;
}

桥接模式

将抽象部分和其实现部分分离,使它们都可以独立的变化

//羁绊
class Jiban {
public:virtual void out() = 0;
};class Family :public Jiban {
public:virtual void out() {cout << " 家人 " << endl;}
};class ZhenMan :public Jiban {
public:virtual void out() {cout << " 铁血屈服者 " << endl;}
};
//英雄
class Hero {
public:virtual void out() = 0;virtual void SetJiban(Jiban* jb) = 0;Jiban* m_jb = nullptr;
};class BaoBao:public Hero {
public:virtual void out() {cout << " 爆爆 ";m_jb->out();}virtual void SetJiban(Jiban* jb) {m_jb = jb;}};class JieSi :public Hero {
public:virtual void out() {cout << " 杰斯 ";m_jb->out();}virtual void SetJiban(Jiban* jb) {m_jb = jb;}
};int main() {Family* family = new Family;ZhenMan* zm = new ZhenMan;JieSi* js = new JieSi();BaoBao* bb = new BaoBao();js->SetJiban(zm);bb->SetJiban(family);js->out();bb->out();return 0;}

组合模式

将对象组合成树型结构以表示整体与部分的层次结构
文件系统

装饰模式

动态的给一个对象添加一些额外的职责

class Water {
public:virtual int cost() = 0;virtual void out() = 0;
};class Wahaha :public Water {
public:virtual int cost() {return 2;}virtual void out() {cout << "娃哈哈";}
};class WaterDecorator :public Water {
public:WaterDecorator(Water* self) {m_self = self;}virtual int cost() {return m_self->cost();}virtual void out() {m_self->out();}Water* m_self;
};
//加冰
class IceDecorator :public WaterDecorator {
public:IceDecorator(Water* self) :WaterDecorator(self) {}virtual int cost() {return 1 + m_self->cost();}virtual void out() {m_self->out();cout << " 加冰 ";}
};
//加糖
class SugarDecorator :public WaterDecorator {
public:SugarDecorator(Water* self) :WaterDecorator(self) {}virtual int cost() {return 1 + m_self->cost();}virtual void out() {m_self->out();cout << " 加糖 ";}
};int main() {Wahaha* whh = new Wahaha();{IceDecorator* d = new IceDecorator(whh);SugarDecorator* d2 = new SugarDecorator(d);d2->out();cout << d2->cost() << endl;}return 0;
}

外观模式

为子系统中一组接口提供一个一致的界面

class Computer {
public:void turnOn() {cout << " 开电脑 ";}void turnOff() {cout << " 关电脑 ";}
};
class Light {
public:void turnOn() {cout << " 开灯 ";}void turnOff() {cout << " 关灯 ";}
};class MyLife {Computer computer;Light light;
public:void play() {computer.turnOn();light.turnOn();cout << endl;}void sleep() {computer.turnOff();light.turnOff();cout << endl;}
};int main() {MyLife* mf = new MyLife;mf->play();mf->sleep();return 0;
}

享元模式

运用共享技术有效的支持大量细粒度的对象

struct Base {
public:string name;int gongji;//攻击int fangyu;//防御
};class BaoBao{
public:BaoBao(Base *base) {m_base = base;x = y = 0;}Base* m_base;int x, y;//坐标
};class BaoBaoFactory {public:BaoBao* GetHero() {Base* base = nullptr;if (mmp.count("爆爆"))base = mmp["爆爆"];else {base = new Base;base->name = "爆爆";base->gongji = 999;base->fangyu = 999;mmp[base->name] = base;}return new BaoBao(base);}unordered_map<string, Base *> mmp;
};int main() {BaoBaoFactory* fac = new BaoBaoFactory();vector<BaoBao* > all;for (int i = 0; i < 100; i++) {all.push_back(fac->GetHero());}return 0;
}

代理模式

行为型

行为模式涉及算法和对象间职责的分配。行为模式不仅描述对象或类的模式,还描述它们之间的通信模式

责任链模式

使多个对象都有机会处理请求,从而避免请求的发送者和接受者之间的耦合关系。将这些对象连成一条链,并沿着这条链传递改请求,直到有一个对象处理它为止。

class Request {
public:Request(int m, string i) :money(m), info(i) {}int money;string info;
};class RequestHandler {
public:virtual void DoHandle(Request* req) = 0;void SetHandler(RequestHandler* handler) {m_handler = handler;}RequestHandler* m_handler = nullptr;
};class Father :public RequestHandler {
public:virtual void DoHandle(Request* req) {if (req->money <= 20) {cout << "Father Handler,give money = " << req->money << endl;}else if (m_handler) {req->money += 1000;m_handler->DoHandle(req);}}
};class Mother :public RequestHandler {
public:virtual void DoHandle(Request* req) {if (req->money <= 5000) {cout << "Mother Handler,give money = " << req->money << endl;}else if (m_handler) {m_handler->DoHandle(req);}}
};int main() {Request* r = new Request(500, "补课费");Father* f = new Father();Mother* m = new Mother();f->SetHandler(m);f->DoHandle(r);return 0;
}

命令模式

将一个请求封装为一个对象,从而使得可以用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可撤销操作。

class Light {
public:void TurnOn() {cout << "light TurnOn" << endl;}void TurnOff() {cout << "light TurnOff" << endl;}
};class Command {
public:virtual void exe() = 0;
};class OpenCommand :public Command {
public:void setLight(Light* light) {m_light = light;}virtual void exe() {m_light->TurnOn();}Light* m_light;
};class CloseCommand :public Command {
public:void setLight(Light* light) {m_light = light;}virtual void exe() {m_light->TurnOff();}Light* m_light;
};int main() {Light* light = new Light;OpenCommand* open = new OpenCommand;CloseCommand* close = new CloseCommand;open->setLight(light);close->setLight(light);open->exe();close->exe();return 0;
}

解释器模式

给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。

迭代器模式

提供一种顺序访问一个聚合对象中的各个元素,且不需要暴露该对象的内部表示。

中介者模式

用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立的改变它们之间的交互。

class User;
class middleman {
public:virtual void sendMessage(string &msg, User* sender) = 0;virtual void addUser(User* user) = 0;
};class User {
public:User(string name, middleman* middleman):m_name(name),m_middleman(middleman){middleman->addUser(this);}void sendMessage(string &msg) {cout << m_name << ":Say " << msg << endl;m_middleman->sendMessage(msg,this);}void recvMessage(string& msg) {cout << m_name << ":Recv " << msg << endl;}string m_name;middleman* m_middleman;
};class ChatRoom :public middleman {vector<User*> m_all;
public:virtual void sendMessage(string &msg,User * sender) {for (auto user : m_all) {if (user == sender)continue;user->recvMessage(msg);}}virtual void addUser(User* user) {m_all.push_back(user);}
};int main() {ChatRoom* room = new ChatRoom();User* user1 = new User("小明", room);User* user2 = new User("小花", room);User* user3 = new User("康康", room);string msg = "How are you";user3->sendMessage(msg);return 0;
}

备忘录模式

在不破坏封装性的前提下捕获一个对象的内部状态,并在对象之外保存这个状态。这样以后就可以将对象恢复原先保存的状态。

观察者模式

定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并自动更新。
和中介者模式区别 1对多 和 多对多 树和图?

//观察者
class Observer {
public:virtual void update(int state) = 0;
};class ActObserver:public Observer {
public:ActObserver(string name, int state) :m_name(name), m_state(state) {}virtual void update(int state) {m_state = state;cout << m_name << ":update state = " << m_state << endl;}
private:string m_name;int m_state;
};//主题
class Subject {
public:virtual void addObserver(Observer *observer) = 0;virtual void removeObserver(Observer* observer) = 0;virtual void notify() = 0;
};class ActSubject {
public:virtual void addObserver(Observer* observer) {m_all.insert(observer);}virtual void removeObserver(Observer* observer) {m_all.erase(observer);}virtual void notify() {for (auto ob : m_all) {ob->update(m_state);}}
public:void setState(int state) { m_state = state;notify();}
private:set<Observer*> m_all;int m_state;
};int main() {ActObserver* aob = new ActObserver("小美", 0);ActObserver* aob2 = new ActObserver("小帅", 0);ActSubject* sub = new ActSubject();sub->addObserver(aob);sub->addObserver(aob2);sub->setState(2);sub->removeObserver(aob);sub->setState(1);return 0;
}

状态模式

允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。
把一堆if else 放到一个一个单独的类中处理

class State;
class Context {
public:virtual void SetState(State* state) = 0;
};class State {
public:virtual void handle(Context* context) = 0;Context *m_context = nullptr;
};class StateA :public State {
public:virtual void handle(Context* context) {cout << "StateA" << endl;//本来 if else 一坨 把每个状态拆在一个单独的类中处理 context->SetState(this);}
};class StateB :public State {
public:virtual void handle(Context* context) {cout << "StateB" << endl;context->SetState(this);}
};class ContextA :public Context {
public:ContextA() {m_state = new StateA();}virtual void SetState(State* state) {m_state = state;}void ChangeState(State* state) {state->handle(this);}State* m_state;
};int main() {StateA* A = new StateA();StateB* B = new StateB();ContextA* C = new ContextA();C->ChangeState(A);C->ChangeState(B);C->ChangeState(A);return 0;
}

策略模式

定义一系列的算法,把它们一个个封装起来,并且使它们可以相互替换。此模式使得算法可以独立于使用它们的客户而变化。

class MathOperation {
public:virtual int DoOperation(int a, int b) = 0;
};
class Add :public MathOperation {
public:virtual int DoOperation(int a, int b) {//a^2 + breturn a * a + b;}
};class Sub :public MathOperation {
public:virtual int DoOperation(int a, int b) {//a - b^2return a - b * b;}
};class Calc {
public:void SetOperation(MathOperation* op) { m_op = op; }int DoIt(int a, int b) {return m_op->DoOperation(a, b);}
private:MathOperation* m_op;
};int main() {Add* add = new Add();Sub* sub = new Sub();Calc* calc = new Calc();calc->SetOperation(add);cout << "DoIt = " << calc->DoIt(1,2) << endl;calc->SetOperation(sub);cout << "DoIt = " << calc->DoIt(3, 4) << endl;return  0;
}

模版方法模式

定义一个操作中的算法骨架,而将一些步骤延迟到子类中。

class Hero {
public:virtual int getHurt() {//伤害计算算法return getPhysicsHurt() + getMagicHurt();}
public:virtual int getPhysicsHurt() = 0;//物理伤害virtual int getMagicHurt() = 0;//魔法伤害virtual string getName() = 0;};
//爆爆
class BaoBao:public Hero {
public:BaoBao(string name) :m_name(name) {}virtual int getPhysicsHurt() {return 50;}virtual int getMagicHurt() {return 100;}virtual string getName() {return m_name;}string m_name;
};//杰斯 
class JieSi :public Hero {
public:JieSi(string name) :m_name(name) {}virtual int getPhysicsHurt() {return 200;}virtual int getMagicHurt() {return 20;}virtual string getName() {return m_name;}string m_name;
};int main() {BaoBao* bb = new BaoBao("爆爆");JieSi* js = new JieSi("杰斯");cout << bb->getName() << " Hart = " << bb->getHurt() << endl;cout << js->getName() << " Hart = " << js->getHurt() << endl;return 0;
}

访问者模式

表示一个作用于某对象结构中的元素的操作。它允许在不改变各元素的类的前提下定义作用于这些元素的新操作。
英雄带装备

class Hero {
public:virtual int getPhysicsHurt() = 0;//物理伤害virtual int getMagicHurt() = 0;//魔法伤害virtual string getName() = 0;
};
//爆爆
class BaoBao:public Hero {
public:BaoBao(string name) :m_name(name) {}virtual int getPhysicsHurt() {return 50;}virtual int getMagicHurt() {return 100;}virtual string getName() {return m_name;}string m_name;
};//杰斯 
class JieSi :public Hero {
public:JieSi(string name) :m_name(name) {}virtual int getPhysicsHurt() {return 200;}virtual int getMagicHurt() {return 20;}virtual string getName() {return m_name;}string m_name;
};class Equipment {
public:virtual int getHurt(Hero* hero) = 0;
};
//帽子
class Maozi :public Equipment {
public:Maozi() {m_name = "帽子";dPhysicsRate = 1.1;dMagicRate = 2.0;}virtual int getHurt(Hero* hero) {int ans = hero->getPhysicsHurt()* dPhysicsRate + hero->getMagicHurt() * dMagicRate;cout << m_name << " " << hero->getName() << ":" << ans << endl;return ans;}
private:double dPhysicsRate;double dMagicRate;string m_name;
};int main() {BaoBao* bb = new BaoBao("爆爆");JieSi* js = new JieSi("杰斯");Maozi* mz = new Maozi();mz->getHurt(bb);mz->getHurt(js);return 0;
}

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

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

相关文章

阿里云服务器购买及环境搭建宝塔部署springboot和vue项目

云服务器ECS_云主机_服务器托管_计算-阿里云 一、前言 对于新手或者学生党来说&#xff0c;有时候就想租一个云服务器来玩玩或者练练手&#xff0c;duck不必花那么多钱去租个服务器。这些云服务厂商对学生和新手还是相当友好的。下面将教你如何快速搭建自己的阿里云服务器&…

ABAP语言的动态编程(4) - 综合案例:管理费用明细表

本篇来实现一个综合案例&#xff1a;管理费用明细表。报表在实际项目中&#xff0c;也有一定的参考意义&#xff0c;一方面展示类似的报表&#xff0c;比如管理费用、研发费用等费用的明细&#xff0c;使用业务比较习惯的展示格式&#xff1b;另一方面正好综合运用前面学习的动…

【Python办公】Excel通用匹配工具(双表互匹)

目录 专栏导读1、背景介绍2、库的安装3、核心代码4、完整代码总结专栏导读 🌸 欢迎来到Python办公自动化专栏—Python处理办公问题,解放您的双手 🏳️‍🌈 博客主页:请点击——> 一晌小贪欢的博客主页求关注 👍 该系列文章专栏:请点击——>Python办公自动化专…

2025-03-15 吴恩达机器学习2——线性回归模型

文章目录 1 概述1.1 案例1.2 分析 2 代价函数2.1 代价函数公式2.2 理解代价函数2.3 可视化代价函数 3 梯度下降3.1 实现步骤3.2 理解梯度下降3.3 学习率 4 最佳实践4.1 导入数据4.2 代码实现4.3 可视化 1 概述 ​ 线性回归模型是使用最广泛的学习算法&#xff0c;让我们从一个…

Webpack 前端性能优化全攻略

文章目录 1. 性能优化全景图1.1 优化维度概览1.2 优化效果指标 2. 构建速度优化2.1 缓存策略2.2 并行处理2.3 减少构建范围 3. 输出质量优化3.1 代码分割3.2 Tree Shaking3.3 压缩优化 4. 运行时性能优化4.1 懒加载4.2 预加载4.3 资源优化 5. 高级优化策略5.1 持久化缓存5.2 模…

实验篇| CentOS 7 下 Keepalived + Nginx 实现双机高可用

为什么要做双机高可用&#xff1f;‌ 想象一下&#xff1a;你的网站突然宕机&#xff0c;用户无法访问&#xff0c;订单流失、口碑暴跌…&#x1f4b8; ‌双机热备‌就是解决这个痛点的终极方案&#xff01;两台服务器互为备份&#xff0c;724小时无缝切换&#xff0c;保障业务…

C语言【内存函数】详解加模拟实现

目录&#xff1a; 1. memcpy使用和模拟实现 2. memmove使用和模拟实现 3. memset函数的使用 4. memcmp函数的使用 以上函数均包含在一个头文件<string.h>里面 一、memcpy的使用和模拟实现。 memcpy函数介绍&#xff1a; 函数原型&#xff1a; void * memcpy ( void…

Flutter——Android与Flutter混合开发详细教程

目录 1.创建FlutterModule项目&#xff0c;相当于Android项目里面的module库&#xff1b;2.或者编辑aar引用3.创建Android原生项目3.直接运行跑起来 1.创建FlutterModule项目&#xff0c;相当于Android项目里面的module库&#xff1b; 2.或者编辑aar引用 执行 flutter build a…

Windows根据文件名批量在文件夹里查找文件并复制出来,用WPF实现的详细步骤

项目前言 在日常工作和生活中&#xff0c;我们常常会遇到需要从大量文件中根据文件名批量查找特定文件并复制到指定位置的情况。手动一个个查找和复制文件不仅效率低下&#xff0c;还容易出错。使用 Windows Presentation Foundation (WPF) 可以创建一个用户友好的图形界面应用…

matlab 控制系统GUI设计-PID控制超前滞后控制

1、内容简介 matlab164-控制系统GUI设计-PID控制超前滞后控制 可以交流、咨询、答疑 2、内容说明 略 3、仿真分析 略 4、参考论文 略

【大模型基础_毛玉仁】2.4 基于 Encoder-Decoder 架构的大语言模型

更多内容&#xff1a;XiaoJ的知识星球 目录 2.4 基于 Encoder-Decoder 架构的大语言模型2.4.1 Encoder-Decoder 架构2.4.2 T5 语言模型1&#xff09;T5 模型结构2&#xff09;T5 预训练方式3&#xff09;T5 下游任务 2.4.3 BART 语言模型1&#xff09;BART 模型结构2&#xff0…

AI智能代码疫苗技术,赋能数字化应用内生安全自免疫

“DevSecOps市占率持续领先&#xff0c;IAST探针覆盖率十倍增长&#xff0c;代码疫苗技术已成功帮助上千家行业用户成功抵御‘Log4j2.x’等重大未知漏洞的利用攻击。”子芽在腾讯专访中透露。 这是2021年悬镜安全交出的一张成绩单。悬镜安全是DevSecOps敏捷安全先行者&#xf…

【初级篇】如何使用DeepSeek和Dify构建高效的企业级智能客服系统

在当今数字化时代,企业面临着日益增长的客户服务需求。使用Dify创建智能客服不仅能够提升客户体验,还能显著提高企业的运营效率。关于DIfy的安装部署,大家可以参考之前的文章: 【入门级篇】Dify安装+DeepSeek模型配置保姆级教程_mindie dify deepseek-CSDN博客 AI智能客服…

【机器学习-基础知识】统计和贝叶斯推断

1. 概率论基本概念回顾 1. 概率分布 定义: 概率分布(Probability Distribution)指的是随机变量所有可能取值及其对应概率的集合。它描述了一个随机变量可能取的所有值以及每个值被取到的概率。 对于离散型随机变量,使用概率质量函数来描述。对于连续型随机变量,使用概率…

正点原子[第三期]Arm(iMX6U)Linux移植学习笔记-4 uboot目录分析

前言&#xff1a; 本文是根据哔哩哔哩网站上“Arm(iMX6U)Linux系统移植和根文件系统构键篇”视频的学习笔记&#xff0c;在这里会记录下正点原子 I.MX6ULL 开发板的配套视频教程所作的实验和学习笔记内容。本文大量引用了正点原子教学视频和链接中的内容。 引用&#xff1a; …

视频AI方案:数据+算力+算法,人工智能的三大基石

背景分析 随着信息技术的迅猛发展&#xff0c;人工智能&#xff08;AI&#xff09;已经逐渐渗透到我们生活的各个领域&#xff0c;从智能家居到自动驾驶&#xff0c;从医疗诊断到金融风控&#xff0c;AI的应用正在改变着我们的生活方式。而数据、算法和算力&#xff0c;正是构…

MySQL -- 表的约束

概念引入&#xff1a;真正的约束表字段的是数据类型&#xff0c;但是数据类型的约束方式比较单一的&#xff0c;所以需要一些额外的一些约束&#xff0c;用于表示数据的合法性&#xff0c;在只有数据类型一种约束的情况下&#xff0c;我们比较难保证数据是百分百合法。通过添加…

嵌入式Zephyr RTOS面试题及参考答案

目录 Zephyr RTOS 的主要设计目标是什么?适用于哪些领域? Zephyr 支持哪些内核对象类型?举例说明其应用场景。 Zephyr 支持哪些线程同步机制?举例说明其适用场景。 Zephyr 内核支持哪些任务状态?状态转换的条件是什么? Zephyr 如何实现低延迟中断处理?(如直接中断服…

《TCP/IP网络编程》学习笔记 | Chapter 18:多线程服务器端的实现

《TCP/IP网络编程》学习笔记 | Chapter 18&#xff1a;多线程服务器端的实现 《TCP/IP网络编程》学习笔记 | Chapter 18&#xff1a;多线程服务器端的实现线程的概念引入线程的背景线程与进程的区别 线程创建与运行pthread_createpthread_join可在临界区内调用的函数工作&#…

C++相关基础概念之入门讲解(上)

1. 命名空间 C中的命名空间&#xff08;namespace&#xff09;是用来避免命名冲突问题的一种机制。通过将类、函数、变量等封装在命名空间中&#xff0c;可以避免不同部分的代码中出现相同名称的冲突。在C中&#xff0c;可以使用namespace关键字来定义命名空间。 然后我们在调…