使用shared_ptr处理可靠的命令模式

Question

我正在尝试在库中实现一个非常干净的命令模式。

我现在有以下结构（一些部分仍在完成中）：

1. 用户（客户端代码）有一些对象，称其为“Manager”
2. Manager 拥有一个 shared_ptrshared_ptr的集合。 Foo>
3. Manager 通过返回 shared_ptr 提供对集合的访问
4. 我有一个 Command 抽象类和命令层次结构用于执行的操作Foo
5. 客户端代码不应该调用Command::execute()，只有Manager应该 >，Manager::execute(shared_ptr)，以便它可以处理撤消/重做

我想遵循以下规则：

1. 用户（客户端代码）有一些对象，称之为“经理”
2. 经理持有shared_ptr 的集合
3. Manager 通过返回 shared_ptr 提供对集合的访问
4. 我有一个 Command 抽象类和对 Foo 执行操作的命令层次结构
5. 客户端代码不能（没有解决方法）调用 Command::execute() ， 仅有的Manager 可以，Manager::execute(shared_ptr)，这样它就可以处理undo/redo并获取非常量智能指针
6. 即使用户初始化了 Command，Manager 也必须能够允许 Command 对象访问和修改 shared_ptr > objecst 与 shared_ptr

我只是想找出处理发出 shared_ptr 同时允许数字 5 和 6 工作的最佳方法。

有没有任何示例/设计模式可以让我学习？与我已经拥有/正在做的事情相比，这是一个好主意吗？

Answer 1

我认为这个 密钥模式 应该适合您：

class CommandExecuteKey{
private:
  friend class Manager;
  CommandExecuteKey(){}
};

class Command{
public:
  // usual stuff
  void execute(CommandExecuteKey);
};

class Manager{
public
  void execute(Command& cmd){
    // do whatever you need to do
    cmd.execute(CommandExecuteKey());
  }
};

现在，Command 不知道有关 Manager 的任何信息，只知道所需的密钥对于执行功能。用户将无法直接调用 execute 方法，因为只有 Manager 可以创建 CommandExecuteKey 对象，这要归功于私有构造函数和 <代码>友谊。

int main(){
  Command cmd;
  Manager mgr;
  //cmd.execute(CommandExecuteKey()); // error: constructor not accessible
  mgr.execute(cmd); // works fine, Manager can create a key
}

---

现在，谈谈你的第六点：
当您输入命令时，在所有 shared_ptr 中搜索正确的对象（使用保存的命令 shared_ptr 作为搜索键），然后传递从内部 shared_ptr 返回到命令的可变指针。

Answer 2

因为否则对我来说没有任何意义，我将假设

• 您的库提供了 Manager 类（或至少是基类），并且
• 客户端必须使用该类来调用一个命令。

在这种情况下，也许这样的方法可以工作：

void Manager::execute(Command& cmd, shared_ptr<Foo const> const& target)
{
    shared_ptr<Foo> mutableTarget = this->LookupMutableFoo(mutableTarget); // throws if not found
    cmd.execute(mutableTarget); // client cannot invoke without mutable pointer
}

// or, if the "target" needs to be stored in the Command you could use something like this:
void Manager::execute(Command& cmd)
{
    shared_ptr<Foo> mutableTarget = this->LookupMutableFoo(cmd.GetTarget()); // throws if not found
    cmd.execute(mutableTarget); // client cannot invoke without mutable pointer
}

我不确定使用 const 是否是这里的最佳解决方案。也许您应该将 Foo 对象包装在例如 ClientFoo 对象中。管理器仅分发指向 ClientFoo 的指针。然后，管理器可以（例如通过friend）从ClientFoo获取Foo，并使用它来调用Command >。

Answer 3

我没有 100% 遵循你的问题，但这里是......

我唯一能想到的 #5 就是使 Command::execute 私有/受保护并使 Manager< /code> Command 的朋友。此方法的缺点是您现在引入了从 Command 到 Manager 的依赖关系。

对于#6，如果用户的 shared_ptr 对象源自 Manager 的 shared_ptr 集合，则 Manager 应该能够安全地将 const_pointer_cast shared_ptr 转换回 shared_ptr。如果 Manager 尝试 const 强制转换 shared_ptr（其中指针对象是实际的常量对象），您将得到未定义的行为。

---

我想到了 #5 的另一个解决方案：

定义一个从 Command 派生的 ExecutableCommand 类。 ExecutableCommand 添加了一个调用命令的方法，仅由 Manager 使用。客户端只能通过 Command 的指针/引用来访问 ExecutableCommand 对象。当管理器想要调用Command时，它将其向下转换为ExecutableCommand以获得对调用接口的访问。

工作示例（包括 #6 的 const_pointer_cast）：

#include <iostream>
#include <string>
#include <vector>
#include <boost/shared_ptr.hpp>

using namespace std;
using namespace boost;

//------------------------------------------------------------------------------
struct Foo
{
    Foo(int x) : x(x) {}
    void print() {++x; cout << "x = " << x << "\n";} // non-const
    int x;
};

//------------------------------------------------------------------------------
struct Command
{
    // Interface accessible to users
    std::string name;

private:
    virtual void execute() = 0;
};

//------------------------------------------------------------------------------
struct ExecutableCommand : public Command
{
    // Only accessible to Manager
    virtual void execute() {} // You may want to make this pure virtual
};

//------------------------------------------------------------------------------
struct PrintCommand : public ExecutableCommand
{
    PrintCommand(shared_ptr<const Foo> foo)
        : foo_( const_pointer_cast<Foo>(foo) ) {}

    void execute() {foo_->print();}

private:
    shared_ptr<Foo> foo_;
};

//------------------------------------------------------------------------------
struct Manager
{
    void execute(Command& command)
    {
        ExecutableCommand& ecmd = dynamic_cast<ExecutableCommand&>(command);
        ecmd.execute();
    }

    void addFoo(shared_ptr<Foo> foo) {fooVec.push_back(foo);}

    shared_ptr<const Foo> getFoo(size_t index) {return fooVec.at(index);}

private:
    std::vector< shared_ptr<Foo> > fooVec;
};

//------------------------------------------------------------------------------
int main()
{
    Manager mgr;
    mgr.addFoo( shared_ptr<Foo>(new Foo(41)) );

    Command* print = new PrintCommand(mgr.getFoo(0));
    // print.execute() // Not allowed
    mgr.execute(*print);

    delete print;
}