Question

我想创建一个实际使用固定密钥集的自定义地图，但其行为应该像std::map。基本上我在内部使用数组并将键映射到索引，从而实现非常有效的查找。然而，我正在努力实现类似于std::map迭代器的迭代器，因为我没有可以分发引用的内部std::pair。

是否可以在保留std::map接口，特别是迭代器的同时将其实现为零开销抽象？

operator*可以提出的最好的方法是返回一个右值std::pair<key_type, mapped_type*>，它基本上允许相同的操作，但不幸的是有不同的使用模式。

我也尝试了std::pair<key_type, boost::referene_wrapper<mapped_type>>，但仍然不允许for(auto& elem : map)，并且由于我不理解的原因，通常需要elem.second.get()。

我很高兴使用boost或轻量级头库，如果有任何有用的用例。

为了说明这种情况，这里有一个最小的例子，其中的地图包含所有字母＆＃39; a＆＃39; - ＆＃39; z＆＃39;。

using letter = char;
static const letter letter_begin = 'a';
static const letter letter_end = 'z' + 1;

template <typename T>
class letter_map
{
private:
    using self = letter_map<T>;

    template <typename IT, typename M>
    class iterator_base : public std::iterator<std::input_iterator_tag, T>
    {
    public:
        iterator_base(letter index, M& map) : index_(index), data_(map)
        {
        }

        using self_iter = iterator_base<IT, M>;
        IT operator*()
        {
            return IT(index_, &data_[index_]);
        }

        self_iter& operator++()
        {
            index_++;
            return *this;
        }

        self_iter operator++(int)
        {
            self_iter tmp(*this);
            operator++();
            return tmp;
        }

        bool operator==(self_iter other) const
        {
            assert(&data_ == &other.data_);
            return index_ == other.index_;
        }

        bool operator!=(self_iter other) const
        {
            return !(*this == other);
        }

    private:
        letter index_;
        M& data_;
    };

public:
    using key_type = letter;
    using mapped_type = T;
    using value_type = std::pair<const key_type, mapped_type*>;
    using const_value_type = std::pair<const key_type, const mapped_type*>;

private:
    static const size_t data_size = letter_end - letter_begin;
    using container_type = std::array<mapped_type, data_size>;

public:
    using iterator = iterator_base<value_type, self>;
    using const_iterator = iterator_base<const_value_type, const self>;

public:
    mapped_type& operator[](letter l)
    {
        return data_[l - letter_begin];
    }

    const mapped_type& operator[](letter l) const
    {
        return data_[l - letter_begin];
    }

    auto begin()
    {
        return iterator(letter_begin, *this);
    }

    auto end()
    {
        return iterator(letter_end, *this);
    }

    auto begin() const
    {
        return const_iterator(letter_begin, *this);
    }

    auto end() const
    {
        return const_iterator(letter_end, *this);
    }

private:
    container_type data_;
};

void print_string_letter_map(const letter_map<std::string>& lm)
{
    for (auto elem : lm)
    {
        std::cout << elem.first << "->" << *(elem.second) << std::endl;
    }
}

template<typename T>
class std_letter_map : public std::map<letter, T>
{
public:
    std_letter_map()
    {
        for (letter l = letter_begin; l != letter_end; ++l) {
            this->emplace(l, T());
        }
    }
};

void print_string_std_letter_map(const std_letter_map<std::string>& lm)
{
    for (const auto& elem : lm)
    {
        std::cout << elem.first << "->" << elem.second << std::endl;
    }
}

int main()
{
    letter_map<std::string> lm;
    // usually I would use auto& elem here
    for (auto elem : lm) {
        auto let = elem.first;
        // usually this would be without the *
        auto& str = *(elem.second);
        str = std::string("foo ") + let;
    }
    print_string_letter_map(lm);
    return 0;
}

Answer 1

实现operator *很简单 - 只需为const迭代器返回std::pair<const Key, Value&>或..., Value const&>，就像在这个简化示例中一样：

template <typename T>
class iterator_array_as_map
{
public:

    iterator_array_as_map(T* array, int index) 
       : array(array), index(index) 
    {}

    bool operator == (const iterator_array_as_map& other) const
    {
        return index == other.index;
    }
    bool operator != (const iterator_array_as_map& other) const
    {
        return index != other.index;
    }
    iterator_array_as_map& operator ++ ()
    {
        ++index;
        return *this;
    }

    auto operator * ()
    {
        return std::pair<const int, T&>(index, array[index]);
    }


private:
    T* array;
    int index;
};

用法：

int main() {
    int array[2] = {2, 4};
    auto begin = iterator_array_as_map<int>(array, 0);
    auto end = iterator_array_as_map<int>(array, 2);

    for (auto it = begin; it != end; ++it)
    {
        std::cout << (*it).first << " " << (*it).second << std::endl;
     }

    (*begin).second = 7;

    for (auto it = begin; it != end; ++it)
    {
        std::cout << (*it).first << " " << (*it).second << std::endl;
    }
}

operator ->有点困难 - 因为你必须返回需要模仿pointer to std::pair的东西 - 但如果不介意动态内存碎片 - 你可以返回std::shared_ptr<std::pair<....>> ...

    auto operator -> ()
    {
        return std::make_shared<std::pair<const int, T&>>(index, array[index]);
    }

如果您不想使用动态内存 - 那么您可以尝试使用指向自身解决方案的指针：

template<typename data>    
class pointer_to_data
{
public:
    template<typename ...Arg>
    pointer_to_data(Arg&&... arg)
      : data{std::forward<Arg>(arg)...}
    {}
    Data* operator -> ()
    {
        return &data;
     }
  private:
      Data data;
  };

只需返回上面的内容而不是shared_ptr ...

请参阅此what-is-the-correct-way-of-using-c11s-range-based-for，“代理迭代器的特例”部分。如果for(auto&e:b)是{1}}，则无法定义b。 std::vector<bool> - 因为通常不可能引用临时，这个容器在这个意义上与你的容器类似，它具有“特殊”引用类型。

你可以尝试在你的迭代器中保留特殊成员来保持“返回值” - 但这会很麻烦 - 因此，我提出的解决方案存在的情况可能并不好。

Answer 2

You could probably use zip_view from Eric Niebler's range library https://github.com/ericniebler/range-v3

为不使用元组的自定义映射模拟std :: map迭代器

2 个答案: