<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[徐小小小hi的博客]]></title><description><![CDATA[徐小小小hi的博客]]></description><link>https://blog.youkuaiyun.com/u010177010</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; u010177010]]></copyright><item><title><![CDATA[C++const对象、const成员变量、const成员函数]]></title><link>https://blog.youkuaiyun.com/u010177010/article/details/122601728</link><guid>https://blog.youkuaiyun.com/u010177010/article/details/122601728</guid><author>u010177010</author><pubDate>Thu, 20 Jan 2022 15:12:24 +0800</pubDate><description><![CDATA[一、常对象

1、数据成员值在对象的整个生存期内不能改变。在定义时必须初始化，而且不能被更新（因为成员变量不可以修改）。

2、常对象，只能调用常成员函数，保证常对象的数据成员不被改变，不能调用非常成员函数，非常成员函数会修改成员变量。


class Test
{
public:
	Test(int i)
	{
		x = i;
	}
private:
	int x;
};
// 定义常对象
const Test a(3); // 定义时，初始化

二、常成员变量

1、常数据成员，一经初始化就不可改变。]]></description><category></category></item><item><title><![CDATA[C++封装、继承和多态总结]]></title><link>https://blog.youkuaiyun.com/u010177010/article/details/105049351</link><guid>https://blog.youkuaiyun.com/u010177010/article/details/105049351</guid><author>u010177010</author><pubDate>Mon, 23 Mar 2020 15:25:13 +0800</pubDate><description><![CDATA[通常用一个专门的抽象类作为封装的接口类来操作子类，抽象类不能实例化，只能指针操作子类的对象。

   通过赋值，也就是接口的指针指向子类实例化对象的内存块。

   编译器通过指针来访问成员变量，指针指向哪个对象就使用哪个对象的数据；编译器通过指针的类型来访问成员函数，指针属于哪个类的类型就使用哪个类的函数（多态除外，多态是通过查虚表来进行操作的）。

例子如：


class fat...]]></description><category></category></item><item><title><![CDATA[设计模式23--Interpreter模式（解释器模式）---行为型模式]]></title><link>https://blog.youkuaiyun.com/u010177010/article/details/99643078</link><guid>https://blog.youkuaiyun.com/u010177010/article/details/99643078</guid><author>u010177010</author><pubDate>Mon, 21 Oct 2019 16:14:36 +0800</pubDate><description><![CDATA[一些应用提供了内建（Build-In）的脚本或者宏语言来让用户可以定义他们能够在系统 中进行的操作。Interpreter 模式的目的就是使用一个解释器为用户提供一个一门定义语言的 语法表示的解释器，然后通过这个解释器来解释语言中的句子。 Interpreter 模式提供了这样的一个实现语法解释器的框架，笔者曾经也正在构建一个编 译系统 Visual CMCS，现在已经发布了 Vis...]]></description><category></category></item><item><title><![CDATA[设计模式22--Iterator模式（迭代器模式）---行为型模式]]></title><link>https://blog.youkuaiyun.com/u010177010/article/details/99642408</link><guid>https://blog.youkuaiyun.com/u010177010/article/details/99642408</guid><author>u010177010</author><pubDate>Thu, 15 Aug 2019 16:44:04 +0800</pubDate><description><![CDATA[Iterator 模式应该是最为熟悉的模式了，最简单的证明就是我在实现 Composite 模式、 Flyweight 模式、Observer 模式中就直接用到了 STL 提供的 Iterator 来遍历 Vector 或者 List 数据结构。

   Iterator 模式也正是用来解决对一个聚合对象的遍历问题，将对聚合的遍历封装到一个 类中进行，这样就避免了暴露这个聚合...]]></description><category></category></item><item><title><![CDATA[设计模式21--Chain of Responsibility模式（职责链模式）---行为型模式]]></title><link>https://blog.youkuaiyun.com/u010177010/article/details/99642004</link><guid>https://blog.youkuaiyun.com/u010177010/article/details/99642004</guid><author>u010177010</author><pubDate>Thu, 15 Aug 2019 16:35:54 +0800</pubDate><description><![CDATA[熟悉 VC/MFC 的都知道，VC 是“基于消息，事件驱动”，消息在 VC 开发中起着举足 轻重的作用。在 MFC 中，消息是通过一个向上递交的方式进行处理，例如一个 WM_COMMAND 消息的处理流程可能为：

