C++ container der allokerer hukommelse i klumper

list<vector<T>> med en tynd wrapper omkring ?

Ja, noget i den stil. Med en fast størrelse for de indvendige vectors, forestiller jeg mig.
Sagen er at jeg tilføjer elementer enkeltvis og ved ikke fra starten hvor mange der er. Til sidst skal jeg blot løbe igennem dem alle en enkelt gang.

Det skulle findes i STL

vector<T,Allocator<T> >

hvor du så skal skrive din egen allocator eller finde en passende standard at bruge.

se om http://www.cplusplus.com/reference/stl/vector/vector.html giver mening for dig.

Simpelt eksempel:

#include <iostream>
#include <vector>

using namespace std;

template<class T, int chunksize>
class VecVec
{
    private:
        vector< vector<T> > data;
        int n;
    public:
        VecVec()
        {
            n = 0;
        }
        void add(T o)
        {
            if(n % chunksize == 0)
            {
                data.push_back(vector<T>());
                data[n / chunksize].reserve(chunksize);
            }
            data[n / chunksize].push_back(o);
            n++;
        }
        T get(int ix)
        {
            return data[ix / chunksize][ix % chunksize];
        }
        int size()
        {
            return n;
        }
};

int main()
{
    VecVec<int,3> vv;
    for(int i = 0; i < 7; i++)
    {
        vv.add(i);
    }
    for(int i = 0; i < vv.size(); i++)
    {
        cout << vv.get(i) << endl;
    }
    return 0;
}

API bør nok laves lidt mere STL agtigt, men ideeen må fremgå.

segmose>

Vil en allocator ikke bare blive kaldt hver gang vector skal udvides ?

@segmose: Jeg mener heller ikke at jeg kan klare det ved at implementere en ny allocator. Den vil stadig af vectoren blive sat til at allokere alt hukommelse på ny, hvis vectoren udvides.

@arne_v: Lige præcis. Klassen VecVec er præcis hvad jeg har brug for, og nu har du jo gjort arbejdet, så jeg kan jo selvfølgelig blot kopiere ovenstående, men jeg tænkte om der ikke fandtes en standard-klasse, der gør det samme. Jeg tror dog at jeg vil bruge en STL-list yderst i data, da man ellers risikerer at alt data skal kopieres, hvis den yderste vector skal udvides. Alternativt kunne man opbevare pointers (til vectors) i den yderste vector. Læg et svar, så uddeler jeg point.

Jeg er stadig interesseret i at høre om der er nogen, der har kendskab til en standard implementering af det arne_v foreslår ovenfor.

Jep. list<vector<T>> var jo også hvad jeg startede med.

Her er zweiter verbesserte udgave:

#include <iostream>
#include <list>
#include <vector>

using namespace std;

template<class T, int chunksize>
class ListVec
{
    private:
        list< vector<T> > data;
    public:
        void add(T o)
        {
            if(data.size() == 0 || data.back().size() % chunksize == 0)
            {
                data.push_back(vector<T>());
                data.back().reserve(chunksize);
            }
            data.back().push_back(o);
        }
        T& get(int ix)
        {
            typename list< vector<T> >::iterator it = data.begin();
            for(int i = 0; i < ix/chunksize; i++) it++;
            return (*it)[ix % chunksize];
        }
        T& operator[](int ix)
        {
            return get(ix);
        }
        int size()
        {
            return (data.size() - 1) * chunksize + data.back().size();
        }
};

int main()
{
    ListVec<int,3> vv;
    for(int i = 0; i < 7; i++)
    {
        vv.add(i);
    }
    for(int i = 0; i < vv.size(); i++)
    {
        cout << vv.get(i) << endl;
    }
    vv[2] = 77;;
    for(int i = 0; i < vv.size(); i++)
    {
        cout << vv[i] << endl;
    }
    return 0;
}

Og et svar.

Ja heltsikkert, det har du nok ret I, Jeg var nok lidt for optimistisk mht. implementeringen, i standarden skulle der være mulighed for forskellige implementation af vector, det er jo ikke et krav at vectors data elementer ligger i rækkefølge fysisk.

Jep. Jeg siger tak for hjælpen!