Question

我有一个类似于以下类型的变量：

map<bool, map<string, pair<string, int> > > items;

我传递给不同的函数。

我是否有一种不那么繁琐的方式来迭代它然后说

for (map<bool, map<string, pair<string, int> > >::iterator p = items.begin();
    p != items.end(); p++)
    ...

每一次？（即我可以以某种方式省略类型名称，使用宏或模板或其他内容吗？手册typedef不计算在内。）

我正在使用Visual C ++ 2008。

Answer 1

您可以使用BOOST_FOREACH。为了清晰起见，你必须使用typedef：

typedef std::map<std::string, std::pair<std::string, int> > inner_map;
typedef std::pair<bool, inner_map> map_entry;

BOOST_FOREACH(map_entry& p, items)
{
    ...
}

我更喜欢普通typedef和for循环。我看到typedef与查看变量赋值的方式相同：

typedef std::map<std::string, std::pair<std::string, int> > inner_map;
typedef std::map<bool, inner_map>::iterator map_iterator;

for (map_iterator i = items.begin(); i != items.end(); ++i)
{
    ...
}

那些typedef也可以是私有成员。这种编码风格更加清晰，因为您可以一目了然地看到所涉及的类型。

如果您准备编写仿函数，也可以使用普通std::for_each。我在标准C ++中并不喜欢这个，因为循环体不再是本地的（但在某些情况下这可能是一个优势）：

struct some_functor
{
    template <typename K, typename V>
    void operator()(std::pair<K, V>& item)
    {
        // In the context below, K is bool and
        // V is map<string, pair<string, int> >
    }
};

然后再

std::for_each(items.begin(), items.end(), some_functor());

如果你升级到VS2010，你可以选择auto和std::for_each替换lambda（我更喜欢）。对于C ++ 0x，从技术上讲，您还有基于范围的for循环（在VS2010中不可用）。

总而言之，我会这样做：

class meaningful_data
{
    typedef std::map<std::string, std::pair<std::string, int> > inner_map;
    std::map<bool, inner_map> items;

public:
    typedef std::pair<bool, inner_map> value_type;
    typedef std::map<bool, inner_map>::iterator iterator;
    typedef std::map<bool, inner_map>::const_iterator const_iterator;

    iterator begin() { return items.begin(); }
    const_iterator begin() const { return items.begin(); }
    iterator end() { return items.end(); }
    const_iterator end() const { return items.end(); }

    // Add some interface here (as small as possible)
};

并像这样迭代：

for (meaningful_data::iterator i = d.begin(); i != d.end(); ++i)
{
    ...
}

或

BOOST_FOREACH(meaningful_data::value_type& i, d)
{
    ...
}

你可能想要封装这样一个复杂的类型，至少有一些typedef（如果inner_map类型应该是公共的，你不会被迫使用一个完整的类）。

Answer 2

我建议使用typedef，这可能是一种说“不，你不能”的方式;）

否则，如果您要切换到支持C ++ 0x中定义的auto的编译器，您可以说：

for (auto p = items.begin(); p != items.end(); ++p) // ...

（顺便说一下，我还建议++p避免复制迭代器）

Answer 3

您可以使用标准的for_each算法：

#include <algorithm>

struct your_functor {
  template<typename T>
  void operator()(T const &item) {
    // Your loop body here.
  }
}

std::for_each(items.begin(), items.end(), your_functor());

Answer 4

您可以使用BOOST_AUTO

Answer 5

您可以编写自己的算法函数。

template<class C>
void do_what_I_want_to_do(C& c)
{
    for (C::iterator i = c.begin(); i != c.end(); ++c)
    {
        // do something
    }
}

do_what_I_want_to_do(items);

这可能会或可能不会对您有所改善。

Answer 6

当然，请使用typedef：

typedef std::map<std::string, std::pair<std::string, int> > Item;
typedef Item::const_iterator                                ItemCItr;

typedef std::map<bool, Item>                                ItemMap;
typedef ItemMap::const_iterator                             ItemMapItr;

for (ItemMapItr it = m.begin(), end = m.end(); it != end; ++it)
{
  const Item & item = it->second;

  for (ItemItr jt = item.begin(), jend = item.end(); jt != jend; ++jt)
  {
     /* ... */
  }
}

Answer 7

在看到所有“你不能做到这一点”的答案后，我花了一些时间试图找到至少一个部分的解决方法。

此版本几乎有效，但需要注意的是对迭代器的每个引用也需要对容器的引用。实际使用它可能不是一个好主意（因为堆分配和其他事情），但我认为无论如何我都会分享它：

#include <map>
#include <iostream>
using namespace std;

template<typename T>
bool _end(T& src, void *iterator = NULL)
{ return static_cast<typename T::iterator>(iterator) < src.end(); }