1） MDI 主窗口（CMDIFrameWnd）收到命令消息 WM_COMMAND，其 ID 位 ID_ ×××； 

2） MDI 主窗口将消息传给当前活动的 MDI ...]]></description><category></category></item><item><title><![CDATA[设计模式20--Visitor模式（访问者模式）---行为型模式]]></title><link>https://blog.youkuaiyun.com/u010177010/article/details/99641504</link><guid>https://blog.youkuaiyun.com/u010177010/article/details/99641504</guid><author>u010177010</author><pubDate>Thu, 15 Aug 2019 16:28:40 +0800</pubDate><description><![CDATA[在面向对象系统的开发和设计过程，经常会遇到一种情况就是需求变更（Requirement Changing），经常我们做好的一个设计、实现了一个系统原型，咱们的客户又会有了新的需 求。我们又因此不得不去修改已有的设计，最常见就是解决方案就是给已经设计、实现好的 类添加新的方法去实现客户新的需求，这样就陷入了设计变更的梦魇：不停地打补丁，其带 来的后果就是设计根本就不可能封闭、编译永远...]]></description><category></category></item><item><title><![CDATA[设计模式19--Command模式（命令模式）---行为型模式]]></title><link>https://blog.youkuaiyun.com/u010177010/article/details/99638755</link><guid>https://blog.youkuaiyun.com/u010177010/article/details/99638755</guid><author>u010177010</author><pubDate>Thu, 15 Aug 2019 16:19:29 +0800</pubDate><description><![CDATA[Command 模式通过将请求封装到一个对象（Command）中，并将请求的接受者存放到 具体的 ConcreteCommand 类中（Receiver）中，从而实现调用操作的对象和操作的具体实现 者之间的解耦。







     Command 模式结构图中，将请求的接收者（处理者）放到 Command 的具体子类 ConcreteCommand 中，当...]]></description><category></category></item><item><title><![CDATA[设计模式18--Mediator模式（中介者模式）---行为型模式]]></title><link>https://blog.youkuaiyun.com/u010177010/article/details/99638013</link><guid>https://blog.youkuaiyun.com/u010177010/article/details/99638013</guid><author>u010177010</author><pubDate>Thu, 15 Aug 2019 15:35:10 +0800</pubDate><description><![CDATA[在面向对象系统的设计和开发过程中，对象之间的交互和通信是最为常见的情况，因为 对象间的交互本身就是一种通信。在系统比较小的时候，可能对象间的通信不是很多、对象 也比较少，我们可以直接硬编码到各个对象的方法中。但是当系统规模变大，对象的量变引 起系统复杂度的急剧增加，对象间的通信也变得越来越复杂，这时候我们就要提供一个专门 处理对象间交互和通信的类，这个中介者就是 Mediator 模...]]></description><category></category></item><item><title><![CDATA[设计模式17--Memento模式（备忘录模式）---行为型模式]]></title><link>https://blog.youkuaiyun.com/u010177010/article/details/99637637</link><guid>https://blog.youkuaiyun.com/u010177010/article/details/99637637</guid><author>u010177010</author><pubDate>Thu, 15 Aug 2019 15:25:49 +0800</pubDate><description><![CDATA[没有人想犯错误，但是没有人能够不犯错误。犯了错误一般只能改过，却很难改正（恢 复）。世界上没有后悔药，但是我们在进行软件系统的设计时候是要给用户后悔的权利（实 际上可能也是用户要求的权利：）），我们对一些关键性的操作肯定需要提供诸如撤销（Undo）的操作。那这个后悔药就是 Memento 模式提供的。

   Memento 模式的关键就是要在不破坏封装行的前提下，捕获并保存...]]></description><category></category></item><item><title><![CDATA[设计模式16--Observer模式（观察者模式）---行为型模式]]></title><link>https://blog.youkuaiyun.com/u010177010/article/details/99636833</link><guid>https://blog.youkuaiyun.com/u010177010/article/details/99636833</guid><author>u010177010</author><pubDate>Thu, 15 Aug 2019 15:17:08 +0800</pubDate><description><![CDATA[Observer 模式应该可以说是应用最多、影响最广的模式之一，因为 Observer 的一个实 例 Model/View/Control（MVC）结构在系统开发架构设计中有着很重要的地位和意义，MVC 实现了业务逻辑和表示层的解耦。个人也认为 Observer 模式是软件开发过程中必须要掌握 和使用的模式之一。在 MFC 中，Doc/View（文档视图结构）提供了实现 MVC ...]]></description><category></category></item><item><title><![CDATA[设计模式15--State模式（状态模式）---行为型模式]]></title><link>https://blog.youkuaiyun.com/u010177010/article/details/99636299</link><guid>https://blog.youkuaiyun.com/u010177010/article/details/99636299</guid><author>u010177010</author><pubDate>Thu, 15 Aug 2019 15:03:06 +0800</pubDate><description><![CDATA[每个人、事物在不同的状态下会有不同表现（动作），而一个状态又会在不同的表现下 转移到下一个不同的状态（State）。最简单的一个生活中的例子就是：地铁入口处，如果你 放入正确的地铁票，门就会打开让你通过。在出口处也是验票，如果正确你就可以 ok，否 则就不让你通过（如果你动作野蛮，或许会有报警（Alarm），：））。

    有限状态自动机（FSM）也是一个典型的状态不同，对...]]></description><category></category></item><item><title><![CDATA[设计模式14--Strategy模式（策略模式）---行为型模式]]></title><link>https://blog.youkuaiyun.com/u010177010/article/details/99635576</link><guid>https://blog.youkuaiyun.com/u010177010/article/details/99635576</guid><author>u010177010</author><pubDate>Thu, 15 Aug 2019 14:53:30 +0800</pubDate><description><![CDATA[Strategy 模式和 Template 模式要解决的问题是相同（类似）的，都是为了给业务逻辑（算 法）具体实现和抽象接口之间的解耦。Strategy 模式将逻辑（算法）封装到一个类（Context） 里面，通过组合的方式将具体算法的实现在组合对象中实现，再通过委托的方式将抽象接口 的实现委托给组合对象实现。State 模式也有类似的功能，他们之间的区别将在讨论中给出。



