STL容器 list、vector、map、set 使用的陷阱

STL容器 list、vector、map、set 使用的陷阱

#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <set>

using namespace std;

void printList(list<int>& l, const char* info)
{
    cout << "list values: " << info;
    list<int>::iterator it;
    for (it = l.begin(); it != l.end(); ++it)
    {
        if (it != l.begin()) cout << ", ";
        cout << *it;
    }
    cout << endl;
}

void printVector(vector<int>& v, const char* info)
{
    cout << "vector values: " << info;
    vector<int>::iterator it;
    for (it = v.begin(); it != v.end(); ++it)
    {
        if (it != v.begin()) cout << ", ";
        cout << *it;
    }
    cout << endl;
}

void printMap(map<int, int>& m, const char* info)
{
    cout << "map values: " << info;
    map<int, int>::iterator it;
    for (it = m.begin(); it != m.end(); ++it)
    {
        if (it != m.begin()) cout << ", ";
        cout << "(" << it->first << ", " << it->second << ")";
    }
    cout << endl;
}

void printSet(set<int>& s, const char* info)
{
    cout << "set values: " << info;
    set<int>::iterator it;
    for (it = s.begin(); it != s.end(); ++it)
    {
        if (it != s.begin()) cout << ", ";
        cout << *it;
    }
    cout << endl;
}

void vectorErase()
{
    cout << "\n====================== vector erase ======================" << endl;
    vector<int> v;

    // initialize
    for (int i = 0; i < 5; ++i) {
        v.push_back(i);
    }

    // erase with iterator
    printVector(v, "Before erase with iterator: ");
    vector<int>::iterator vit;
    for (vit = v.begin(); vit != v.end();)
    {
        if (0 == (*vit) % 2) {
            vit = v.erase(vit);
        }
        else {
            ++vit;
        }
    }
    printVector(v, "After erase with iterator: ");

    // reset
    v.clear();
    for (int i = 0; i < 5; ++i) {
        v.push_back(i);
    }

    // erase with reverse_iterator
    printVector(v, "Before erase with reverse_iterator: ");
    vector<int>::reverse_iterator vrit;
    for (vrit = v.rbegin(); vrit != v.rend();)
    {
        if (0 == (*vrit) % 2) {
            vrit = vector<int>::reverse_iterator(v.erase((++vrit).base()));
        }
        else {
            ++vrit;
        }
    }
    printVector(v, "After erase with reverse_iterator: ");
}

void listErase()
{
    cout << "\n====================== list erase ======================" << endl;
    list<int> l;

    // initialize
    for (int i = 0; i < 5; ++i) {
        l.push_back(i);
    }

    // erase with iterator
    printList(l, "Before erase with iterator: ");
    list<int>::iterator it;
    for (it = l.begin(); it != l.end();)
    {
        if (0 == (*it) % 2) {
            it = l.erase(it);
        }
        else {
            ++it;
        }
    }
    printList(l, "After erase with iterator: ");

    // reset
    l.clear();
    for (int i = 0; i < 5; ++i) {
        l.push_back(i);
    }

    // erase with reverse_iterator
    printList(l, "Before erase with reverse_iterator: ");
    list<int>::reverse_iterator rit;
    for (rit = l.rbegin(); rit != l.rend();)
    {
        if (0 == (*rit) % 2) {
            rit = list<int>::reverse_iterator(l.erase((++rit).base()));
            //rit = list<int>::reverse_iterator(l.erase(--(rit.base()));
        }
        else {
            ++rit;
        }
    }
    printList(l, "After erase with reverse_iterator: ");
}

void mapErase()
{
    cout << "\n====================== map erase ======================" << endl;
    map<int, int> m;

    // initialize
    for (int i = 0; i < 5; ++i) {
        m[i] = i;
    }

    // erase with iterator
    printMap(m, "Before erase with iterator: ");
    map<int, int>::iterator mit;
    for (mit = m.begin(); mit != m.end();)
    {
        if (0 == mit->first % 2) {
            m.erase(mit++);
        }
        else {
            ++mit;
        }
    }
    printMap(m, "After erase with iterator: ");

    // reset
    m.clear();
    for (int i = 0; i < 5; ++i) {
        m[i] = i;
    }

    // erase with reverse_iterator
    printMap(m, "Before erase with reverse_iterator: ");
    map<int, int>::reverse_iterator rit;
    for (rit = m.rbegin(); rit != m.rend();)
    {
        if (0 == rit->first % 2) {
            m.erase((++rit).base());
        }
        else {
            ++rit;
        }
    }
    printMap(m, "After erase with reverse_iterator: ");
}

void setErase()
{
    cout << "\n====================== set erase ======================" << endl;
    set<int> s;

    // initialize
    for (int i = 0; i < 5; ++i) {
        s.insert(i);
    }

    // erase with iterator
    printSet(s, "Before erase with iterator: ");
    set<int>::iterator sit;
    for (sit = s.begin(); sit != s.end();)
    {
        if (0 == (*sit) % 2) {
            s.erase(sit++);
        }
        else {
            ++sit;
        }
    }
    printSet(s, "After erase with iterator: ");

    // reset
    s.clear();
    for (int i = 0; i < 5; ++i) {
        s.insert(i);
    }

    // erase with reverse_iterator
    printSet(s, "Before erase with reverse_iterator: ");
    set<int>::reverse_iterator rit;
    for (rit = s.rbegin(); rit != s.rend();)
    {
        if (0 == (*rit) % 2) {
            s.erase((++rit).base());
        }
        else {
            ++rit;
        }
    }
    printSet(s, "After erase with reverse_iterator: ");
}

int main()
{
    vectorErase();
    listErase();
    mapErase();
    setErase();
    return 0;
}