undo

撤销重做（UndoRedo）

在撤销和重做的实现过程中，总会出现各种各样的特殊情况和特殊技巧来实现撤销和重做功能，由于本系列⽂档实现的是采⽤了⼀般化的

⽅法实现了撤销和重做框架！所以就要思考这样的问题：采⽤取巧的⽅法是否⼀定⽐这⾥通⽤的⽅法在时间和空间上⾯⾼效呢？本⽂就是

通过讨论⼀个基本的交换函数来作为类⽐，虽然不是很有说服⼒的解释，但是也说明了不少的问题！

下⾯是经典的交换函数的两种实现⽅式：

采⽤中间变量的交换过程：

inta=10;

intb=20;

//需要第三个变量进⾏中转的交换过程

intt;//中转变量

t=a;//执⾏之后a=10b=20t=10

a=b;//执⾏之后a=20b=20

b=t;//执⾏之后a=20b=10

这就类似于有⼀杯橙汁(a)和⼀杯⽜奶(b)，要想把两个杯⼦中的饮料进⾏置换，就必须借助于第三⽀空杯⼦(t)。交换的过程如下：

1.把橙汁(a)导⼊空杯⼦(t)中

2.把⽜奶(b)导⼊盛橙汁的杯⼦(a)中

3.把空杯⼦(t)中的橙汁倒⼊盛⽜奶的杯⼦(a)中

在上⾯的讨论过程中，假设了三个杯⼦的⼤⼩⼀样，其实这种假设是不必要的！特别需要注意的是，这⾥的这个过程可以很容易的实现逆

操作！

下⾯再来看看采⽤另外的⼀种假设的交换过程：

inta=10;

intb=20;

//不需要第三个变量进⾏中转的交换过程

a=a+b;//右边a=10b=20执⾏之后a=30b=20

b=a-b;//右边a=30b=20执⾏之后a=30b=10

a=a-b;//右边a=30b=10执⾏之后a=20b=10

从上⾯的交换过程可以看出，并没有采⽤第三个变量，⽽是直接采⽤了两个变量的⾃⾝！这其实就是假设了：装橙汁和装⽜奶的两个杯⼦

都最多只装了⼀半！交换过程如下：

1.将⽜奶倒⼊盛橙汁的杯⼦中

2.从1中的混合溶液中萃取出橙汁，放⼊盛⽜奶的杯⼦中

上⾯的这个萃取过程是可不是那么容易实现的，这是由物理特性和化学特性决定的！但是把上⾯的⽜奶和橙汁换成⽔和汽油，那么实现起

来就容易多了！当然是⽜奶换成⽔，橙汁换成汽油啦：）不过还要注意的是，上⾯的那个数学过程是可以实现可逆操作的，但是后⾯的那

个物理过程却很难实现逆操作！

从上⾯的两种交换过程可以看出：虽然可以采⽤⼀些特定的技巧（例如第⼆种交换⽅法）实现不采⽤第三个量实现交换，但是这种交换过

程的限制却太多了，不容易推⼴使⽤！此外这种⾮常有技巧的交换过程的逆操作的实现也是⾮常困难的，不可能有⽐较通⽤的⽅法实现逆

操作的！

鉴于此，第⼀种⽅法虽然采⽤了第三个变量实现交换，但是这种⽅法有着下⾯的种种优势：

1.交换过程可以⾮常容易的实现

2.交换过程的逆操作也可以很容易的实现

3.采⽤第三个变量实现交换的过程并不⽐其他的特定技巧实现的交换过程的⽅法占⽤的资源多！

关于第3点，可以这样解释：第⼀种交换⽅法所⽤的三个杯⼦可以是⼀样⼤，⽽第⼆种交换⽅法的两个杯⼦，先倒出⽜奶的杯⼦可以只有装

橙汁的杯⼦的容积的⼀半⼤⼩！如果装⽜奶的杯⼦和第⼀种⽅法中的杯⼦⼤⼩⼀致，那么两种⽅法的杯⼦的容积是⼀样的！由此可见，采

⽤特定的⽅法并不⼀定省资源:(

有了上⾯的讨论，可以看出，第⼀种交换⽅法是⼀种⾮常好的通⽤的交换⽅法：）撤销和重做的本质就是⼀种交换过程，下⾯的内容都是

围绕这种⽅法来讨论的:)

⾸先讨论⼀下针对整型变量v的撤销和重做功能的原理实现：

intv=5;//v的当前值

v=8;//(1)现在需要将v的值修改成为8

v=5;//(2)撤销将v的值修改成为8的操作

v=8;//(3)重做将v的值修改成为8的操作

在上⾯的代码中可以看出：这是⼀个典型的修改操作的撤销和重做的原理实现，其中：

1.步骤（1）中的8是修改参数

2.步骤（2）中的5是v在执⾏修改操作之前的原始数据

3.步骤（3）中的8是执⾏重做操作需要的修改参数备份，必须在执⾏修改操作之前备份之

从⽽可以总结出实现撤销和重做所必须遵守的规范如下：

1.为了实现撤销操作必须在修改对象之前备份原始数据

2.为了实现重做操作必须在修改对象的时候备份修改参数

有了这两条规范就可以保证任何操作（到⽬前为⽌我还没有发现不能⽤这种⽅式实现撤销和重做的操作）都可以通过这两条规则实现撤销

和重做的能⼒了。

好了，到⽬前为⽌，有了实现撤销和重做⽅案的通⽤规则，并且这种规则的空间和时间效率都⾮常好，我们该讨论⼀下三个基本操作和⼀

个复合操作了。⾄于为什么只有三种基本操作和⼀个复合操作，这是我在编写这个撤销和重做框架的过程中慢慢积累起来的，⾄于严格的

证明，恐怕不是我现在可以处理的了:(

这个三个基本操作是：

a.创建操作

b.修改操作

c.删除操作

⼀个复合操作是：

d.复合操作

⼀共是四个操作，其中复合操作可以是三个基本操作的组合，也可以是三个基本操作和复合操作的任意组合，也就是说：复合操作⾥⾯还

有⼦复合操作，这种嵌套可以达到任意的层次。这⾥⾯的组合就是千变万化的了！

好了，说了这么多，是该看看具体的代码是如何实现的了。值得说明的是：为了代码的正确性和可读性，在实现的过程中尽量避免⾮常复

杂的C++指针操作问题，当然对于避免不了的指针问题，也要尽可能的使其简单；取⽽代之的是尽量使⽤STL中的容器和算法来实现需要

的功能。

在上⾯的修改操作的原理实现中，我们⾸先就已经拥有了⼀个整型变量v，所以执⾏修改操作的必要条件就是保证该变量已经存在（没有变

量，如何修改啊），但是这⾥的变量v从分配到释放的过程没有考虑，因此下⾯来讨论分配和释放两个过程对应的创建操作和删除操作：

int*ptr=newint(5);//创建操作

deleteptr;ptr=;//删除操作

可以看出，对象的创建过程就是创建操作，⽽对象的释放过程就是删除操作。在此其实还有另外⼀种考虑：如何表⽰存在和消失的概念？

⽬前我只能想到⽤另外⼀个对象来记录这种变化，也就是说：对象的存在和消失的状态，对象⾃⾝是不可以保存的，必须通过另外的对象

（这⾥采⽤的是整型指针）来保存！⽽这另外⼀个对象来保存其他对象的存在和消失的状态，实际上也是⼀种修改过程，只不过这种修改

过程不需要实现撤销和重做功能，也就是说实现撤销和重做能⼒需要借助于不需要撤销和重做的基础才能实现！这是不是很⽭盾，其实这

是普遍的规律，量⼦信息的通信还是需要借助于传统通讯基础才能实现：）

事实上，除了⽤指针对象来表⽰对象的存在和消失状态外，也可以⽤STL容器来表⽰对象的存在和消失状态，⽽后者就是在本⽂中采⽤的⽅

案！当容器中存在对象的时候，可以从STL容器中索引出相应的对象；当容器中没有指定索引的对象的时候，就表⽰该对象已经被释放了！

Tip

·事实上，只要能够表⽰存在和消失的概念的C++量都可以在这⾥作为

·另外⼀个对象。

这⾥强调了索引，其实这⾥的索引包含了两层意思：

名字

·STL容器中可以存放多个同类型对象，为了识别不同的对象，就需要为每个对象取⼀个

·独⼀⽆⼆的名字，当然这⾥的独⼀⽆⼆仅仅只限于该STL容器范围

动作

·为STL容器中的多个对象取独⼀⽆⼆名字的⽬的就是为了能够在修改的时候有提取指定

·对象的能⼒

在编写GUI程序的过程中，经常⽤对话框来实现对⼀批对象的操作，⽽且这种批量操作的撤销操作和重做操作也希望能够⼀步执⾏所有⼦操

作的撤销和重做操作，否则⾏为就会极其怪异。这种批量操作不同于上⾯的修改操作、创建操作以及删除操作，⽽是独⽴于这三种基本操

作之外的操作。简单点说就是⼀种能够组合基本操作和批量操作的操作。这种操作就是前⾯所说的复合操作。

现在对前⾯的讨论进⾏总结如下：

修改操作

1.为了实现撤销操作必须在对对象修改之前保存原始信息备份

2.为了实现重做操作必须在修改对象的时候保存修改信息备份

创建操作删除操作

1.必须通过对象(v)之外的其他对象(ptr)来反映该对象的存在和消失状态

2.创建操作和删除操作互为逆操作，可以⽤来互相实现对⽅的撤销操作

3.本质上讲，创建操作和删除操作的撤销和重做操作实际上就是针对该对象之外的对象(ptr)执⾏的修改操作，因此也必须要满⾜修改操

作的信息备份要求

复合操作

1.必须能够组合前⾯讨论的修改操作、创建操作和删除操作三种基本操作

2.当然复合操作也要能够组合其他的⼦复合操作

为了使得讨论更加形象，在这⾥特别提供⼀个对象类：

//对象类

classObject

{

public:

Object():_member(0){}

Object(intm):_member(m){}

private:

int_member;

};

有了这些讨论，我们就可以实现撤销和重做基本结构的原理实现了：

创建操作的原理实现：

//⾸先创建两个Object对象，为了避免指针的出现，采⽤了标识号的⽅法

{//创建操作的撤销和重做

typedefstd::mapContainer;//容器类

ContainerC;//必须⽤这个容器来表⽰对象的存在状态，并且可以根据标识符得到对象

intid1=1,id2=2;//两个对象的标识号创建参数保存于此

Objectobj(10);//对象创建参数保存于此

(std::make_pair(id1,obj));//创建标识号为id1的对象

(std::make_pair(id2,obj));//创建标识号为id2的对象

//创建操作的撤销⾮常容易实现

(id1);//创建标识号为id1的对象的撤销操作

(id2);//创建标识号为id2的对象的撤销操作

//创建操作的重做操作也⾮常容易实现，不过需要备份的创建参数

(std::make_pair(id1,obj));//重做创建标识号为id1的对象

(std::make_pair(id2,obj));//重做创建标识号为id2的对象

}

修改操作的原理实现：

{//修改操作的撤销和重做

typedefstd::mapContainer;//容器类

ContainerC;//必须⽤这个容器来表⽰对象的存在状态，并且可以根据标识符得到对象

//当然如果需要修改操作的话，对象就必须⼀定已经存在了

/

intid1=1,id2=2;//两个对象的标识号创建参数保存于此

Objectobj(10);//对象创建参数保存于此

(std::make_pair(id1,obj));//创建标识号为id1的对象

(std::make_pair(id2,obj));//创建标识号为id2的对象

/

//下⾯才能够开始实现修改操作

//为了能够实现撤销操作⽽必须保存的信息

ObjectOBK1=C[id1];//备份标识号为id1的对象的原始信息

ObjectOBK2=C[id2];//备份标识号为id2的对象的原始信息

//为了能够实现重做操作⽽必须保存的信息

ObjectOM1(20);//备份标识号为id1的对象的修改参数信息

ObjectOM2(50);//备份标识号为id2的对象的修改参数信息

//开始对对象实现修改操作

C[id1]=OM1;//修改标识号为id1的对象

C[id2]=OM2;//修改标识号为id2的对象

//开始对对象实现撤销操作

C[id1]=OBK1;//撤销修改标识号为id1的对象

C[id2]=OBK2;//撤销修改标识号为id2的对象

//开始对对象实现重做操作

C[id1]=OM1;//重做修改标识号为id1的对象

C[id2]=OM2;//重做修改标识号为id2的对象

}

删除操作的原理实现：

{//删除操作的撤销和重做

typedefstd::mapContainer;//容器类

ContainerC;//必须⽤这个容器来表⽰对象的存在状态，并且可以根据标识符得到对象

//当然如果需要删除操作的话，对象就必须⼀定已经存在了

/

intid1=1,id2=2;//两个对象的标识号创建参数保存于此

Objectobj(10);//对象创建参数保存于此

(std::make_pair(id1,obj));//创建标识号为id1的对象

(std::make_pair(id2,obj));//创建标识号为id2的对象

/

//下⾯才能够开始实现删除操作

//为了能够实现撤销操作⽽必须保存的信息

ObjectOBK1=C[id1];//备份标识号为id1的对象的原始信息

ObjectOBK2=C[id2];//备份标识号为id2的对象的原始信息

//开始对对象实现删除操作

(id1);//删除标识号为id1的对象

(id2);//删除标识号为id2的对象

//开始对对象实现撤销操作

(std::make_pair(id1,OBK1));//创建标识号为id1的对象

(std::make_pair(id2,OBK2));//创建标识号为id2的对象

//开始对对象实现重做操作

(id1);//重做删除标识号为id1的对象

(id2);//重做删除标识号为id2的对象

}

复合操作的原理实现：

{//复合操作

//由于复合操作需要对三个基本操作进⾏保存，也需要对⼦复合操作

//进⾏保存，在这⾥不⽅便给出，所以在后续的章节对这三个基本操

//作进⾏了封装之后才能够讨论。

}

从上⾯的三种操作的原理实现可以看出，为了实现三个基本操作的撤销和重做，都必须在执⾏操作之前进⾏必要的数据备份，为撤销和重

做提供必要的数据。

此外，表达对象存在和消失的状态是通过容器类（Container）来实现的！容器类的状态变化是不可以撤销和重做的，这也正是体现了前⾯

所提到的新功能必须借助于现有的基础才能实现的思想。此外⽤整数作为区别同类型对象的标识符！采⽤整数作为标识符是本框架在最初

的时候采⽤的⽅案。但是后来发现：采⽤指针作为标识符⽐整数作标识符更加直接、⽅便且⾼效！这在后⾯的代码中将会直接反映出来:-)

复合操作没能实现的原因已经在代码⾥⾯说明了:-)

在上⼀节中，已经对三种基本操作的撤销和重做的原理实现进⾏了细致的分析，并给出了⽰例代码，但是并没能够给出复合操作的⽰例代

码。这⾥⾯有着⽐较深刻的原因，具体来说就是：复合操作⾥⾯保存的是三个基本操作以及⼦复合操作的任意组合，这⾥⾯本⾝就存在⼀

个将三个基本操作和复合操作对象化的概念，在三个基本操作实现对象化之前是不能够讨论复合操作的！既然需要对三个基本操作进⾏对

象化，同时还应该看到：复合操作可以保存其它的复合操作，这说明复合操作也需要对象化！既然三个基本操作和⼀个复合操作都需要对

象化，并且这些对象都可以保存到复合操作⾥⾯，那么在对三个基本操作的对象化的同时就应该考虑复合操作的对象化问题！

现在就来讨论⼀下三个基本操作和⼀个复合操作的对象化问题，不过在讨论这个问题之前必须先回答下⾯的⼏个问题：

1.三个基本操作和⼀个复合操作的组合过程需要撤销和重做功能吗？

2.三个基本操作和⼀个复合操作怎样保存在复合操作⾥⾯？

3.撤销和重做功能在应⽤程序⾥⾯是怎么使⽤的？

对于问题1可以肯定的说是不需要撤销和重做功能的，否则就会成为“蛋鸡问题”！究竟是先有蛋还是先有鸡呢？我想这不应该是我回答的

问题吧:-)

对于问题2，C++⾥⾯有⽐较完美的⽅案，那就是C++天⽣具备的多态能⼒，所以问题2的答案就是通过保存操作类的基类指针指向不同类

型的对象实例的⽅法。

对于问题3就⽐较⿇烦了，不过还是有⽐较简单的⽅案的：应⽤程序中保存⼀个可撤销操作的命令队列，同时也要保存⼀个可重做操作的命

令队列；每当执⾏⼀个操作的时候，在执⾏完毕之后将这个命令保存到可撤销操作命令队列尾部，并且清空可重做操作命令队列；每当执

⾏撤销操作的时候，执⾏这个可撤销操作的反执⾏操作，执⾏完毕之后将这个命令从可撤销操作队列尾部移到可重做操作队列尾部；对于

重做操作则是执⾏可重做操作队列中的操作的执⾏操作，执⾏完毕之后将这个操作的命令从可重做操作队列尾部移到可撤销操作队列尾

部。

为了以后讨论的⽅便，在此引进“命令”概念：

命令

·将操作编码为C++类之后就成了命令类，命令类创建的对象就是命令

有了以上问题的讨论便可以得出如下的概念：

1.命令的操作对象都是另外存在的⼀个容器（对象存在和消失的状态由其保存），这个容器必须满⾜：

a.⽤标识号区别容器中的同类型的不同对象，⽽且这种绑定是在程序运⾏期间是终⽣绑定的！

b.能够根据标识号得到对象

2.必须有⼀个命令基类，这样才可以将所有的命令保存到复合命令中；同时命令基类必须提供接⼝，以提供执⾏操作和反执⾏操作。

3.复合命令实际上是⼀个命令队列，执⾏操作就是顺序调⽤⼦命令的执⾏操作，⽽反执⾏操作就是逆序调⽤⼦命令的反执⾏操作。

关于标识符与对象的绑定是终⽣绑定的问题根源在于：当标识符绑定的对象在执⾏删除操作之后，该标识符⼜和别的对象进⾏了绑定，那

么当这个删除操作撤销的时候就会出问题！因为⼀个标识符不可以⽤来标识两个对象，否则如何能够根据这个标识符来得到绑定的对象

呢？

有了这些讨论，现在可以得出标识符应该具备的功能列表了：

1.在程序的运⾏期间的任何时刻，⼀个标识符都要能够且只能够索引出⼀个对象

2.只有当标识符被完全废⽌的时候才能够重新使⽤这个标识符

3.所谓的标识符完全废⽌，是指在程序运⾏到废⽌该标识号之后的任何时候都不存在调⽤该标识号索引相应对象的代码

在前⾯的原理实现中，给出的是采⽤int类型的标识符。关于标识符的产⽣，采⽤的是预先分配的⽅式（直接给出了id1和id2）。这对于固

定的对象代码当然没有问题，但是要想使得标识号能够⽤到动态⽣成的对象上⾯，就必须提供⼀个标识号⾃动⽣成的函数了！