...]]></description><category></category></item><item><title><![CDATA[设计模式13--Template模式（模板方法模式）---行为型模式]]></title><link>https://blog.youkuaiyun.com/u010177010/article/details/99634984</link><guid>https://blog.youkuaiyun.com/u010177010/article/details/99634984</guid><author>u010177010</author><pubDate>Thu, 15 Aug 2019 14:41:05 +0800</pubDate><description><![CDATA[在面向对象系统的分析与设计过程中经常会遇到这样一种情况：对于某一个业务逻辑 （算法实现）在不同的对象中有不同的细节实现，但是逻辑（算法）的框架（或通用的应用 算法）是相同的。Template 提供了这种情况的一个实现框架。 Template 模式是采用继承的方式实现这一点：将逻辑（算法）框架放在抽象基类中，并 定义好细节的接口，子类中实现细节。【注释 1】 

    【注释 ...]]></description><category></category></item><item><title><![CDATA[设计模式12--Proxy模式（代理模式）---结构型模式]]></title><link>https://blog.youkuaiyun.com/u010177010/article/details/97143520</link><guid>https://blog.youkuaiyun.com/u010177010/article/details/97143520</guid><author>u010177010</author><pubDate>Wed, 24 Jul 2019 17:34:29 +0800</pubDate><description><![CDATA[至少在以下集中情况下可以用 Proxy 模式解决问题：
  1）创建开销大的对象时候，比如显示一幅大的图片，我们将这个创建的过程交给代理去完成，GoF 称之为虚代理（Virtual Proxy）；
  2）为网络上的对象创建一个局部的本地代理，比如要操作一个网络上的一个对象（网络性能不好的时候，问题尤其突出），我们将这个操纵的过程交给一个代理去完成，GoF 称之为远程代理（Remote...]]></description><category></category></item><item><title><![CDATA[设计模式11--Facade模式（外观模式）---结构型模式]]></title><link>https://blog.youkuaiyun.com/u010177010/article/details/97141670</link><guid>https://blog.youkuaiyun.com/u010177010/article/details/97141670</guid><author>u010177010</author><pubDate>Wed, 24 Jul 2019 17:24:36 +0800</pubDate><description><![CDATA[举一个生活中的小例子，大凡开过学或者毕过业的都会体会到这样一种郁闷：你要去 n个地方办理 n 个手续（现在大学合并后就更加麻烦，因为可能那 n 个地方都隔的比较远）。但是实际上我们需要的就是一个最后一道手续的证明而已，对于前面的手续是怎么办的、到什么地方去办理我们都不感兴趣

    实际上在软件系统开发中也经常回会遇到这样的情况，可能你实现了一些接口（模块），而这些接口（模...]]></description><category></category></item><item><title><![CDATA[设计模式10--Flyweight模式（享元模式）---结构型模式]]></title><link>https://blog.youkuaiyun.com/u010177010/article/details/97139863</link><guid>https://blog.youkuaiyun.com/u010177010/article/details/97139863</guid><author>u010177010</author><pubDate>Wed, 24 Jul 2019 17:08:59 +0800</pubDate><description><![CDATA[在面向对象系统的设计何实现中，创建对象是最为常见的操作。这里面就有一个问题：如果一个应用程序使用了太多的对象，就会造成很大的存储开销。特别是对于大量轻量级（细粒度）的对象，比如在文档编辑器的设计过程中，我们如果为没有字母创建一个对象的话，系统可能会因为大量的对象而造成存储开销的浪费。例如一个字母“a”在文档中出现了100000 次，而实际上我们可以让这一万个字母“a”共享一个对象，当...]]></description><category></category></item><item><title><![CDATA[设计模式9--Composite模式（组合模式）---结构型模式]]></title><link>https://blog.youkuaiyun.com/u010177010/article/details/97139304</link><guid>https://blog.youkuaiyun.com/u010177010/article/details/97139304</guid><author>u010177010</author><pubDate>Wed, 24 Jul 2019 16:51:00 +0800</pubDate><description><![CDATA[在开发中，我们经常可能要递归构建树状的组合结构，Composite 模式则提供了很好的解决方案。




//Component.h
#pragma once
#include &lt;memory&gt;
class Component
{
public:
	Component();
	virtual ~Component();
public:
	virtual void Operation()...]]></description><category></category></item><item><title><![CDATA[设计模式8--Decorator模式（装饰模式）---结构型模式]]></title><link>https://blog.youkuaiyun.com/u010177010/article/details/97135404</link><guid>https://blog.youkuaiyun.com/u010177010/article/details/97135404</guid><author>u010177010</author><pubDate>Wed, 24 Jul 2019 16:03:46 +0800</pubDate><description><![CDATA[在 OO 设计和开发过程，可能会经常遇到以下的情况：我们需要为一个已经定义好的类添加新的职责（操作），通常的情况我们会给定义一个新类继承自定义好的类，这样会带来一个问题（将在本模式的讨论中给出）。通过继承的方式解决这样的情况还带来了系统的复杂性，因为继承的深度会变得很深。

   而 Decorator 提供了一种给类增加职责的方法，不是通过继承实现的，而是通过组合。有关这...]]></description><category></category></item><item><title><![CDATA[设计模式7--Adapter模式（适配器模式）---结构型模式]]></title><link>https://blog.youkuaiyun.com/u010177010/article/details/97131873</link><guid>https://blog.youkuaiyun.com/u010177010/article/details/97131873</guid><author>u010177010</author><pubDate>Wed, 24 Jul 2019 15:05:03 +0800</pubDate><description><![CDATA[Adapter 模式解决的问题在生活中经常会遇到：比如我们有一个 Team 为外界提供 S 类服务，但是我们 Team 里面没有能够完成此项人物的 member，然后我们得知有 A 可以完成这项服务（他把这项人物重新取了个名字叫 S’，并且他不对外公布他的具体实现）。为了保证我们对外的服务类别的一致性（提供 S 服务），我们有以下两种方式解决这个问题：

    1）把 B...]]></description><category></category></item><item><title><![CDATA[设计模式6--Bridge模式（桥接模式）---结构型模式]]></title><link>https://blog.youkuaiyun.com/u010177010/article/details/96999213</link><guid>https://blog.youkuaiyun.com/u010177010/article/details/96999213</guid><author>u010177010</author><pubDate>Tue, 23 Jul 2019 16:00:15 +0800</pubDate><description><![CDATA[总结面向对象实际上就两句话：一是松耦合（Coupling），二是高内聚（Cohesion）。面向对象系统追求的目标就是尽可能地提高系统模块内部的内聚（Cohesion）、尽可能降低模块间的耦合（Coupling）。然而这也是面向对象设计过程中最为难把握的部分，大家肯定在OO 系统的开发过程中遇到这样的问题：

1）客户给了你一个需求，于是使用一个类来实现（A）；
2）客户需求变化，...]]></description><category></category></item></channel></rss>