Undo/Redo框架的一种实现

在许多软件尤其是编辑器类软件中，需要操作的撤销和重做(Undo/Redo)。其实，Undo/Redo的思路很简单，下面介绍一种Undo/Redo的框架。

每一步操作看作一个命令(Command)。在每一步操作之后，添加一个命令到命令管理器(UndoRedo)。这个具体的命令对象记录操作的状态。当用户执行撤销时，取出最后添加的那个Commad对象调用它的Undo方法，此时，并不删除这个Command对象，只是让指示当前Command的游标移动一个位置。这样，执行Redo操作时，反向移动游标，调用相应的Command对象的Do方法即可实现Redo。

复合命令(MultiCommand)是一组命令的集合，软件中有某些操作是不可分割的整体时，使用它实现一次多个操作的撤销和重做。

 

下面是框架代码：

//command.h

 

//Command 接口定义

class Command

{

protected :

    Command(){}

public :

    virtual ~Command(){}

    virtual void Do() = 0;

    virtual void Undo() = 0;

};

 

class MultiCommand : public Command

{

public :

    MultiCommand(){}

    virtual ~MultiCommand();

 

    virtual void Do();

    virtual void Undo();

 

    void AddCommand(Command * cmd);

    bool IsEmpty() const;

 

private :

    typedef std::vector<Command*> CommandVec;

    CommandVec m_cmds;

};

 

// 帮助删除容器中对象的防函数

struct DeleteContPtr {

    template <typename T>

       void operator()(T *&p) {

           delete p;

           p = NULL;

       }

       template <typename T,typename U>

           void operator()(std::pair<T,U*> &pr) {

              delete pr.second;

              pr.second = NULL;

           }

};

 

//command.cpp

 

MultiCommand::~MultiCommand()

{

    std::for_each(m_cmds.begin(),m_cmds.end(),DeleteContPtr());

}

 

void MultiCommand::Do()

{

    std::for_each(m_cmds.begin(),m_cmds.end(),std::mem_fun(&Command::Do));

}

 

void MultiCommand::Undo()

{

    std::for_each(m_cmds.rbegin(),m_cmds.rend(),std::mem_fun(&Command::Undo));

}

 

void MultiCommand::AddCommand(Command * cmd)

{

    assert(cmd);

    m_cmds.push_back(cmd);

}

 

bool MultiCommand::IsEmpty() const

{

    return m_cmds.empty();

}

 

//undoredo.h

//UndoRedo 管理器

 

class Command;

class UndoRedo

{

public :

    UndoRedo(size_t maxSteps = 100);

    ~UndoRedo();

 

    void AddCommand(Command * cmd);

    void Undo(int steps = 1);

    void Redo(int steps = 1);

    bool CanUndo() const;

    bool CanRedo() const;

private :

    typedef std::deque<Command*> CommandQueue;

    size_t m_maxSteps;

    CommandQueue m_cmds;

    CommandQueue::iterator m_currPos;

};

 

//undoredo.cpp

UndoRedo::UndoRedo(size_t maxSteps /*= 100*/) : m_maxSteps(maxSteps)

{

    assert(m_maxSteps > 0);

}

 

UndoRedo::~UndoRedo()

{

    std::for_each(m_cmds.begin(),m_cmds.end(),DeleteContPtr());

}

 

void UndoRedo::AddCommand(Command * cmd)

{

    assert(cmd);

 

    std::for_each(m_cmds.begin(),m_currPos,DeleteContPtr());

    m_cmds.erase(m_cmds.begin(),m_currPos);

 

    while (m_cmds.size() >= m_maxSteps)

    {

       delete m_cmds.back();

       m_cmds.pop_back();

    }

 

    m_cmds.push_front(cmd);

    m_currPos = m_cmds.begin();

}

 

void UndoRedo::Undo(int steps /* = 1 */)

{

    int i = 0;

    while (m_currPos != m_cmds.end() && ++i <= steps)

    {

       (*m_currPos++)->Undo();

    }

}

 

void UndoRedo::Redo(int steps /* = 1 */)

{

    int i = 0;

    while (m_currPos != m_cmds.begin() && ++i <= steps)

    {

       (*--m_currPos)->Do();

    }

}

 

bool UndoRedo::CanUndo() const

{

    return m_currPos != m_cmds.end();

}

 

bool UndoRedo::CanRedo() const

{

    return m_currPos != m_cmds.begin();

}