如何隐藏 API 中的迭代器以使用 std::map 包装器中的项目

Question

在一个 c++98 项目中，我有一个 class Items 包装了一个 std::map:

#include <string>
#include <map>

class Item { /* ... */ }; // Some class holding some data

class Items
{
 public:
    typedef std::map<std::string,Item> container_type;
    typedef container_type::iterator iterator;

    Items() {}

    iterator find(const String& k) { return i_map.find(k); }
    iterator end() { return i_map.end(); }
    void erase(iterator i) { i_map.erase(i); }
    // ...

 private:
    container_type i_map;
};

它的主要用途是搜索某个Item，如果找到就使用并删除它。第一个明显的 API 我建议消费一个项目是这个：

Items items;
Items::iterator i = items.find("some-id");
if( i!=items.end() )
   {
    const Item& item = i->second; // Get and use the item
    items.erase(i); // Item consumed: remove it from items
   }

...但是我被要求隐藏 class API 中的 iterator 和 pair 的概念。为了满足这个新要求，第一个想法是在内部存储一个迭代器 i_found 以记住最后找到的项目：

#include <stdexcept>
#include <string>
#include <map>

class Item { /* ... */ }; // Some class holding some data

class Items
{
 public:
    typedef std::map<std::string,Item> container_type;
    typedef container_type::iterator iterator;

    Items() : i_found( i_map.end() ) {}

    #define should_be_const // const // Unfortunately 'i_found' must be a non const 'iterator' in order to be erased

    bool contains(const std::string& k) should_be_const
       {
        i_found = i_map.find(k);
        return i_found!=i_map.end();
       }

    const Item& get(const std::string& k) should_be_const
       {
        if(i_found==i_map.end() || k!=i_found->first) i_found = i_map.find(k); // search if necessary
        if(i_found!=i_map.end()) return i_found->second;
        else throw std::runtime_error("key \'" + std::string(k) + "\' not found!");
       }

    void erase_found()
       {
        i_map.erase(i_found);
        i_found = i_map.end(); // invalidate last find
       }

 private:
    container_type i_map;
    mutable iterator i_found; // Last found item
};

这样就可以写成：

Items items;
if( items.contains("some-id") )
   {
    const Item& item = items.get("some-id"); // Get and use the item
    items.erase_found(); // Item used: remove it from items
   }

我知道这是否是一种改进是值得商榷的，我不是在问这个（是的，我也不喜欢它）。在最后一个实现中有没有办法使方法 contains() 和 get() const?

鉴于上述要求，我也对有关不同方法的建议感兴趣。虽然 Item 复制构造是可以接受的，但如果未找到“some-id”，我想避免构造一个 item，因为在这个替代方案中我拼命尝试：

bool Items::extract_if_present(const std::string& k, Item& item)
   {
    iterator i = i_map.find(k);
    if( i != i_map.end() )
       {
        item = i->second;
        i_map.erase(i);
        return true;
       }
    return false;
   }

Item item; // <-- Avoidable useless work if not found
if( items.extract_if_present("some-id", item) )
   {
    //item; // Use the copied item
   }

Answer 1

使用 optional（不是标准，它是 C++17，但可以在 C++98 中完成（例如使用 boost）），那么您可能在接口

optional<Item> get(const std::string&) const;
optional<Item> extract(const std::string&);

用法类似于：

Items items;
// ...
if (optional<Item> item = items.extract("some-id"))
{
    // use *item;
}

Answer 2

因为如果找不到密钥你就会抛出，你可以有一个比map更简单的界面。

class Items
{
 public:
    // do these need to be public?
    typedef std::map<std::string, Item> container_type;
    typedef container_type::iterator iterator;

    bool contains(const std::string& k) const
       {
        return i_map.find(k)!=i_map.end();
       }

    const Item& get(const std::string& k) const
       {
        iterator i_found = i_map.find(k);
        if(i_found!=i_map.end()) return i_found->second;
        else throw std::runtime_error("key \'" + k + "\' not found!");
       }

    Item extract(const std::string& k)
       {
        iterator i_found = i_map.find(k);
        if(i_found!=i_map.end()) 
           {
            Item temp = i_found->second;
            map.erase(i_found);
            return temp;
           }
        else throw std::runtime_error("key \'" + k + "\' not found!");
       }

 private:
    container_type i_map;
};

如果移动到 C++11，提取可以移动而不是复制。

如何隐藏 API 中的迭代器以使用 std::map 包装器中的项目

How to hide iterators in the API to consume an item in a std::map wrapper

c++

stl

api-design

stdmap

c++98