Question

给定一个控制具有项目的会话的库的C API，将C API封装到RAII C ++类中的最佳设计是什么？

C API看起来像：

HANDLE OpenSession(STRING sessionID);
void CloseSession(HANDLE hSession);
HANDLE OpenItem(HANDLE hSession, STRING itemID);
void CloseItem(HANDLE hItem);

加上对这些类型之一（Session或Item）有用的其他函数，并直接映射到相关对象的C ++成员函数。但这里不需要它们。我的主要兴趣在于构建和销毁这些对象，使用RAII来管理这些类的正确打开和关闭。

我设计课程的第一个想法是纯和直接RAII。包含的类接受一个容器对象作为构造函数参数。

class Session {
    HANDLE const m_hSession;
public:
    Session(STRING sessionID): m_hSession(OpenSession(sessionID)) {}
    ~Session() { CloseSession(m_hSession); }
};
class Item {
    HANDLE const m_hItem;
public:
    Item(HANDLE hSession, STRING itemID): m_hItem(OpenItem(hSession, itemID)) {}
    ~Item() { CloseItem(m_hItem); }
};

这种设计的缺点是允许不良行为：在破坏所有Item对象之前，可以破坏Session对象（并调用CloseSession函数）。这很烦人，因为它不应该发生。即使这种错误行为是可能的，因此无效，使用C API，我希望在C ++ API中通过设计来避免它。

这就是为什么我想知道如何使用以下设计，其中Session包含其Items（这显示了实际关系），并且是唯一能够构造和销毁Items的类。