经过深⼊的考虑（⼤约两年多时间）之后，发现：采⽤指针作为标识符⽐整数作标识符更加直接、⽅便且⾼效，具体原因如下：

1.在程序的运⾏周期内，程序分配的指针值（整数值）是绝对不会重复的！当然这也是要满⾜⼀定条件的，在讨论后⾯的容器类的时候

会讨论到这⼀点。这就解决了标识符⾃动⽣成的问题:-)

2.标识符要求能够根据标识符索引得到绑定的对象！关于这⼀点C++指针天⽣就具备这种能⼒，根本就不需要额外的编码实现！从⽽采

⽤指针作为标识符使得C++实现更加⾃然

3.要想在⼀个对象内部引⽤其它对象，采⽤指针是⼀个更加直接的⽅式！试想⼀下，如果⼀个对象内部放置了⼀个整数⽤来索引其它的

对象，这会多么的别扭啊！此外⽤整数标识其它类型的对象把对象的类型弄丢了！这在C++中应该尽⼒避免，因为C++的⾼效很⼤⼀部分

在于类型系统的编译期优化

有了上⾯关于标识符的详细讨论之后，在后⾯的章节中将会采⽤指针作为标识符来实现这个撤销和重做框架。

好了现在终于可以给出三个基本命令和⼀个复合命令的⽰例代码了：

命令基类command（提供两个公共的接⼝：redo和undo）的实现如下：

structcommand

{

virtual~command(){}//避免内存泄漏

virtualvoidredo()=0;//重做操作，兼任执⾏操作

virtualvoidundo()=0;//撤销操作

};

Note

·将操作概念映射到具体的C++类，我将这种映射得到的C++类命名为操作

·类，⽽操作类定义的对象就是命令，⽽这种将操作定义为命令

·的过程就是对象化。

组合操作类的复合操作类：

classbatch//复合命令

:publiccommand//是⼀种命令

,publicstd::list//⽤来记录⼦命令的命令队列

{

public:

virtual~batch()//当复合命令被释放的时候，所有的⼦命令也要释放

{

this->free();

}

voidrecord(command*pCmd)//记录⼦命令，⼦命令必须通过new创建

{

this->push_back(pCmd);

}

public:

virtualvoidredo()//执⾏操作和重做操作

{

std::for_each(begin(),end(),std::mem_fun(&command::redo));

}

virtualvoidundo()//撤销操作

{

std::for_each(rbegin(),rend(),std::mem_fun(&command::undo));

}

voidfree()//⽤复合命令实现命令中⼼的时候，需要这个函数

{

std::for_each(this->begin(),this->end(),kill());//释放⼦命令对象

this->clear();//释放⼦命令对象指针

}

};

其中的仿函数kill的实现如下：

structkill//给STL使⽤的仿函数

{

templatevoidoperator()(T*ptr)

{

deleteptr;//delete⾃动判断ptr是否为NULL

}

};

这⾥的kill纯粹是为了使得编码更加简洁。

虽然有了上⾯的命令基类、复合操作类就可以实现任意的撤销和重做功能的程序了，但是很明显，还需要编写⼤量的派⽣⾃命令基类的各

种各样的操作类。那么有没有办法减轻或者消除这种负担呢？

在前⾯讨论过程中，我们已经假定任何操作都可以采⽤三种基本操作和⼀个复合操作来实现，那么撤销和重做的架构的⾃动化就要以这个

假定为基础了。

在前⾯讨论三个基本操作的时候，我们知道对象的存在状态必须通过另外的对象来表现，因此需要提供⼀个始终存在的对象来表⽰。在这

⾥就采⽤和STL类似的容器类来表⽰这种状态：

templateclasscontainer:publicstd::t

