ich bin mittlerweile mit den Nerven am Ende. -.-
Derzeit sitze ich seit 20 Stunden an einer kleinen Aufgabe fürs Studium und bräuchte mal etwas Hilfe.

Aufgabenstellung ist die List (STL) teilweise nachzuprogrammieren.

Mein Problem: Ich möchte über einen Iterator in die Liste an einem bestimmten Punkt ein Element (Datentyp mittels Template variabel) einfügen.

Wenn ich eine List anlege fällt mir auf, dass die Werte sich um 0x20 größer werden, wenn ich die eigens erstelle pushback-Fktn aufrufe. Soweit so gut, hier entsprechen die Einträge im Speicher meinen Erwartungen und es kommt zu einen Problemen.

Beim Iterator sieht die Sache dagegen anders aus. Ich lege also einen Iterator anhand der Liste an, in die ich zuvor ein paar doubles "gepushbackt" habe.

Nun inkrementiere ich den Iterator und er zählt aus mir nicht erkennbaren Gründen in einer ganz anderen "Größe" hoch.
Diese Illustration verdeutlicht mein Problem:
https://dl.dropboxusercontent.com/u/28089422/Untitled.png

Wie gesagt, derzeit habe ich mehrere Tage schon an dem Problem verbracht und komme auf keinen Lösungsansatz.

**Wäre super nett, wenn mir jemand helfen kann und mir einen Denkanstoß gibt.
**
Hier noch ein paar Zeilen aus meinem Code:

main.cpp

double a(1), b(2), c(3), d(4), e(5), f(6);

    test_List.push_back(a);
    test_List.push_back(b);
    test_List.push_back(c);
    test_List.push_back(d);
    test_List.push_back(e);
    test_List.push_back(f);

    myList<double>::myIterator p = test_List.begin();
    ++p;
    ++p;
    ++p;

    myList<double>::myIterator q = p;
    ++q;

    test_List.insert(p, 999.99);

myList.h

myIterator& operator++() {
            ++curr;
            return *this;
        }

myNode<Elem>* getCurrent() const {
            return curr;
        }

myList.cpp

template<class Elem>
typename myList<Elem>::myIterator myList<Elem>::insert
(myIterator iter, const Elem& args)
{

    myList<Elem>::myIterator walkthrough(first);

    while (iter != walkthrough) {
        ++(walkthrough);
    }

    myNode<Elem>* newInsNote = new myNode<Elem>;

    newInsNote = iter.getCurrent();
    //newInsNote = walkthrough; // Geht natuerlich auch nicht -.- ARGGG!!!
    //newInsNote->pre = newInsNote->pre->pre;
    //newInsNote->suc = newInsNote->pre->suc; // trauiger Manipulations-Versuch
    myNode<Elem>* newInsNote_sec = new myNode<Elem>;
    newInsNote_sec->val = args;

    ins(newInsNote, newInsNote_sec);

    return iter;
}

template<class Elem>
void myList<Elem>::ins(myNode<Elem>* p, myNode<Elem>* v) // neuen Knoten (v) hinter p einfuegen
{
    /*... pruefe...*/
    if (v != 0) {
        v->pre = p;
        v->suc = p->suc;
        p->suc->pre = v;
        p->suc = v;
    }
    else return;
}

Insgesamt bleibt zu sagen, dass ich mit den Iteratoren absolut überfordert bin und auch nicht im Geringsten einen Sinn erkenne ebendiese zu nutzen.

Vielen Dank vorab!
Beste Grüße

Kleine Frage am Rand:
gibt es in Netbeans irgendwie die Möglichkeit zu verhindern, dass bei der Speicheransicht im Debugger das "OUT OF SCOPE" verhindert wird? Ich finde es extrem nervig, dass die Werte einfach verschwinden, wenn man den Scope verlässt. Ich suche irgendwas wie eine "Screenshot-Funktion" o.ä. (ist so ein Punkt, der mich nach dem fünften versehentlichen "Einmal zu viel Klicken" an Rand des nervlichen Wahnsinn treibt.)

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

Was ist denn curr? Ein Zeiger? Das wäre doch sehr komisch, bei einem Listeniterator Zeigerarithmetik zu benutzen.

myIterator& operator++() {
            curr = curr->suc;
            return *this;
        }

So sieht das doch schon besser aus.

https://dl.dropboxusercontent.com/u/28089422/Untitled2.png

Vielen, vielen, lieben Dank!! Ich habe glaube ich noch nie eine so "zielgerichtete Fragestellung" aufgeworfen bekommen.

Wenn du noch einen Tipp hast, wie man sich so Zusammenhänge dauerhaft behalten kann bzw. zielsicher erkennen kann, lass es mich bitte wissen. Ich programmiere erst seit knapp einem Jahr und glaube für solche Sachen fehlt mir an manchen Stellen der Überblick über die Gesamtheit.

Wenn du noch einen Tipp hast, wie man sich so Zusammenhänge dauerhaft behalten kann bzw. zielsicher erkennen kann, lass es mich bitte wissen. Ich programmiere erst seit knapp einem Jahr und glaube für solche Sachen fehlt mir an manchen Stellen der Überblick über die Gesamtheit.

Das war jetzt einfach Erfahrung meinerseits, die kann man leider noch nicht auf die einfache Art und Weise erlangen.

Aber Fehler dieser Art kann man allgemein sehr gut mit einem Debugger finden. Du hast ja bereits einen benutzt und gute Hinweise gefunden. Wenn man versucht, die Fehlerursache im Code möglichst gut einzugrenzen (Einzelschritt: Wann beginnt der Programmzustand von den Erwartungen abzuweichen?), dann findet man oft die Ursache.

Nochmals Danke.