class Item {
    HANDLE const m_hItem;
    Item(HANDLE hSession, STRING itemID): m_hItem(OpenItem(hSession, itemID) {}
    ~Item() { CloseItem(m_hItem); }
    friend class Session;
public:
};
class Session {
    HANDLE const m_hSession;
    typedef vector<Item *> VecItem;
    VecItem m_vecItem;
    Session(STRING sessionID): m_hSession(OpenSession(sessionID)) {}
    ~Session() {
        for (size_t n = 0 ; n < m_vecItem.size() ; ++n) delete m_vecItem[n];
        m_vecItem.clear();
        CloseSession(m_hSession);
        }
public:
    Item * OpenItem(STRING itemID) {
        Item *p = new Item(m_hSession, itemID);
        m_vecItem.push_back(p);
        return p;
        }
    void CloseItem(Item * item) {
        VecItem::iterator it = find(m_vecItem.begin(), m_vecItem.end(), item);
        if (it != m_vecItem.end()) {
            Item *p = *it; m_vecItem.erase(it); delete p;
            }
        }
};

在我看来，它是确保Session关闭之前没有关闭的唯一方法：在设计中反映Item对象是其成员会话，因此会在会议被销毁之前被破坏。

然而，对我来说这看起来有点奇怪，因为它在Session类的接口中留下了OpenItem和CloseItem这些函数。我正在寻找更多的RAII（对我而言，这意味着使用Item的构造函数），但无法设想一种封装它的方法，以确保正确的销毁顺序。

此外，使用指针，new和delete是太旧的世纪C ++。应该可以使用Item的向量（而不是Item *），代价是正确定义类Item的移动语义，但它的代价是允许Item的默认构造函数创建未初始化的第二类公民物品对象。

有更好的设计理念吗？

Answer 1

通过添加另一个图层（并使您的RAII更加明确），您可以获得非常整洁的东西。 Sessions和Items的默认复制构造函数和赋值是正确的。所有项目的HANDLE关闭后，会话的HANDLE将关闭。没有必要保留儿童的矢量，共享指针跟踪所有这些...所以我认为它应该做你需要的一切。

class SessionHandle
{
   explicit SessionHandle( HANDLE in_h ) : h(in_h) {}
   HANDLE h;
   ~SessionHandle() { if(h) CloseSession(h); }
};

class ItemHandle
{
   explicit ItemHandle( HANDLE in_h ) : h(in_h) {}
   HANDLE h;
   ~ItemHandle() { if(h) CloseItem(h); }
};

class Session
{
   explicit Session( STRING sessionID ) : session_handle( OpenSession(sessionID) )
   {
   }
   shared_ptr<SessionHandle> session_handle;
};

class Item
{
   Item( Session & s, STRING itemID ) : 
     item_handle( OpenItem(s.session_handle.get(), itemID ) ), 
     session_handle( s.session_handle )
   {
   }
   shared_ptr<ItemHandle> item_handle;
   shared_ptr<SessionHandle> session_handle;
};

Answer 2

我认为这是一个有趣的问题。

首先，对于RAII，您通常希望实现复制构造函数和赋值运算符，这里HANDLE const会阻止它们，但您真的想要无法复制的对象吗？并且最好也使它们异常安全。

此外，还存在id的问题：您是否必须确保其独特性或框架是否适合您？

修改：

自我的第一个答案以来，要求已经准确，即：

库已经实现了引用计数，不需要自己处理

在这种情况下，您有两种设计方案：

使用Observer模式：Item已链接回创建时Session，Session会在其死亡时通知它（使用会话管理器通过让会话管理员拥有会话并让Item向管理员查询其会话来实现自动化

使用@ Michael的方案，其中Item分享Session对象的所有权，以便Session无法销毁，而至少有一个Item仍然存在

我不太喜欢第二种解决方案，因为Session的生命周期很难跟踪：你无法可靠地杀死它。

另一方面，如你所说，第一个解决方案意味着存在空对象，这可能是不可接受的。

旧解决方案：

至于实际设计，我建议：

class Item { public: Item(): mHandle() {} Item(Session& session, std::string id): mHandle(session.CreateItem(id)) { } void swap(Item& rhs) { using std::swap; swap(mHandle, rhs.mHandle); } void reset() { mHandle.reset(); } /// Defensive Programming void do() { assert(mHandle.exists() && "do - no item"); // do } private: boost::weak_ptr<HANDLE const> mHandle; };

和Session类

class Session { public: private: typedef boost::weak_ptr<HANDLE const> weak_ptr; typedef boost::shared_ptr<HANDLE const> shared_ptr; typedef boost::unordered_map<std::string, shared_ptr> map_type; friend class Item; struct ItemDeleter { void operator()(HANDLE const* p) { CloseItem(*p); } }; weak_ptr CreateItem(std::string const& id) { map_type::iterator it = mItems.find(id); if (it != mItems.end()) return it->second; shared_ptr p = shared_ptr(new OpenItem(mHandle, id), ItemDeleter()); std::pair<map_type::iterator, bool> result = mItems(std::make_pair(id, p)); return result.first->second; } map_type mItems; HANDLE const mHandle; };

这传达了你要求的含义：

Session对象负责管理Item的生命周期，实际的Item对象只不过是句柄的代理

您的对象有确定性生命周期：只要Session死亡，所有HANDLE项都会被有效关闭

微妙的问题：这个代码在多线程应用程序中不安全，但后来我不知道我们是否需要完全序列化对OpenItem和CloseItem的访问，因为我不知道底层是否库是线程安全的。

请注意，在此设计中，无法复制Session对象。显然我们可以创建一个SessionManager对象（通常是一个单例，但这不是必需的）并让他以同样的方式管理Session：）

Answer 3

要扩展 STLSoft 的评论，请使用STLSoft的scoped_handle智能指针，如：

HANDLE hSession = OpenSession("session-X");
if(!hSession) {
 // Handle failure to open session
}
else {
  stlsoft::scoped_handle<HANDLE> session_release(hSession, CloseSession);

  HANDLE hItem = OpenItem(hSession, "item-Y");
  if(!hItem) {
     // Handle failure to open item
  }
  else {
      stlsoft::scoped_handle<HANDLE> item_release(hItem, CloseItem);

    // Use item
  }
}

如果“null”句柄值不为0，则执行以下操作：

if(hSession != -1) {
 // Handle failure to open session
}
else {
  stlsoft::scoped_handle<HANDLE> session_release(hSession, CloseSession, -1);

HTH

Answer 4

使用shared_ptr：http://www.boost.org/doc/libs/1_44_0/libs/smart_ptr/sp_techniques.html#handle

如何将C API封装到RAII C ++类中？

4 个答案: