2-dimensional container i STL?

Det nærmeste du kommer er mig bekendt et map, men jeg er ikke helt sikker på om den har den funktionalitet som du søger. En map fungerer således at det første objekt er din nøgle og det andet din værdi, hvor du efterfølgende kan foretage nogle hurtige opslag og søgninger på din nøgle.

template<class Key, class T, class Pred = less<Key>, class A = allocator<T> >
    class map {
public:
    typedef Key key_type;
    typedef T referent_type;
    typedef Pred key_compare;
    typedef A allocator_type;
    typedef pair<const Key, T> value_type;
    class value_compare;
    typedef A::size_type size_type;
    typedef A::difference_type difference_type;
    typedef A::rebind<value_type>::other::reference reference;
    typedef A::rebind<value_type>::other::const_reference const_reference;
    typedef T0 iterator;
    typedef T1 const_iterator;
    typedef reverse_bidirectional_iterator<iterator,
        value_type, reference, A::pointer,
            difference_type> reverse_iterator;
    typedef reverse_bidirectional_iterator<const_iterator,
        value_type, const_reference, A::const_pointer,
            difference_type> const_reverse_iterator;
    explicit map(const Pred& comp = Pred(), const A& al = A());
    map(const map& x);
    map(const value_type *first, const value_type *last,
        const Pred& comp = Pred(),
            const A& al = A());
    iterator begin();
    const_iterator begin() const;
    iterator end();
    iterator end() const;
    reverse_iterator rbegin();
    const_reverse_iterator rbegin() const;
    reverse_iterator rend();
    const_reverse_iterator rend() const;
    size_type size() const;
    size_type max_size() const;
    bool empty() const;
    A get_allocator() const;
    A::reference operator[](const Key& key);
    pair<iterator, bool> insert(const value_type& x);
    iterator insert(iterator it, const value_type& x);
    void insert(const value_type *first, const value_type *last);
    iterator erase(iterator it);
    iterator erase(iterator first, iterator last);
    size_type erase(const Key& key);
    void clear();
    void swap(map x);
    key_compare key_comp() const;
    value_compare value_comp() const;
    iterator find(const Key& key);
    const_iterator find(const Key& key) const;
    size_type count(const Key& key) const;
    iterator lower_bound(const Key& key);
    const_iterator lower_bound(const Key& key) const;
    iterator upper_bound(const Key& key);
    const_iterator upper_bound(const Key& key) const;
    pair<iterator, iterator> equal_range(const Key& key);
    pair<const_iterator, const_iterator>
        equal_range(const Key& key) const;
protected:
    A allocator;
    };

Alternativt kan du lave et objekt som er ansvarlig for at opretholde de to dimensioner og gemme det objekt i din vector.

class ItemPair
{
public:
int first;
int second;
};

std::vector<ItemPair*> _minListe;

På denne måde har du en meget mere fleksibel struktur, og du kan eventuelt lave method overloading, så du direkte kan sammenligne elementerne i listen for eksempel ved at lade den første "dimension" (som er first variablen i mit eksempel) være din nøgle.

class ItemPair
{
public:
int first;
CMyClass * second;
};

std::vector<ItemPair*> _minListe;

Din anden dimension kan så (imodsætning til et to-dimensionelt array, int array[][]) være af vilkårlig type afhængig af definitionen på dit ItemPair.

Hth

Du laver bare en std::vector af std::vector af whatever:

std::vector<std::vector<whatever > >Int2dVector;

Elller list af list eller ...

FFI: http://damb.dk/container.php

Tak skal I have, begge to. Min ide er at lave en enkel model af et landkort, delt op i kvadratiske felter, med udbredelsen af forskellige geografiske parametre defineret i hvert felt - jeg tror konceptet med en vector af vector will do the trick, idet jeg skal bruge random access.
Det er super at have udvikleren.dk i baghånden til sådan noget her

Da Bertel har skrevet med en kommentar giver jeg alle UP'ene til Jess. Mange tak!