Работа над прочным шаблоном команды с помощью shared_ptr

Поскольку в противном случае это не имело бы для меня никакого смысла, я собираюсь предположить, что

• ваша библиотека предоставляет класс Manager (или, по крайней мере, базовый класс), и
• клиенты должны использовать этот класс для вызова Command.

В этом случае, возможно, что-то вроде этого может работать:

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) получить Foo из ClientFoo и использовать его для вызова Command.

Я думаю, что это passkey pattern должно быть правильным для вас:

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());
  }
};

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

Я не понимаю ваш вопрос на 100%, но вот...

Единственное, что я могу придумать для # 5, это сделать Command::execute частным/защищенным и сделать Manager friend из Command. Недостатком этого подхода является то, что теперь вы ввели зависимость от Command до Manager.

Что касается #6, если объекты shared_ptr<const Foo> пользователя были получены из коллекции shared_ptr<Foo> Менеджера, то Manager должен иметь возможность безопасно преобразовать const_pointer_cast shared_ptr<const Foo*> обратно в shared_ptr<Foo*>. Если Manager попытается преобразовать константу shared_ptr<const Foo*>, где pointee является фактическим постоянным объектом, вы получите неопределенное поведение.

Я подумал о другом решении для № 5:

Определите класс ExecutableCommand, производный от Command. ExecutableCommand имеет добавленный метод вызова команды, который может использоваться только Manager. Клиенты могут получить доступ только к ExecutableCommand объектам через указатели/ссылки на Command. Когда менеджер хочет вызвать Command, он понижает его до ExecutableCommand, чтобы получить доступ к интерфейсу вызова.

Рабочий пример (включая const_pointer_cast для #6):

#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;
}