template<typename T>
struct _IterateHelper
{
    typename T::iterator *pIterator;
    _IterateHelper(T& dummy, void *&p)
    { this->pIterator = static_cast<typename T::iterator *>(p); }
    ~_IterateHelper() { delete pIterator; }
};

template<typename T>
_IterateHelper<T> _iterateHelper(T& dummy, void *&p)
{ return _IterateHelper<T>(dummy, p); }

template<typename T>
bool _iterate(T& container, void *&iterator)
{
    typename T::iterator *&p =
        reinterpret_cast<typename T::iterator *&>(iterator);
    if (iterator == NULL) { p = new typename T::iterator(container.begin()); }
    else { ++*p; }
    return *p != container.end();
}

template<typename T>
typename T::iterator & I(T& container, void *&pIterator)
{ return *static_cast<typename T::iterator *>(pIterator); }

#define FOR_EACH(state, container) \
    void *state = NULL; \
    for (_iterateHelper(container, state); _iterate(container, state); )


int main()
{
    map<string, string> m;
    items["a"] = "b";
    items["1"] = "2";
    FOR_EACH(p, items)
        cout << I(items, p)->first << ": " << I(items, p)->second << endl;
}

Answer 8

Qt提供了自己的foreach实现，所以我只是为std :: map重做它 - 基本上只是一个简单的修改（ - ＆gt; second）。在MSVC和gcc上测试。

struct ForeachBaseBase {};

template <typename T1, typename T2>
class ForeachBase: public ForeachBaseBase
{
public:
    inline ForeachBase(const std::map<T1,T2>& t): c(t), brk(0), i(c.begin()), e(c.end()){}
    const std::map<T1,T2> c;
    mutable int brk;
    mutable typename std::map<T1,T2>::const_iterator i, e;
    inline bool condition() const { return (!brk++ && i != e);}
};

template <typename T1, typename T2> inline std::map<T1,T2> *pMForeachPointer(const std::map<T1,T2> &) { return 0; }

template <typename T1, typename T2> inline ForeachBase<T1,T2> pMForeachBaseNew(const std::map<T1,T2>& t)
{ return ForeachBase<T1,T2>(t); }

template <typename T1, typename T2>
inline const ForeachBase<T1,T2> *pMForeachBase(const ForeachBaseBase *base, const std::map<T1,T2> *)
{ return static_cast<const ForeachBase<T1,T2> *>(base); }


#if defined(Q_CC_MIPS)
/*
   Proper for-scoping in MIPSpro CC
*/
#  define MAP_FOREACH(variable,container)                                                             \
    if(0){}else                                                                                     \
    for (const ForeachBaseBase &_container_ = pMForeachBaseNew(container);                \
         pMForeachBase(&_container_, true ? 0 : pMForeachPointer(container))->condition();       \
         ++pMForeachBase(&_container_, true ? 0 : pMForeachPointer(container))->i)               \
        for (variable = pMForeachBase(&_container_, true ? 0 : pMForeachPointer(container))->i->second; \
             pMForeachBase(&_container_, true ? 0 : pMForeachPointer(container))->brk;           \
             --pMForeachBase(&_container_, true ? 0 : pMForeachPointer(container))->brk)

#elif defined(Q_CC_DIAB)
// VxWorks DIAB generates unresolvable symbols, if container is a function call
#  define MAP_FOREACH(variable,container)                                                             \
    if(0){}else                                                                                     \
    for (const ForeachBaseBase &_container_ = pMForeachBaseNew(container);                \
         pMForeachBase(&_container_, (__typeof__(container) *) 0)->condition();       \
         ++pMForeachBase(&_container_, (__typeof__(container) *) 0)->i)               \
        for (variable = pMForeachBase(&_container_, (__typeof__(container) *) 0)->i->second; \
             pMForeachBase(&_container_, (__typeof__(container) *) 0)->brk;           \
             --pMForeachBase(&_container_, (__typeof__(container) *) 0)->brk)

#else
#  define MAP_FOREACH(variable, container) \
    for (const ForeachBaseBase &_container_ = pMForeachBaseNew(container); \
         pMForeachBase(&_container_, true ? 0 : pMForeachPointer(container))->condition();       \
         ++pMForeachBase(&_container_, true ? 0 : pMForeachPointer(container))->i)               \
        for (variable = pMForeachBase(&_container_, true ? 0 : pMForeachPointer(container))->i->second; \
             pMForeachBase(&_container_, true ? 0 : pMForeachPointer(container))->brk;           \
             --pMForeachBase(&_container_, true ? 0 : pMForeachPointer(container))->brk)
#endif // MSVC6 || MIPSpro

#define mforeach MAP_FOREACH

迭代std :: map＆lt; ...＆gt ;?的简便方法

8 个答案: