Fun-Soft - Programmierforum

Autor

Thread - Seiten: > 1 <

000
14.04.2007, 19:48 Uhr
FunnyDingo

Hallo zusammen,

ich versuche gerade, einen vector anzulegen der iteratoren enthalten soll, aber irgendwie klappt das nicht so ganz:

C++:

std::vector<std::list<User*>::iterator*> itlist;

int initIter()
{
    std::list<User*>::iterator *it = new std::list<User*>::iterator;
    *it = userlist.begin();
    itlist.insert(itlist.size(), it);
}

Ich habe das ganze dann auch nochmal als nicht-Pointer-Variante probiert:

C++:

std::vector<std::list<User*>::iterator> itlist;

int initIter()
{
std::list<User*>::iterator it = userlist.begin();
itlist.insert(itlist.size(), it);
}

Aber keins von beidem klappt! Hat jemand ne Idee?

Welche Variante wäre eigentlich die bessere? vector mit Pointern auf Objekte oder die Objekte direkt in den vector?

Wäre toll wenn jemand nen Tipp hat.

Gruß,
Funny
--
"Der Computer ist die logische Weiterentwicklung des Menschen: Intelligenz ohne Moral." (John James Osborne)

Meine Website: http://www.funnydingo.de

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

001
14.04.2007, 22:57 Uhr
Kest
saint

Hi!

Die >size()< von vector liefert ja die Größe, >insert< braucht ja einen Iterator.
Der Code würde mit >itlist.insert(itlist.begin(), it);< funktionieren
--
Wenn man einen Hufschlag hört, sollte man >Pferd< denken und nicht >Zebra<.

Dieser Post wurde am 14.04.2007 um 23:04 Uhr von Kest editiert.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

002
14.04.2007, 23:09 Uhr
Kest
saint

Nur so aus Interesse:
Was hast du überhaupt vor?
--
Wenn man einen Hufschlag hört, sollte man >Pferd< denken und nicht >Zebra<.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

003
14.04.2007, 23:24 Uhr
FunnyDingo

Ich gehe mal davon aus, das o.g. Code grundlegen erklärt welche Objekte dabei betroffen sind

Ich möchte an allen Stellen in meinem Code, an dem ich an die Namen der Benutzer ran muss, nicht eine eigene Iteration machen müssen - diese sollte am besten die Datenbank-Klasse tun. Aus diesem Grund habe ich mir folgendes überlegt (kein Code, nur Grundriss meiner Idee!):

C++:

int iterator_id = database->init_iterator();
string *name;
while(name = database->get_next_iteration(interator_id))
{
cout << "Name: " << *name << end;
}
database->clean_interator(interator);

database::init_iterator(interator_id)
wäre dann der Code der einen neuen Iterator erstellt, diesen im Vector ablegt und nen int mit der Position dieses Interators zurückgibt

database::get_next_iteration()
Diese macht eine Interation und gibt einen Pointer auf den String der den Namen des Benutzers beinhaltet zurück

database::clean_iteration()
Hier wird der Iterator aus dem vector rausgeholt und das Objekt deleted

Vielleicht gibt es ja einen besseren weg wie ich das umsetzten kann? Ich möchte halt irgendwo im Code eine Schleife durchlaufen in der ich alle Namen der Benutzer zurück bekomme ohne dort selbst iterieren zu müssen.

Puh, ich hoffe ich konnte verständlich machen was ich vor haben - falls nicht, einfach noch mal nachfragen *g*
--
"Der Computer ist die logische Weiterentwicklung des Menschen: Intelligenz ohne Moral." (John James Osborne)

Meine Website: http://www.funnydingo.de

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

004
16.04.2007, 08:48 Uhr
Kest
saint

Also:
Jeder würde das anders machen. Ist ja auch logisch.

Die Klasse >database< beschäftigt sich mit den >Usern<.
In >database< definiere ich:

C++:

std::list<User*> userlist;
std::list<User*>::iterator currentUserIter;

Die Methode >init_iterator< macht im Grunde nichts anderes als

C++:

currentUserIter=userlist.begin();

und liefert einen bool-Wert. (Vielleicht ist was schiefgegangen oder was auch immer)
Wenn der >true< ist, durchläuft man die Schleife

C++:

while((name=dabase.getUserName())!="")...

, die die Namen liefert. (Es gibt eher selten User ohne Namen)
Die Methode >getUserName<

C++:

std::string getUserName(){
         if(currentUserIter==userlist.end())
                                            return "";
         std::string temp((*currentUserIter)->getName());
         ++currentUserIter;
         return temp;
         }

Es entfällt, meiner Meinung nach, das >komische<

C++:

std::vector<std::list<User*>::iterator> itlist;

,
weil ich nicht verstehen kann, was du damit errichen willst.
--
Wenn man einen Hufschlag hört, sollte man >Pferd< denken und nicht >Zebra<.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

005
16.04.2007, 09:53 Uhr
(un)wissender
Niveauwart

Iteratoren sind flüchtig, speicher die nicht. Du erschaffst damit schwer aufzufindende Fehler.
Speicher Pointer. Aber nicht die von Stackobjekten in einer Kollektion (z.B. vector) sondern die von new zurückgegebenen, die bleiben gültig.
--
Wer früher stirbt ist länger tot.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

006
16.04.2007, 11:05 Uhr
FunnyDingo

@Kest:
Das sieht dem was ich gebastelt habe ziemlich änhlich, nur das ich bei meiner getUserName() einen Pointer zurückgebe (damit von dort aus der Name ohne weiters auch geändert werden könnte.

Warum ich die Iteratoren in einem Vector ablegen wollte kann ich dir auch erklären: Die Anwendung arbeitet mit Threads und somit wollte ich dieses Feature ThreadSafe bekommen. Bei meiner jetzigen Variante (wie gesagt, in etwa das gleich wie bei dir) wird ein Zeitgleicher Zugriff auf den Iterator richtiges Chaos verursachen. Mir ist aber eingefallen, dass ich das ja viel besser mit einem Mutex lösen kann, der den Iterator in einer "initNameSearch" locked und ihn in einer "cleanupNameSearch" wieder freigibt. Dann müsste der andere Thread hat solange warten bis der Iterator wieder frei ist.

@(un)wissender:
Die Iteratoren zu speichern hat sich ja damit erldigt ;-). Deine Aussage zum Speichern habe ich nun ehrlich gesagt nicht verstanden. Vielleicht ein Beispiel wie ich vorgehe:

C++:

std::list<user*> userlist;

bool add(const string name)
{
    /****************************
        Verify non-existence
        of name
    ****************************/

    cout << "Searching user '" << name << "'... ";
    list<user*>::iterator it_user = userlist.begin();
    while(it_user != userlist.end()) {
        if ((*it_user)->name == name) {
            cout << "found, return false" << endl;
            return false;
        }
        it_user++;
    }

    /****************************
        Create new user
    ****************************/

    cout << "not found" << endl << "Creating user '" << name << "'... ";
    user *newuser = new user(name);
    userlist.push_back(newuser);
    cout << "done" << endl;
    cout << "New user count: " << userlist.size() << endl;

    return true;
}

Ich glaube aber, dass dies deiner Aussage entspricht.
--
"Der Computer ist die logische Weiterentwicklung des Menschen: Intelligenz ohne Moral." (John James Osborne)

Meine Website: http://www.funnydingo.de

Dieser Post wurde am 16.04.2007 um 11:05 Uhr von FunnyDingo editiert.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

Seiten: > 1 < [ C / C++ (ANSI-Standard) ]

ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: