Вопрос на интеллектуальных указателях и их неизбежном индетерминизме

Проблемная Сводка

Там является двумя конкурирующими проблемами в этом вопросе.

1. управление жизненным циклом Subsystem с, позволяя их удаление в нужное время.
2. Клиенты Subsystem с должна знать, что Subsystem они используют, допустимо.

Обработка № 1

System владеет Subsystem с и должна управлять их жизненным циклом со своим собственным объемом. Используя shared_ptr с для этого особенно полезна, поскольку она упрощает разрушение, но Вы не должны раздавать их, потому что тогда Вы освобождаете детерминизм, который Вы ищете относительно их освобождения.

Обработка № 2

Это - больше беспокойства межжала для обращения. Описывая проблему более подробно, Вам нужны клиенты для получения объекта, который ведет себя как Subsystem, в то время как это Subsystem (и это - родитель System) существует, но ведет себя соответственно после Subsystem уничтожается.

Это легко решено комбинацией Шаблон "proxy" , Шаблон состояния и Шаблон Несуществующего объекта . В то время как это, может казаться, немного сложно решения, ' существует простота только, чтобы иметься с другой стороны сложности '. Как разработчики Библиотеки/API, мы должны пойти дополнительная миля для создания наших систем устойчивыми. Далее, мы хотим, чтобы наши системы вели себя интуитивно, как пользователь ожидает, и затухать корректно, когда они попытаются неправильно использовать их. Существует много решений этой проблемы, однако, этот должен получить Вас к тому всему важному моменту, где, как Вы и Scott Meyers говорит, это" просто в использовании правильно и трудно использовать неправильно. '

Теперь, я предполагаю, что в действительности, System соглашения в некотором базовом классе [1 113] с, из которой Вы происходите всевозможный Subsystem с. Я представил его ниже как [1 115]. Необходимо представить Прокси объект, SubsystemProxy ниже, который реализует интерфейс [1 117] запросами на переадресацию к объекту, который это проксирует. (В этом смысле это очень похоже на приложение особого назначения Шаблон "декоратор" .) Каждый Subsystem создает один из этих объектов, которые он содержит через shared_ptr и возвращает, когда требуется через [1 120], который называет родитель System объект, когда GetSubsystem() назван.

, Когда System выходит из объема, каждого из, его Subsystem, объекты разрушены. В их деструкторе они звонят mProxy->Nullify(), который вызывает их Прокси объекты изменить их состояние . Они делают это путем изменения на точку к Несуществующий объект , который реализует эти SubsystemBase интерфейс, но делает так, ничего не делая.

Используя Шаблон состояния здесь позволил клиентскому приложению абсолютно не обращать внимания на то, существует ли деталь Subsystem. Кроме того, это не должно проверять указатели или иметь в наличии экземпляры, которые должны были быть уничтожены.

Шаблон "proxy" позволяет клиенту зависеть от объекта легкого веса, который полностью оборачивает детали внутренних работ API и поддерживает постоянный, универсальный интерфейс.

Шаблон Несуществующего объекта позволяет Прокси функционировать после того, как оригинал Subsystem был удален.

Пример кода

я поместил грубый качественный пример псевдокода сюда, но я не был удовлетворен им. Я переписал его, чтобы быть точным, компилируя (я использовал g ++), пример того, что я описал выше. Чтобы заставить его работать, я должен был представить несколько других классов, но их использование должно быть четким из их имен. Я использовал Шаблон "одиночка" для NullSubsystem класс, поскольку это имеет смысл, что Вам не был бы нужен больше чем один. ProxyableSubsystemBase полностью абстрагирует поведение Проксирования далеко от эти Subsystem, позволяя ему быть незнакомым с этим поведением. Вот диаграмма UML классов:

Пример кода:

#include <iostream>
#include <string>
#include <vector>

#include <boost/shared_ptr.hpp>


// Forward Declarations to allow friending
class System;
class ProxyableSubsystemBase;

// Base defining the interface for Subsystems
class SubsystemBase
{
  public:
    // pure virtual functions
    virtual void DoSomething(void) = 0;
    virtual int GetSize(void) = 0;

    virtual ~SubsystemBase() {} // virtual destructor for base class
};


// Null Object Pattern: an object which implements the interface to do nothing.
class NullSubsystem : public SubsystemBase
{
  public:
    // implements pure virtual functions from SubsystemBase to do nothing.
    void DoSomething(void) { }
    int GetSize(void) { return -1; }

    // Singleton Pattern: We only ever need one NullSubsystem, so we'll enforce that
    static NullSubsystem *instance()
    {
      static NullSubsystem singletonInstance;
      return &singletonInstance;
    }

  private:
    NullSubsystem() {}  // private constructor to inforce Singleton Pattern
};


// Proxy Pattern: An object that takes the place of another to provide better
//   control over the uses of that object
class SubsystemProxy : public SubsystemBase
{
  friend class ProxyableSubsystemBase;

  public:
    SubsystemProxy(SubsystemBase *ProxiedSubsystem)
      : mProxied(ProxiedSubsystem)
      {
      }

    // implements pure virtual functions from SubsystemBase to forward to mProxied
    void DoSomething(void) { mProxied->DoSomething(); }
    int  GetSize(void) { return mProxied->GetSize(); }

  protected:
    // State Pattern: the initial state of the SubsystemProxy is to point to a
    //  valid SubsytemBase, which is passed into the constructor.  Calling Nullify()
    //  causes a change in the internal state to point to a NullSubsystem, which allows
    //  the proxy to still perform correctly, despite the Subsystem going out of scope.
    void Nullify()
    {
        mProxied=NullSubsystem::instance();
    }

  private:
      SubsystemBase *mProxied;
};


// A Base for real Subsystems to add the Proxying behavior
class ProxyableSubsystemBase : public SubsystemBase
{
  friend class System;  // Allow system to call our GetProxy() method.

  public:
    ProxyableSubsystemBase()
      : mProxy(new SubsystemProxy(this)) // create our proxy object
    {
    }
    ~ProxyableSubsystemBase()
    {
      mProxy->Nullify(); // inform our proxy object we are going away
    }

  protected:
    boost::shared_ptr<SubsystemProxy> GetProxy() { return mProxy; }

  private:
    boost::shared_ptr<SubsystemProxy> mProxy;
};


// the managing system
class System
{
  public:
    typedef boost::shared_ptr< SubsystemProxy > SubsystemHandle;
    typedef boost::shared_ptr< ProxyableSubsystemBase > SubsystemPtr;

    SubsystemHandle GetSubsystem( unsigned int index )
    {
        assert( index < mSubsystems.size() );
        return mSubsystems[ index ]->GetProxy();
    }

    void LogMessage( const std::string& message )
    {
        std::cout << "  <System>: " << message << std::endl;
    }

    int AddSubsystem( ProxyableSubsystemBase *pSubsystem )
    {
      LogMessage("Adding Subsystem:");
      mSubsystems.push_back(SubsystemPtr(pSubsystem));
      return mSubsystems.size()-1;
    }

    System()
    {
      LogMessage("System is constructing.");
    }

    ~System()
    {
      LogMessage("System is going out of scope.");
    }

  private:
    // have to hold base pointers
    typedef std::vector< boost::shared_ptr<ProxyableSubsystemBase> > SubsystemList;
    SubsystemList mSubsystems;
};

// the actual Subsystem
class Subsystem : public ProxyableSubsystemBase
{
  public:
    Subsystem( System* pParentSystem, const std::string ID )
      : mParentSystem( pParentSystem )
      , mID(ID)
    {
         mParentSystem->LogMessage( "Creating... "+mID );
    }

    ~Subsystem()
    {
         mParentSystem->LogMessage( "Destroying... "+mID );
    }

    // implements pure virtual functions from SubsystemBase
    void DoSomething(void) { mParentSystem->LogMessage( mID + " is DoingSomething (tm)."); }
    int GetSize(void) { return sizeof(Subsystem); }

  private:
    System * mParentSystem; // raw pointer to avoid cycles - can also use weak_ptrs
    std::string mID;
};



//////////////////////////////////////////////////////////////////
// Actual Use Example
int main(int argc, char* argv[])
{

  std::cout << "main(): Creating Handles H1 and H2 for Subsystems. " << std::endl;
  System::SubsystemHandle H1;
  System::SubsystemHandle H2;

  std::cout << "-------------------------------------------" << std::endl;
  {
    std::cout << "  main(): Begin scope for System." << std::endl;
    System mySystem;
    int FrankIndex = mySystem.AddSubsystem(new Subsystem(&mySystem, "Frank"));
    int ErnestIndex = mySystem.AddSubsystem(new Subsystem(&mySystem, "Ernest"));

    std::cout << "  main(): Assigning Subsystems to H1 and H2." << std::endl;
    H1=mySystem.GetSubsystem(FrankIndex);
    H2=mySystem.GetSubsystem(ErnestIndex);


    std::cout << "  main(): Doing something on H1 and H2." << std::endl;
    H1->DoSomething();
    H2->DoSomething();
    std::cout << "  main(): Leaving scope for System." << std::endl;
  }
  std::cout << "-------------------------------------------" << std::endl;
  std::cout << "main(): Doing something on H1 and H2. (outside System Scope.) " << std::endl;
  H1->DoSomething();
  H2->DoSomething();
  std::cout << "main(): No errors from using handles to out of scope Subsystems because of Proxy to Null Object." << std::endl;

  return 0;
}

Вывод от кода:

main(): Creating Handles H1 and H2 for Subsystems.
-------------------------------------------
  main(): Begin scope for System.
  <System>: System is constructing.
  <System>: Creating... Frank
  <System>: Adding Subsystem:
  <System>: Creating... Ernest
  <System>: Adding Subsystem:
  main(): Assigning Subsystems to H1 and H2.
  main(): Doing something on H1 and H2.
  <System>: Frank is DoingSomething (tm).
  <System>: Ernest is DoingSomething (tm).
  main(): Leaving scope for System.
  <System>: System is going out of scope.
  <System>: Destroying... Frank
  <System>: Destroying... Ernest
-------------------------------------------
main(): Doing something on H1 and H2. (outside System Scope.)
main(): No errors from using handles to out of scope Subsystems because of Proxy to Null Object.

Другие Мысли:

• интересная статья я читал в одной из Игры, Программируя переговоры по книгам Драгоценных камней об использовании Несуществующих объектов для отладки и разработки. Они конкретно говорили об использовании Пустых Графических Моделей и Структур, таких как структура шахматной доски, чтобы заставить недостающие модели действительно выделиться. То же могло быть применено здесь путем изменения NullSubsystem для ReportingSubsystem, который зарегистрирует вызов и возможно стек вызовов каждый раз, когда к этому получают доступ. Это позволило бы Вам или клиентам Вашей библиотеки разыскивать, где они в зависимости от чего-то, что вышло из объема, но без потребности вызвать катастрофический отказ.

• я упомянул в комментарии @Arkadiy, что круговая зависимость, которую он поднял между [1 134] и Subsystem, немного неприятна. Это может легко быть исправлено при наличии System, происходят из интерфейса, от которого Subsystem зависит, приложение Robert C Martin Принцип Инверсии Зависимости . Лучше все еще должен был бы изолировать функциональность, в которой Subsystem с нуждаются от их родителя, пишут интерфейс для этого, затем содержат на конструктора того интерфейса в [1 139] и передают его Subsystem с, которая содержала бы его через shared_ptr. Например, Вы могли бы иметь LoggerInterface, который Ваш Subsystem использование для записи в журнал тогда Вы могли получить CoutLogger или FileLogger от него и сохранить экземпляр такого в [1 146].