{

public:

typedefTobject_type;

typedefstd::tpointers_type;

typedefstd::listobjects_type;

typedefstd::mapunud_type;

protected:

objects_type_objects;//所有的对象都保存在这⾥

unud_type_unud;//第⼆个参数是对应的变量被命令引⽤的数量

public:

//下⾯两个函数是在命令的创建和删除的时候调⽤的

//配合_unud就是⼀个受管理的引⽤计数智能指针

//只是引⽤该对象的“智能指针”只能是命令

voidincrea(T*id){_unud[id]++;}

voiddecrea(T*id){_unud[id]--;}

//获得⼀个可以使⽤的对象空间，当没有对象可以回收的时候就创建⼀个

virtualT*generate(T*ud=)

{

T*ptr=ud;

typenameunud_type::iteratorit;

//如果_unud中有引⽤计数为零的对象，直接返回该指针

for(it=_();it!=_();++it)

{

if(0==it->cond&&ud!=it->first)

{

ptr=it->first;

break;

}

}

//如果_unud中没有引⽤计数为零的对象，在_vector中新建⼀个对象

//并返回该新建对象的指针

if(ud==ptr)

{

__back(T());//调⽤默认构造函数的情况

ptr=&_();

}

returnptr;

}

//得到某个指针被命令引⽤的次数，不存在的指针引⽤计数为零

typenameunud_type::size_typeud(T**pID)

{

return(_(*pID)==_())?0:_unud[*pID];

}

public:

virtualvoidcreate(T*id)

{

this->inrt(id);

}

virtualvoidmodify(T*id,constT&v)

{

*id=v;

}

virtualvoidremove(T*id)

{

this->era(id);

}

};

此容器类已经采⽤了指针作为标识符！把这⾥的代码和前⾯的原理实现中的容器类（STL的map容器）进⾏⼀下对⽐便可以发现⾮常类

似，但也有很多不同。这是因为这个容器类考虑了前⾯谈到的标识符所必须具备的功能！下⾯逐⼀的进⾏解释：

标识符⾃动创建

·在程序的运⾏周期内，程序分配的指针值（整数值）是绝对不会重复的！

1.在上⾯的容器类⾥⾯，container向外提供的是t概念，也就是说容器⾥⾯的标识符（指针）是不允许重复的！

2.既然标识符是指针，那么必然有管理指针指向的对象的容器，在这⾥是_objects。最初使⽤的是STL的vector类，但是经过使⽤发

现，采⽤vector不能满⾜需求，相反采⽤list却⽐较能够满⾜需求！因为这个容器仅仅只是保存对象，对这些对象只执⾏⼀次添加操作，添

加的同时把新添加的对象地址值取出，作为标识符。除此之外，不需要任何其他的操作了。

3.对象的分配是通过_objects进⾏管理的。这样可以降低复杂度！基本分配原理就是：⾸先看看_unud⾥⾯有没有引⽤计数为零的还

没有被释放的闲置对象。有就直接利⽤之，反之则在_objects中追加⼀个，同时将追加的对象地址取出返回！

4.既然有对象分配，⾃然也要有资源的回收。上⾯的容器类的实现中，_unud容器是⼀个map容器，作⽤是和increa()和

decrea()函数配合使⽤，构成⼀个引⽤计数的“智能指针”概念！特别需要注意的是，这⾥的“智能指针”就是我们讨论的三个基本命

令对象！

索引对象

·C++指针天⽣就可以索引到对象:-)

嵌⼊到其他对象

·在其他的对象⾥⾯可以直接编写对象指针代码，这样就可以嵌⼊到其他的对象⾥⾯了

·！这⼀点在处理复杂对象的时候特别有⽤（当然要配合⾃动化编程的⾼级技术才可以

·）。

create()modify()remove()

·分别被三个基本命令调⽤，这样就可以⽐较对称的处理三个基本操作了：）撤销和重

·做的能⼒全部来⾃于三个基本命令类对必要数据的备份：）当然也可以采⽤其他专⽤

·的⽅法可以避免⼀些数据的备份，或许可以节省⼀些时间和空间上的开销，但是通常

·来说，这样是得不偿失的！即使采取各种各样的技巧，也未必真的可以减少时间或空

·间上的开销，见前⾯的swap函数的讨论。

ud()

·因为对象的指针是作为标识符的，同时也可以直接操作对象！既然可以直接操作对象

·，那么就可以在撤销和重做库的外部保存该指针变量，该指针变量有可能是动态分配

·的就会出现释放的问题，所以在此提供⼀个查询指针的命令引⽤计数的函数。当该函

·数返回0的时候，就表⽰没有命令引⽤该指针，也就表⽰可以安全删除该指针变量：）

·特别注意不是删除指针指向的对象，⽽是指针变量⽽已，指针所指向的对象

·并没有被删除，该对象由容器类管理。

有了上⾯的容器类之后，就可以来编写属于该容器类的三个基本操作类了：

创建操作类：

templateclasscreate:publiccommand

{

voidinit()

{

//下⾯的generate函数主要是在第⼀次执⾏创建命令的时候起作⽤

_ID=_te(_ID);//如果_ID已经被使⽤了，则创建新的对象空间

_(_ID);//容器类的引⽤计数增⼀

}

public:

typedeftypenameContainer::object_typeT;

create(Container&C,T*&ID):_C(C),_ID(ID)

{

init();

}

create(Container&C,T*&ID,constT&O):_C(C),_ID(ID)

{

init();*_ID=O;

}

virtual~create()

{

_(_ID);//容器类的引⽤计数减⼀

}

voidredo()

{

_(_ID);

}

voidundo()

{

_(_ID);

}

private:

create(){}

Container&_C;

T*&_ID;

};

修改操作类：

templateclassmodify:publiccommand

{

public:

typedeftypenameContainer::object_typeT;

public:

modify(Container&C,T*ID,constT&O):_C(C),_ID(ID),_O(O)

{

_OB=*_ID;//备份信息

_(_ID);

}

virtual~modify()

{

_(_ID);

}

voidredo()

{

_(_ID,_O);

}

voidundo()

{

_(_ID,_OB);

}

private:

bool_backuped;//是否已经进⾏过备份啦，避免重复备份的问题

modify(){}

Container&_C;

T*_ID;

T_O;//修改参数

T_OB;//修改之前的对象

};

删除操作类（因为delete是C++操作符，所以选择了remove）：

templateclassremove:publiccommand

{

typedeftypenameContainer::object_typeT;

public:

remove(Container&C,T*&ID):_C(C),_ID(ID),_IDB(ID)

{

_(_ID);

}

virtual~remove()

{

_(_ID);

}

voidredo()

{

_(_ID);

_ID=;//标识号为NULL表⽰已经被删除了

}

voidundo()

{

_ID=_IDB;//撤销了删除操作，标识号应该复原

_(_ID);

}

private:

remove(){}

Container&_C;

T*&_ID;

T*_IDB;

};

有了前⾯的这些讨论就可以⽤最少的编码付出得到⾮常强⼤的撤销和重做功能。下⾯是⼀个使⽤中的实际例⼦：

在测试代码中使⽤的对象：

//对象类

classObject

{

public:

Object():_member(0){}

Object(intm):_member(m){}

//这个函数是前⾯的命令中所必须的操作符

Object&operator=(constObject&o)

{

if(&o!=this)

{

_member=o._member;

}

return*this;

}

private:

int_member;

//下⾯的这个函数仅仅是为了⽅便显⽰对象信息⽽重载的操作符

template

friendStream&operator<<(Stream&s,Object&o)

{

s<

returns;

}

};

//为了能够判断操作的正确性需要输出容器的信息

template

voiddisplay(constchar*str,Container&c)

{

std::cout<

typenameContainer::iteratorit=();

for(;it!=();++it)

{

std::cout<<<<*it<<<<**it<<;

}

std::cout<

}

测试代码：

创建命令的撤销和重做⽰例：

{//模拟创建操作的撤销和重做

typedefundo::raw::container