CopperSpice API  1.7.2
QMap< Key, Val, C >::iterator Class Reference

STL style iterator for QMap. More...

Public Typedefs

using iterator_category = std::bidirectional_iterator_tag
 
using pointer = Val *
 
using reference = Val &
 
using size_type = typename std::map< Key, Val, C >::difference_type
 

Public Methods

 iterator () = default
 
const Key & key () const
 
bool operator!= (iterator other) const
 
Val & operator* () const
 
iterator operator+ (size_type n) const
 
iterator & operator++ ()
 
iterator operator++ (int)
 
iterator & operator+= (size_type n)
 
iterator operator- (size_type n) const
 
iterator & operator-- ()
 
iterator operator-- (int)
 
iterator & operator-= (size_type n)
 
Val * operator-> () const
 
bool operator== (iterator other) const
 
std::pair< const Key, Val > & pair () const
 
Val & value () const
 

Friends

class QMap< Key, Val, C >
 

Detailed Description

template<typename Key, typename Val, typename C>
class QMap< Key, Val, C >::iterator

The QMap::iterator class provides an STL style iterator for QMap. QMap features both STL style iterators and Java style iterators.

QMap::const_iterator allows you to iterate over a QMap. If you want to modify the QMap as you iterate over it use QMap::iterator instead.

After construction you must initialize the iterator using a method like QMap::constBegin(), QMap::constEnd(), or QMap::find() before you can start iterating.

The following is an example which prints all the (key, value) pairs stored in the map.

map.insert("January", 1);
map.insert("February", 2);
...
map.insert("December", 12);
for (auto iter = map.constBegin(); iter != map.constEnd(); ++iter) {
cout << iter.key() << ": " << iter.value() << endl;
}

Unlike QHash which stores its items in an arbitrary order, QMap stores its items ordered by key.

The following is an example which increments every value stored in the QMap by 2:

for (iter = map.begin(); iter != map.end(); ++iter) {
iter.value() += 2;
}

Here is an example which removes all the items whose key is a string that starts with an underscore character:

while (iter != map.end()) {
if (iter.key().startsWith("_")) {
iter = map.erase(iter);
} else {
++iter;
}
}

The call to QMap::erase() removes the item pointed to by the iterator from the map and returns an iterator to the next item. Here is another way of removing an item while iterating:

while (iter != map.end()) {
++iter;
if (prev.key().startsWith("_")) {
map.erase(prev);
}
}

It might be tempting to write code like the following. This code will potentially crash in ++iter, because iter is invalid after the call to erase().

// INCORRECT
while (iter != map.end()) {
if (iter.key().startsWith("_")) {
map.erase(iter);
}
++iter;
}
See also
QMap::const_iterator

Member Typedef Documentation

template<typename Key , typename Val , typename C >
QMap< Key, Val, C >::iterator::iterator_category

A synonym for std::bidirectional_iterator_tag indicating this iterator is a bidirectional iterator.

template<typename Key , typename Val , typename C >
QMap< Key, Val, C >::iterator::pointer

A synonym for value_type *.

template<typename Key , typename Val , typename C >
QMap< Key, Val, C >::iterator::reference

A synonym for value_type &.

template<typename Key , typename Val , typename C >
QMap< Key, Val, C >::iterator::size_type

A synonym for the native size type of this container.

Constructor & Destructor Documentation

template<typename Key , typename Val , typename C >
QMap< Key, Val, C >::iterator::iterator ( )
default

Constructs an uninitialized iterator.

Methods like key(), value(), and operator++() must not be called on an uninitialized iterator. Use operator=() to assign a value to it before using it.

See also
QMap::begin(), QMap::end()

Method Documentation

template<typename Key , typename Val , typename C >
const Key & QMap< Key, Val, C >::iterator::key ( ) const
inline

Returns the current item's key as a const reference.

There is no direct way of changing an item's key through an iterator, although it can be done by calling QMap::erase() followed by QMap::insert().

See also
value()
template<typename Key , typename Val , typename C >
bool QMap< Key, Val, C >::iterator::operator!= ( iterator  other) const
inline

Returns true if other points to a different item than this iterator, otherwise it returns false.

See also
operator==()
template<typename Key , typename Val , typename C >
Val & QMap< Key, Val, C >::iterator::operator* ( ) const
inline

Equivalent to calling value().

See also
key()
template<typename Key , typename Val , typename C >
iterator QMap< Key, Val, C >::iterator::operator+ ( size_type  n) const
inline

Returns an iterator to the item at n positions forward from this iterator. If n is negative the iterator goes backward.

This operation can be slow for large values of n.

See also
operator-()
template<typename Key , typename Val , typename C >
iterator & QMap< Key, Val, C >::iterator::operator++ ( )
inline

The prefix ++ operator (++i) advances the iterator to the next item in the map and returns an iterator to the new current item.

Calling this method on QMap::end() leads to undefined behavior.

See also
operator--()
template<typename Key , typename Val , typename C >
iterator QMap< Key, Val, C >::iterator::operator++ ( int  )
inline

The postfix ++ operator (i++) advances the iterator to the next item in the map and returns an iterator to the previously current item.

template<typename Key , typename Val , typename C >
iterator & QMap< Key, Val, C >::iterator::operator+= ( size_type  n)
inline

Advances the iterator by n items. If n is negative the iterator goes backward.

See also
operator-=(), operator+()
template<typename Key , typename Val , typename C >
iterator QMap< Key, Val, C >::iterator::operator- ( size_type  n) const
inline

Returns an iterator to the item at n positions backward from this iterator. If n is negative, the iterator goes forward.

This operation can be slow for large values of n.

See also
operator+()
template<typename Key , typename Val , typename C >
iterator & QMap< Key, Val, C >::iterator::operator-- ( )
inline

The prefix – operator (–i) makes the preceding item current and returns an iterator pointing to the new current item.

Calling this method on QMap::begin() leads to undefined behavior.

See also
operator++()
template<typename Key , typename Val , typename C >
iterator QMap< Key, Val, C >::iterator::operator-- ( int  )
inline

The postfix – operator (i–) makes the preceding item current and returns an iterator pointing to the previously current item.

template<typename Key , typename Val , typename C >
iterator & QMap< Key, Val, C >::iterator::operator-= ( size_type  n)
inline

Makes the iterator go back by n items. If n is negative the iterator goes forward.

See also
operator+=(), operator-()
template<typename Key , typename Val , typename C >
Val * QMap< Key, Val, C >::iterator::operator-> ( ) const
inline

Returns a pointer to the current item's value.

See also
value()
template<typename Key , typename Val , typename C >
bool QMap< Key, Val, C >::iterator::operator== ( iterator  other) const
inline

Returns true if other points to the same item as this iterator, otherwise it returns false.

See also
operator!=()
template<typename Key , typename Val , typename C >
std::pair< const Key, Val > & QMap< Key, Val, C >::iterator::pair ( ) const
inline

Returns the current item's key and value as a pair.

template<typename Key , typename Val , typename C >
Val & QMap< Key, Val, C >::iterator::value ( ) const
inline

Returns a reference to the value of the current item. You can change the value of an item by using value() on the left side of an assignment.

if (i.key() == "Hello") {
i.value() = "Bonjour";
}
See also
key(), operator*()