Warum werden bei folgendem Programm die gelöschgten sätze nicht ausgegeben, obwohl die Ausgabe vor dem Löschen erfolgt?

# include           <iostream>
# include           <string>
# include           <vector>
using namespace     std;

class person
   {
   private:
      string        mFirstname;
      string        mLastname;

   public:

                    person (string fn, string ln) : mFirstname (fn), mLastname (ln) {};
                    person () {};
      void          printPerson (void)
         {
         cout << mFirstname << " " << mLastname << endl;
         }
      string        getFirstname () { return mFirstname; }
      string        getLastname () { return mLastname; }
   };

int                 main (int argc, char ** argv)
   {
   vector<person>           personen;
   vector<person>::iterator pit;
   string                   fname;

   personen.push_back (person ("Klaus", "Müller"));
   personen.push_back (person ("Erwin", "Meier"));
   personen.push_back (person ("Sieghard", "Rupp"));
   personen.push_back (person ("Jochen", "Senft"));
   personen.push_back (person ("Ulrike", "Kranwinkel"));
   personen.push_back (person ("Sabine", "Burghard"));
   for (pit = personen.begin (); pit != personen.end (); pit++)
      {
      pit->printPerson ();
      fname = pit->getFirstname ();
      if ((fname.compare ("Erwin") == 0) || (fname.compare ("Jochen") == 0))
         {
         pit = personen.erase (pit);
         }
      }
   cout << "           -----   schnipp -----       " << endl;
   for (pit = personen.begin (); pit != personen.end (); pit++)
      {
      pit->printPerson ();
      }
   return 0;
   }

Wenn ich in einer ersten Schleife nur ausgebe, in einer weiteren löschen und dann wieder ausgebe, ist alles OK.

Gruss Henrik

Ich hab das bei mir mal ausprobiert, und es klappt eigentlich, bis auf einen Punkt:
In der ersten Schleife werden Sieghard und Ulrike nicht ausgegeben. Grund:

Return value
A random access iterator pointing to the new location of the element that followed the last element erased by the function call, which is the vector end if the operation erased the last element in the sequence.

Quelle: http://cplusplus.com/reference/stl/vector/erase/
Da deine for-Schleife automatisch inkrementiert, wird dieser eine Eintrag übersprungen.
Lösung: while-Schleife:

vector<person>::iterator pit=personen.begin();
while(pit != personen.end()) {
    pit->printPerson ();
    fname = pit->getFirstname ();
    if ((fname.compare ("Erwin") == 0) || (fname.compare ("Jochen") == 0))
    {
        pit = personen.erase (pit);
    }
    else ++pit;
}

//edit: Deklaration von pit mit eingefügt

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

Dieses Posting wurde automatisch erzeugt.

Gruss Henrik

P.S. Umgangston

Was gefällt Dir nicht an meiner Art der Einrückung? Ich rücke jeden Block um 3 Leerzeichen ein und schreibe die Öffnende Klammer genau da hin. Damit stehen öffnende und schliessende Klammer genau übereinander und Blockanfang und -ende sind gut erkennbar. Die andere Schreibweise mit den öffnenden Klammern finde ich weniger gut lesbar.

drakon meint wohl den liberalen Gebrauch von Leerzeichen in deinem Code. Wichtige Dinge stehen viel zu weit auseinander.

Erst mal Danke an alle nützlichen Beiträge.

Ich hab's gerne ein bischen Luftiger und hatte mir bei der C Programmierung ein gewisses Spaltenschema angeeignet. Das lässt sich bei C++ nur bedingt durchhalten, aber ich versuch's trotzdem.

Erst mal Danke an alle nützlichen Beiträge.

Ich würde dir empfehlen das nicht zu tun. Gewöhn dir am besten eine übliches Schema an. Ansonsten wird kaum jemand deinen Code lesen können/wollen und wenn du das einem Arbeitgeber zeigst, dann wird der auch nicht unbedingt Freude dran haben, respektive du musst so oder so einen üblichen Schreibstil angewöhnen.

class person
    {
    };

Irgendwie denk ich da, ich hab nen Fehler reingebracht.
Auch platzsparende Schreibweisen wie

if( predicate1 ) {
    doSomething(25);
} else {
    doSomething(35);
}

bool ok = false;
do {
    askForInput(&ok);
} while( !ok );

sind schwerer leserlich:

if( predicate1 )
    {
    doSomething(25);
    } else {
    doSomething(35);
    }

bool ok = false;
do
    {
    askForInput(&ok);
    } while( !ok );

Die Absätze sind nicht mehr getrennt, alles auf einer Ebene!
Noch schlimmer wird es bei anonymen Blöcken, um temporäre Objekte sofort nach Verlassen wieder zu zerstören:

void fun(std::string& str)
    {
    int var = 10;
        {
        std::stringstream s;
        s << var;
        str = s.str();
        }
    }

Man sieht einfach den Absatz nicht ins Auge springen!

War vllt. jetzt etwas zu viel des Guten, aber ich hoffe du siehst, warum eigentlich jeder erst den Inhalt eines Blockes einrückt, nicht aber die Klammern.

Das mit der Einrückung ist sicherlich Gewohnheitssache. Ich will halt (wie wohl die meisten) dass ein Block erkennbar da endet wo er beginnt, und das ist bei deiner Schreibweise leider nicht gegeben.

Seine Schreibweise ist zwar nicht die übliche Form, aber durchaus auch in Natura anzutreffen (Wenn gleich ich aus den Projekten in denen ich bislang mitgewirkt habe, andere gewohnt bin). Selbst manche IDEs unterstützen (nach einiger Konfiguration) diesen Stil.

Ich würde sagen, die zwei üblichsten Stile sind folgende:

// 1.
class A {
};

int main() {
}

// 2.
class A
{
};

int main()
{
}

gerade wenn es um Unixsysteme geht, habe ich aber auch Stile gesehen, die dem OP durchaus nicht unüblich sind (von den vielen Leerzeichen einmal abgesehen). Varianten gibt es von allen, ich z.B. breche Teilweise auch Parameter um (Mit Einrückung) auch wenn es selten ist das man Code mal ausdruckt sehe ich lieber alle Parameter auch bei längeren Bezeichnern ohne seitlich Scrollen zu müssen.

Die vielen Leerzeichen gewöhnt man sich spätestens dann ab, wenn man auch gleich Kommentare zur Dokumentation (z.B. Doxygen) einsetzt (Die Dokumentation durchbricht nunmal die künstlichen Einrückung etwas).