Question

好的，这是一个奇怪的问题，我不确定是否有解决方案。

我有两个列表，比如客户列表和每个客户端的一些数据列表。我有兴趣将两个列表保存在两个单独的std::list中，因为我有一个用于提供客户列表的API，但我不想提供其余的数据。

但是，由于两个列表应该相互对齐，即每个列表中的元素n应该引用同一个客户端，我正在寻找一种方法来链接它们，这样一个列表的元素就不会能够添加/删除而不添加/删除其他列表中的相应元素，但仍然将它们保存在两个单独的列表中，以用于我提到的API目的。

有什么想法吗？

Answer 1

你可以做一个非常简单的封装

class TwoLists{
  ...
  void addNode(clientstuff a, datastuff b);
  void removeNode(int index);
  const std::list<clientstuff>& GetClientList();
private:
  std::list<clientstuff> clientList; 
  std::list<datastuff> datalist;
}

void TwoLists::addNode(clientstuff a, datastuff b);
{
  //add a to clientList, and add b to dataList
}

void TwoLists::removeNode(int n)
{
  //remove node n from both lists
}

const std::list<clientstuff>& TwoLists::GetClientList()
{
  return clientList;
}

Answer 2

如果你设计界面，我会继续把它们放在一个容器中，但是为用户提供只允许访问公共客户端部分的自定义迭代器。 boost::iterator_adaptor使得编写这种迭代器变得容易。

#include "Client.hpp"
#include <list>
#include <boost/iterator_adaptor.hpp>

class ClientList {
public:
    class iterator;
    class const_iterator;
    iterator begin();
    const_iterator begin() const;
    iterator end();
    const_iterator end() const;

private:
    struct InternalData {
        //...
    };
    struct ClientAndData {
        Client client;
        InternalData data;
    };
    typedef std::list<ClientAndData> internal_list_type;
    internal_list_type m_clients;
    friend class iterator;
    friend class const_iterator;
};

class ClientList::iterator
    : public boost::iterator_adaptor<
        ClientList::iterator,                     // Derived type for CRTP
        ClientList::internal_list_type::iterator  // Iter type to encapsulate 
        Client >                                  // Data type to expose
{
private:
    explicit iterator(const base_type& base_iter)
      : iterator_adaptor(base_iter) {}
    Client& dereference() const { return base()->client; }
    friend class ClientList;
    // Allow boost to call dereference():
    friend class boost::iterator_core_access;
};

class ClientList::const_iterator
    : public boost::iterator_adaptor<
        ClientList::const_iterator,
        ClientList::internal_list_type::const_iterator
        const Client >
{
public:
    const_iterator(const iterator& iter)
      : iterator_adaptor(iter.base()) {}
private:
    explicit const_iterator(const base_type& base_iter)
      : iterator_adaptor(base_iter) {}
    const Client& dereference() const { return base()->client; }
    friend class ClientList;
    friend class boost::iterator_core_access;
};

inline ClientList::iterator ClientList::begin()
{ return iterator(m_clients.begin()); }

inline ClientList::const_iterator ClientList::begin() const
{ return const_iterator(m_clients.begin()); }

inline ClientList::iterator ClientList::end()
{ return iterator(m_clients.end()); }

inline ClientList::const_iterator ClientList::end() const
{ return const_iterator(m_clients.end()); }

或者，如果您的代码的用户只应获得const Client&个引用，那么您只需要一个迭代器类型，它看起来大致类似于上面的const_iterator类。

此处没有复制Client个对象;用户获得对私有列表中相同对象的引用。

这确实在迭代器类型中公开了一个公共base()成员函数，有些人可以使用它来获取InternalData。但任何了解或发现base()的人都应该知道或者意识到他们不应该使用它。如果这令您担心，您可以私下继承iterator_adaptor，然后再次手动将其所有公共成员除 base()公开。或者（可能更容易），将InternalData中的所有内容设为私有或受保护，然后friend使用它的类{。}}。

将两个单独的std ::列表相互绑定

2 个答案: