class Klasse
{
    std::string id;
    //...
};

std::vector<KLASSE> vec;

int main()
{
    vec.reserve(20000);
    std::ifstream lesen("Database");
    while(!lesen.eof())
    {
        Klasse objekt;
        lesen>>objekt;
        for(size_t a(0), b(vec.size()); a!=b; ++a)
        {
            if(objekt.id == vec[a].id)
                break;
        }
    }
}

Die Laufzeit deses Algorithmus steigt natürlich mit zunehmender Database größe exponentiell. In meinem Fall hat die Database ca. 15.000 Einträge und der Einlesevorgang benötigt ca. 5 Sekunden.
Hat jemand eine Idee, wie man das einlesen performanter gestalten könnte? Ich hatte schon die Idee, den vector nach jedem neu eingelesenem Objekt zu sortieren, um bei der suche nach objekten den Suchbereich eingrenzen zu können. Was haltet ihr davon? Der Code ist relativ komplex, daher habe ich diese Änderung noch nicht probiert. Was haltet ihr davon? Gibt es andere Möglichkeiten?

@ hah: komischer Vorschlag Oo

Grüssli

class Klasse
{
    std::string id;
    std::vector<int> version;
    //...
};

std::vector<Klasse> vec;

int main()
{
    vec.reserve(20000);
    std::ifstream lesen("Database");
    bool gefunden = false;
    while(!lesen.eof())
    {
        Klasse objekt;
        lesen>>objekt;
        for(size_t a(0), b(vec.size()); a!=b; ++a)
        {
            if(objekt.id == vec[a].id)
            {
                vec[a].version.push_back(objekt.version[0]);
                gefunden=true;
                break;
            }
        }
        if(gefunden)
        {
            gefunden=false;
            continue;
        }
        vec.push_back(objekt);
    }
}

So kompliziert ist der Algorithmus ja wirklich nicht.

Grüssli

Genauso wie es Draveres Vorschlag tut. Lies alle Werte ein, sortier und füll dann erst den Versionsvektor auf mit den doppelten Elementen, die folgen. Zum Schluss die doppelten Objekte entfernen.

class Klasse
{
    std::string id;
    std::vectir<int> version;
    //...
}

inline bool sort_all ( const Klasse& a, const Klasse& b){ return (a.id < b.id); }
inline bool operator==(const Klasse& a, const Klasse& b){ return (a.id == b.id); }

std::vector<Klasse> vec;

int main()
{
    vec.reserve(20000);
    while(!lesen.eof())
    {
        Klasse objekt;          //
        lesen>>objekt;          // alle einlesen
        vec.push_back(objekt);  //
    }
    lesen.close()

    std::vector<Klasse>::iterator it=vec.begin(), end=vec.end(), at, unique_it;

    sort(it, et, sort_all); //vec sortieren

    at = it;
    ++it;

    while(at != end)
    {
        if(*it == *at)
        { 
            (*it).version.push_back( (*at).version[0] );
            ++at;
            continue;
        }
        it = at;
        ++at;
    }

    unique_it = unique(vec.begin(), end);
    vec.resize(end-unique_it);
}

typedef vector<Klasse>::iterator Iter;

Iter pos1 = vec.begin();
Iter pos2;

while((pos1 = adjacent_find(pos1, vec.end())) != vec.end())
{
	pos2 = pos1 + 1;
	while(*pos2 == *pos1)
	{
		pos1->version.push_back(pos2->version[0]);
		++pos2;
		if(pos2 == vec.end())
			return;	// aus beiden Schleifen raus
	}
	pos1 = pos2 + 1;
}

Wie immer ungetestet.

[Edit] OK, hier kann man sich adjacent_find() wirklich sparen