C++设计模式大观园：20招让代码从“乱炖”变“佛跳墙”

写代码像闯江湖？总遇到些似曾相识的难题：对象怎么造省心？功能怎么加优雅？模块怎么搭结实？设计模式就是前辈们踩坑总结的“武功套路”，专治各种代码花式作死。

今天猫哥继续带你逛遍设计模式大观园，分造人派（创建型）、搭积木派（结构型）、搞关系派（行为型）三大片区，20个门派各显神通！走起！

---

一、造人派（创建型）：专治“对象难产”

1. 单例模式 (Singleton) - “孤寡老人”

核心奥义：整个江湖就允许一个实例！想new？没门！
适用场景：日志总管、配置大管家、数据库连接池（多了会撑死）
猫哥吐槽：用不好就是“全局垃圾场”，测试时想换对象？做梦！

classLogManager{public:staticLogManager&getInstance(){staticLogManager instance;// C++11魔法：线程安全又省心returninstance;}voidlog(conststd::string&msg){std::cout<<"[LOG] "<<msg<<std::endl;}private:LogManager()=default;// 关门！不准外面造！// 防克隆防篡位三连LogManager(constLogManager&)=delete;LogManager&operator=(constLogManager&)=delete;};// 用法：整个程序就这一个日志老大LogManager::getInstance().log("猫哥来也！");

2. 工厂方法 (Factory Method) - “专业分店”

核心奥义：想要啥产品？找对应分店！子类决定造啥。
适用场景：不同武器店造不同武器（刀店造刀，枪店造枪）
猫哥吐槽：开分店上瘾？小心“类爆炸”！

// 武器基类classWeapon{public:virtualvoidattack()=0;};// 具体产品：屠龙刀classDragonSword:publicWeapon{public:voidattack()override{std::cout<<"刀光一闪！"<<std::endl;}};// 武器工厂（总店规矩）classWeaponFactory{public:virtualstd::unique_ptr<Weapon>create()=0;};// 屠龙刀专卖店（分店）classSwordFactory:publicWeaponFactory{public:std::unique_ptr<Weapon>create()override{returnstd::make_unique<DragonSword>();}};// 用法：找分店买刀autofactory=std::make_unique<SwordFactory>();automySword=factory->create();mySword->attack();// 刀光一闪！

3. 抽象工厂 (Abstract Factory) - “集团大厂”

核心奥义：搞套装！Windows风按钮+窗口，Mac风按钮+窗口，整包发货！
适用场景：跨平台UI套件、游戏皮肤包
猫哥吐槽：加个新配件？所有分厂都得加班！

// 抽象UI套件classButton{public:virtualvoiddraw()=0;};classWindow{public:virtualvoidshow()=0;};// Windows全家桶classWinButton:publicButton{voiddraw()override{std::cout<<"画了个Windows按钮"<<std::endl;}};classWinWindow:publicWindow{voidshow()override{std::cout<<"弹了个Windows窗口"<<std::endl;}};// 抽象大厂classUIFactory{public:virtualstd::unique_ptr<Button>createButton()=0;virtualstd::unique_ptr<Window>createWindow()=0;};// Windows大厂classWinFactory:publicUIFactory{std::unique_ptr<Button>createButton()override{returnstd::make_unique<WinButton>();}std::unique_ptr<Window>createWindow()override{returnstd::make_unique<WinWindow>();}};// 用法：找Windows大厂下单autowinFactory=std::make_unique<WinFactory>();autobtn=winFactory->createButton();autowindow=winFactory->createWindow();btn->draw();// 画了个Windows按钮window->show();// 弹了个Windows窗口

4. 建造者 (Builder) - “乐高大师”

核心奥义：分步造复杂对象，避免构造函数参数炸了！
适用场景：配豪华电脑（选CPU、加内存、装显卡）
猫哥吐槽：配台电脑要写10个类？杀鸡用牛刀！

classComputer{public:voidsetCPU(conststd::string&cpu){cpu_=cpu;}voidsetRAM(conststd::string&ram){ram_=ram;}voidshow()const{std::cout<<"电脑配置: CPU="<<cpu_<<" RAM="<<ram_<<std::endl;}private:std::string cpu_;std::string ram_;};// 装机师傅（建造者）classComputerBuilder{public:virtualvoidbuildCPU()=0;virtualvoidbuildRAM()=0;virtualComputergetResult()=0;};// 游戏电脑装机师傅classGamingBuilder:publicComputerBuilder{public:voidbuildCPU()override{computer_.setCPU("i9-13900K");}voidbuildRAM()override{computer_.setRAM("32GB DDR5");}ComputergetResult()override{returncomputer_;}private:Computer computer_;};// 用法：指挥装机GamingBuilder builder;builder.buildCPU();builder.buildRAM();Computer myPC=builder.getResult();myPC.show();// 电脑配置: CPU=i9-13900K RAM=32GB DDR5

5. 原型模式 (Prototype) - “克隆大法”

核心奥义：复制比new快！尤其当对象构造像“等外卖”一样慢时。
适用场景：游戏里复制100个小兵、复杂配置对象复制
猫哥吐槽：深拷贝浅拷贝搞不清？等着内存泄漏吧！

classMonster{public:virtualstd::unique_ptr<Monster>clone()const=0;virtualvoidroar()const=0;};classGoblin:publicMonster{public:std::unique_ptr<Monster>clone()constoverride{returnstd::make_unique<Goblin>(*this);// 深拷贝}voidroar()constoverride{std::cout<<"嘎呜！"<<std::endl;}};// 用法：克隆10只哥布林Goblin prototype;std::vector<std::unique_ptr<Monster>>army;for(inti=0;i<10;++i){army.push_back(prototype.clone());}army[0]->roar();// 嘎呜！

---

二、搭积木派（结构型）：专治“对象不合”

6. 适配器 (Adapter) - “万能转接头”

核心奥义：让老插头插新插座！旧类换身马甲继续用。
适用场景：整合老代码、第三方库接口改造
猫哥吐槽：适配器叠三层？代码变千层饼！

// 新插座标准 (Target)classUSBSocket{public:virtualvoidcharge()=0;};// 老式TypeC插头 (Adaptee)classTypeCPlug{public:voidtypeCCharge(){std::cout<<"TypeC充电中..."<<std::endl;}};// 转接头 (Adapter)classTypeCToUSBAdapter:publicUSBSocket{public:TypeCToUSBAdapter(TypeCPlug*plug):plug_(plug){}voidcharge()override{plug_->typeCCharge();}// 偷偷转换private:TypeCPlug*plug_;};// 用法：老插头插新插座TypeCPlug oldPlug;TypeCToUSBAdapteradapter(&oldPlug);adapter.charge();// TypeC充电中...

7. 装饰器 (Decorator) - “俄罗斯套娃”

核心奥义：给对象动态穿马甲！加日志？加权限？套就完事！
适用场景：功能增强（咖啡加奶加糖）、中间件
猫哥吐槽：套娃十层？调试时想找本尊得拆到哭！

classCoffee{public:virtualvoidbrew()const=0;};classBlackCoffee:publicCoffee{voidbrew()constoverride{std::cout<<"冲一杯黑咖啡"<<std::endl;}};// 装饰器基类（套娃核心）classCoffeeDecorator:publicCoffee{public:explicitCoffeeDecorator(std::unique_ptr<Coffee>c):coffee_(std::move(c)){}voidbrew()constoverride{coffee_->brew();}protected:std::unique_ptr<Coffee>coffee_;};// 加奶装饰器classMilkDecorator:publicCoffeeDecorator{public:usingCoffeeDecorator::CoffeeDecorator;voidbrew()constoverride{coffee_->brew();std::cout<<"加一勺鲜奶"<<std::endl;}};// 用法：黑咖啡 -> 加奶 -> 加糖automyCoffee=std::make_unique<MilkDecorator>(std::make_unique<BlackCoffee>());myCoffee->brew();// 输出：// 冲一杯黑咖啡// 加一勺鲜奶

8. 代理 (Proxy) - “明星经纪人”

核心奥义：想见明星？先过经纪人这关！控制访问+延迟加载。
适用场景：远程调用、权限控制、图片懒加载
猫哥吐槽：经纪人太忙？访问速度慢成蜗牛！

classStar{public:virtualvoidperform()=0;};classRealStar:publicStar{voidperform()override{std::cout<<"周董开唱：哎哟不错哦！"<<std::endl;}};// 经纪人（代理）classStarAgent:publicStar{public:voidperform()override{if(!realStar_){// 还没请？赶紧的！std::cout<<"经纪人：联系周董中...（收出场费）"<<std::endl;realStar_=std::make_unique<RealStar>();}realStar_->perform();}private:std::unique_ptr<RealStar>realStar_;};// 用法：找经纪人StarAgent agent;agent.perform();// 第一次：经纪人联系明星agent.perform();// 第二次：直接表演

9. 桥接 (Bridge) - “跨平台大佬”

核心奥义：抽象和实现分手！让它们各自找新欢。
适用场景：跨平台绘图库（Windows/Mac画圆画方）
猫哥吐槽：抽象和实现总吵架？桥接劝分不劝和！

// 实现部分：渲染引擎classRenderer{public:virtualvoidrenderCircle(floatr)=0;};classOpenGLRenderer:publicRenderer{voidrenderCircle(floatr)override{std::cout<<"OpenGL画圆：半径="<<r<<std::endl;}};// 抽象部分：形状classShape{public:Shape(Renderer*r):renderer_(r){}virtualvoiddraw()=0;protected:Renderer*renderer_;};classCircle:publicShape{public:Circle(Renderer*r,floatrad):Shape(r),radius_(rad){}voiddraw()override{renderer_->renderCircle(radius_);}private:floatradius_;};// 用法：OpenGL画个圆OpenGLRenderer gl;Circlecircle(&gl,5.0f);circle.draw();// OpenGL画圆：半径=5

10. 组合 (Composite) - “套娃高手”

核心奥义：文件夹套文件夹套文件，统一当“节点”处理！
适用场景：UI组件树、文件系统、组织架构
猫哥吐槽：叶子节点非要加子节点？等着程序崩吧！

classFileComponent{public:virtualvoidlist(intdepth=0)const=0;};// 文件（叶子节点）classFile:publicFileComponent{public:File(std::string name):name_(std::move(name)){}voidlist(intdepth)constoverride{std::cout<<std::string(depth,'-')<<"文件: "<<name_<<std::endl;}private:std::string name_;};// 文件夹（复合节点）classFolder:publicFileComponent{public:voidadd(std::unique_ptr<FileComponent>comp){children_.push_back(std::move(comp));}voidlist(intdepth)constoverride{std::cout<<std::string(depth,'-')<<"文件夹"<<std::endl;for(constauto&child:children_){child->list(depth+2);}}private:std::vector<std::unique_ptr<FileComponent>>children_;};// 用法：构建文件夹结构autoroot=std::make_unique<Folder>();root->add(std::make_unique<File>("猫哥的简历.pdf"));autosubFolder=std::make_unique<Folder>();subFolder->add(std::make_unique<File>("黑历史.txt"));root->add(std::move(subFolder));root->list();// 输出：// 文件夹// --文件: 猫哥的简历.pdf// --文件夹// ----文件: 黑历史.txt

11. 享元 (Flyweight) - “内存抠门鬼”

核心奥义：共享相同部分，省内存！尤其当你有10万颗同款树时。
适用场景：文字编辑器字符池、游戏粒子系统
猫哥吐槽：共享状态线程不安全？多线程下等着哭吧！

// 享元对象：树的类型（内在状态）classTreeType{public:TreeType(std::string name,std::string color):name_(std::move(name)),color_(std::move(color)){}voiddraw(intx,inty)const{std::cout<<"在("<<x<<","<<y<<")画一棵"<<color_<<"的"<<name_<<std::endl;}private:std::string name_;std::string color_;};// 享元工厂（管理池子）classTreeFactory{public:constTreeType*getTreeType(conststd::string&name,conststd::string&color){autokey=name+"_"+color;if(autoit=pool_.find(key);it!=pool_.end()){return&(it->second);}auto[newIt,_]=pool_.emplace(key,TreeType(name,color));return&(newIt->second);}private:std::unordered_map<std::string,TreeType>pool_;};// 用法：画1000棵松树（只存1个类型）TreeFactory factory;constTreeType*pineType=factory.getTreeType("松树","绿色");for(inti=0;i<1000;++i){pineType->draw(rand()%100,rand()%100);// 复用同一个TreeType对象！}

12. 外观 (Facade) - “万能接线员”

核心奥义：复杂系统太闹心？一个接口全搞定！
适用场景：系统启动流程、复杂库封装
猫哥吐槽：滥用外观？小心变成“上帝类”背锅侠！

// 复杂子系统：CPUclassCPU{public:voidstart(){std::cout<<"CPU启动！"<<std::endl;}};// 复杂子系统：内存classMemory{public:voidinit(){std::cout<<"内存初始化！"<<std::endl;}};// 复杂子系统：硬盘classHardDrive{public:voidread(){std::cout<<"硬盘读取引导区！"<<std::endl;}};// 外观：电脑启动按钮classComputerFacade{public:voidpowerOn(){cpu_.start();memory_.init();hd_.read();std::cout<<"欢迎使用！"<<std::endl;}private:CPU cpu_;Memory memory_;HardDrive hd_;};// 用法：一键开机！ComputerFacade myPC;myPC.powerOn();// 输出：// CPU启动！// 内存初始化！// 硬盘读取引导区！// 欢迎使用！

---

三、搞关系派（行为型）：专治“对象社恐”

13. 策略 (Strategy) - “算法七十二变”

核心奥义：算法随便换，告别if-else地狱！
适用场景：支付方式切换、排序算法动态选择
猫哥吐槽：策略太多？选择困难症患者慎入！

classPaymentStrategy{public:virtualvoidpay(intamount)=0;};classAlipay:publicPaymentStrategy{voidpay(intamount)override{std::cout<<"支付宝支付："<<amount<<"元"<<std::endl;}};classWechatPay:publicPaymentStrategy{voidpay(intamount)override{std::cout<<"微信支付："<<amount<<"元"<<std::endl;}};// 支付上下文（收银台）classPaymentContext{public:voidsetStrategy(std::unique_ptr<PaymentStrategy>s){strategy_=std::move(s);}voidexecutePay(intamount){strategy_->pay(amount);}private:std::unique_ptr<PaymentStrategy>strategy_;};// 用法：随时切换支付方式PaymentContext ctx;ctx.setStrategy(std::make_unique<Alipay>());ctx.executePay(100);// 支付宝支付100元ctx.setStrategy(std::make_unique<WechatPay>());ctx.executePay(50);// 微信支付50元

14. 观察者 (Observer) - “八卦传播链”

核心奥义：一个对象咳嗽，所有依赖它的对象都感冒！
适用场景：事件通知、数据监控、MVC架构
猫哥吐槽：观察者太多？通知一圈能泡三杯咖啡！

// 主题（八卦中心）classSubject{public:virtualvoidattach(Observer*o)=0;virtualvoidnotify(conststd::string&news)=0;};// 观察者（吃瓜群众）classObserver{public:virtualvoidupdate(conststd::string&news)=0;};// 具体主题：微博大VclassWeiboStar:publicSubject{public:voidattach(Observer*o)override{fans_.push_back(o);}voidnotify(conststd::string&news)override{for(autofan:fans_)fan->update(news);}private:std::vector<Observer*>fans_;};// 具体观察者：猫哥classCatBro:publicObserver{voidupdate(conststd::string&news)override{std::cout<<"猫哥收到八卦："<<news<<" (咔嚓截图)"<<std::endl;}};// 用法：大V发动态，粉丝全收到WeiboStar star;CatBro cat;star.attach(&cat);star.notify("某顶流明星塌房了！");

15. 状态 (State) - “变脸大师”

核心奥义：状态一变，行为全变！告别if-else状态机。
适用场景：订单流程、游戏角色状态、工单审批流
猫哥吐槽：状态太多？类数量爆炸警告！

classVendingMachineState{public:virtualvoidinsertCoin()=0;virtualvoiddispense()=0;};// 待投币状态classIdleState:publicVendingMachineState{public:voidinsertCoin()override{std::cout<<"投币成功！请选择商品"<<std::endl;}voiddispense()override{std::cout<<"请先投币！"<<std::endl;}};// 已投币状态classHasCoinState:publicVendingMachineState{public:voidinsertCoin()override{std::cout<<"您已投币，别再投了！"<<std::endl;}voiddispense()override{std::cout<<"出货中...请取走快乐水"<<std::endl;}};// 自动贩卖机classVendingMachine{public:VendingMachine():state_(std::make_unique<IdleState>()){}voidinsertCoin(){state_->insertCoin();}voiddispense(){state_->dispense();}voidchangeState(std::unique_ptr<VendingMachineState>newState){state_=std::move(newState);}private:std::unique_ptr<VendingMachineState>state_;};// 用法：根据状态切换行为VendingMachine vm;vm.insertCoin();// 投币成功！请选择商品vm.dispense();// 出货中...请取走快乐水

16. 命令 (Command) - “任务派遣单”

核心奥义：把请求打包成对象，支持撤销/重做/排队！
适用场景：操作历史记录、遥控器按钮、任务队列
猫哥吐槽：简单操作搞命令？杀鸡用火箭筒！

// 命令接口classCommand{public:virtualvoidexecute()=0;virtualvoidundo()=0;};// 具体命令：开灯classLightOnCommand:publicCommand{public:explicitLightOnCommand(Light*l):light_(l){}voidexecute()override{light_->on();}voidundo()override{light_->off();}private:Light*light_;};// 灯（接收者）classLight{public:voidon(){std::cout<<"灯亮了！"<<std::endl;}voidoff(){std::cout<<"灯灭了！"<<std::endl;}};// 遥控器按钮（调用者）classRemoteButton{public:voidsetCommand(std::unique_ptr<Command>cmd){command_=std::move(cmd);}voidpress(){command_->execute();}voidundoPress(){command_->undo();}private:std::unique_ptr<Command>command_;};// 用法：开灯 -> 撤销Light myLight;autobutton=std::make_unique<RemoteButton>();button->setCommand(std::make_unique<LightOnCommand>(&myLight));button->press();// 灯亮了！button->undoPress();// 灯灭了！

17. 模板方法 (Template Method) - “标准化流水线”

核心奥义：固定流程框架，子类填空细节！防止跑偏。
适用场景：游戏主循环、业务流程框架
猫哥吐槽：步骤太多？子类实现要疯！

// 游戏骨架（模板）classGame{public:// 固定流程！子类不能改voidplay(){initialize();startPlay();endPlay();}virtual~Game()=default;protected:// 留给子类填空virtualvoidinitialize()=0;virtualvoidstartPlay()=0;virtualvoidendPlay()=0;};// 具体游戏：象棋classChess:publicGame{protected:voidinitialize()override{std::cout<<"摆棋盘棋子..."<<std::endl;}voidstartPlay()override{std::cout<<"当头炮！"<<std::endl;}voidendPlay()override{std::cout<<"将军！赢了顿烧烤"<<std::endl;}};// 用法：按标准流程玩Chess game;game.play();// 输出：// 摆棋盘棋子...// 当头炮！// 将军！赢了顿烧烤

18. 迭代器 (Iterator) - “容器导游”

核心奥义：不管容器是数组还是链表，遍历用同一套姿势！
适用场景：自定义容器遍历、封装集合内部结构
猫哥吐槽：C++有STL迭代器还手写？除非吃饱了撑的！

template<typenameT>classMyList{public:classIterator{public:Iterator(T*ptr):ptr_(ptr){}T&operator*()const{return*ptr_;}Iterator&operator++(){++ptr_;return*this;}booloperator!=(constIterator&other)const{returnptr_!=other.ptr_;}private:T*ptr_;};voidadd(constT&item){data_.push_back(item);}Iteratorbegin(){returnIterator(&data_[0]);}Iteratorend(){returnIterator(&data_[0]+data_.size());}private:std::vector<T>data_;};// 用法：像STL一样遍历MyList<std::string>playlist;playlist.add("七里香");playlist.add("双截棍");for(auto&song:playlist){std::cout<<"播放: "<<song<<std::endl;}

19. 备忘录 (Memento) - “时光机”

核心奥义：随时存档读档！对象状态想改就改，想回滚就回滚。
适用场景：撤销操作、游戏存档
猫哥吐槽：存档太频繁？内存分分钟爆炸！

// 游戏角色（需存档的对象）classGameCharacter{public:structMemento{inthealth;intlevel;};// 存档数据Mementosave()const{return{health_,level_};}voidrestore(constMemento&m){health_=m.health;level_=m.level;}voidtakeDamage(intdmg){health_-=dmg;}voidshow()const{std::cout<<"血量:"<<health_<<" 等级:"<<level_<<std::endl;}private:inthealth_=100;intlevel_=1;};// 存档管理器classSaveManager{public:voidsave(conststd::string&key,constGameCharacter::Memento&m){saves_[key]=m;}GameCharacter::Mementoload(conststd::string&key){returnsaves_.at(key);}private:std::unordered_map<std::string,GameCharacter::Memento>saves_;};// 用法：存档 -> 受伤 -> 读档GameCharacter hero;SaveManager saves;saves.save("slot1",hero.save());// 存档hero.takeDamage(50);// 受伤hero.show();// 血量:50 等级:1hero.restore(saves.load("slot1"));// 读档hero.show();// 血量:100 等级:1 (满血复活!)

20. 中介者 (Mediator) - “婚介所红娘”

核心奥义：对象别直接聊天！找中介传话，降低耦合。
适用场景：聊天室、飞机调度系统
猫哥吐槽：中介累成狗？可能成性能瓶颈！

// 中介接口classChatMediator{public:virtualvoidsendMsg(conststd::string&msg,classUser*sender)=0;virtualvoidaddUser(User*user)=0;};// 具体中介：聊天室classChatRoom:publicChatMediator{public:voidaddUser(User*user)override{users_.push_back(user);}voidsendMsg(conststd::string&msg,User*sender)override{for(autouser:users_){if(user!=sender)// 不发给发送者user->receive(msg);}}private:std::vector<User*>users_;};// 用户classUser{public:User(conststd::string&name,ChatMediator*med):name_(name),mediator_(med){}voidsend(conststd::string&msg){std::cout<<name_<<"发送: "<<msg<<std::endl;mediator_->sendMsg(msg,this);}voidreceive(conststd::string&msg){std::cout<<name_<<"收到: "<<msg<<std::endl;}private:std::string name_;ChatMediator*mediator_;};// 用法：聊天不用加好友，找中介！ChatRoom room;Useruser1("猫哥",&room);Useruser2("狗弟",&room);room.addUser(&user1);room.addUser(&user2);user1.send("今晚吃鸡？");// 输出：// 猫哥发送: 今晚吃鸡？// 狗弟收到: 今晚吃鸡？

---

猫哥结语：设计模式是调料包，不是主食！

一口气逛完20大设计模式，是不是感觉代码世界豁然开朗？最后叮嘱几句：

1. 别走火入魔：不是所有代码都要套模式！KISS原则（Keep It Simple, Stupid）永不过时。

2. 看懂再用：半懂不懂硬套？恭喜喜提“屎山代码”一座！

3. C++特色：善用RAII管理资源，智能指针防内存泄漏，模板元编程玩出花。

记住：好代码不是模式堆出来的，是让读的人拍大腿喊“妙啊”！下次写代码卡壳，翻出猫哥这篇，保证药到病除！