3. C++ Lernen - Verständnisfragen

C++ Lernen - Verständnisfragen

  • F

    @Drgreentom sagte in C++ Lernen - Verständnisfrage (Ausgabe rückwärts - aus Array):

    for (size_t i = arr.size(); i > 0; --i) würde dann aber ja den Index "0" des Arrays nicht mit ausgeben?! Also müsste man sicher i>=0 nehmen, richtig?

    Nein, das hat schon so seine Richtigkeit. @wob hat ja geschrieben, dass diese Schleifen mit unsigned-Zähler (wie solche vom Typ size_t) nicht leicht korrekt hinzubekommen sind. i >= 0 ist nämlich für diese vorzeichenlosen Ganzzahlen eine Tautologie, also ein Ausdruck der immer wahr ist, für jeden Wert, den diese Zahl annehmen kann (da es keine unsigned-Zahlen kleiner 0 gibt). Die Schleife würde also nie enden und auf falsche Indizes zugreifen.

    Auch können unsigned-Variablen über- und unterlaufen (siehe Arithmetischer Überlauf), das heisst, dass falls eingabe.size() == 0 gilt, j = eingabe.size() - 1 zu einem Unterlauf führt, nach dem j den maximalen Wert hat, den eine Variable dieses Typs annehmen kann. Auch mit dieser Schleife würdest du auf falsche Indizes zugreifen.

    Mit int passiert das übrigens nicht, da dieser auch negative Werte annehmen kann und in deinem Fall nicht "unterläuft".

    Es gibt mit einem int-Zähler allerdings das Problem, dass dieser (üblicherweise) nur Werte bis 231−12^{31}-1 annehmen kann (auf bestimmten Systemen auch nur bis 215−12^{15}-1. Damit läuft man dann auf Probleme, wenn der std::vector zu gross wird (auf einem 64-Bit-System geht std::size_t üblicherweise bis 263−12^{63}-1). Bei kleinen, per Hand eingegebenen Datenmengen kann man das machen, aber es ist keine saubere Umsetzung.

    Ab C++20 gibt es auch noch std::ssize, das gibt die Größe eines Containers als vorzeichenbehafteten Integer-Typen zurück, z.B. als 64-Bit Integer. Das wäre eine etwas sauberere Lösung:

    for (auto j = std::ssize(eingabe) - 1; j >= 0; j--)
{
   cout << eingabe.at(j) << " ";
}

    ... auch wenn dieser Typ ebenfalls nicht alle Werte eines std::size_t abdeckt, aber zumindest auf einem 64-bit-System kann man derzeit nicht genug Speicher haben, als dass ein std::vector zu groß dafür würde.

    Wenn du mit std::size_t arbeitest, musst du es schon so machen wie @wob vorgeschlagen hat (oder eben meinen Vorwärtsschleifen-Ansatz). Aber ich würde dir das generell nur als Übung empfehlen und nahelegen, dich möglichst früh in Iteratoren einzuarbeiten. Mit denen lassen sich Probleme dieser Art elegant vermeiden.

    1
  • W

    @Drgreentom sagte in C++ Lernen - Verständnisfrage (Ausgabe rückwärts - aus Array):

    Wenn man auf ein Index in einem Array verweist, das nicht existiert, dann stürtzt das Programm ab - so stand das auch im Buch.

    Das kommt darauf an.

    a) Wenn du, wie in deinem Beispiel, mit eingabe.at(i) zugreifst, dann wird einfach eine Exception (std::out_of_range) geworfen, siehe https://en.cppreference.com/w/cpp/container/array/at. Das Programm stürzt nicht ab. Du musst die Exception natürlich fangen.

    b) Wenn du mit eingabe[i] zugreifst, dann darf das Programm abstürzen. Es muss aber nicht. Der Absturz ist NICHT garantiert. Es darf aber auch ein falsches Ergebnis herauskommen. Oder sogar das richtige (hm, was bedeutet "richtig" hier?). Es darf halt einfach irgendwas rauskommen. Es ist schlicht undefiniertes Verhalten. Siehe https://en.cppreference.com/w/cpp/container/array/operator_at (Zitat aus Notes: "Accessing a nonexistent element through this operator is undefined behavior." Und UB willst du nie haben.)

    Ich arbeite mit Code::Blocks + Mingw. Der Compiler lieferte keine Fehler.

    Du musst Warnungen einschalten. Warnungen sind allerdings keine Fehler, du solltest sie aber wie Fehler behandeln. Ich habe Code::Blocks nicht, aber StackOverflow zeigt hier Screenshots, wie man Warnungen einschaltet: https://stackoverflow.com/questions/43447796/how-to-enable-narrowing-warnings-in-codeblocks (schalte mindestens -Wall und -Wextra ein)

    1
  • D

    Das beantwortet fürs erste meine Fragen. Vielen Dank

    0
  • D

    Ich habe mir jetzt dazu die Lösung im Buch angesehen:

    for(int i=eingabe.size()-1; i>=0; i--)
     cout << eingabe.at(i) << " ";

    Das entspricht ja etwa dem Ansatz wie ich es mir überlegt hatte.

    Ich gebe euch aber recht. Die Variante mit rend ist schöner - nur wurden for_each - Schleifen noch nicht behandelt. Kann aber sicher nicht Schaden vorzugreifen und es gleich richtig zu lernen, auch weil man ja mehr als nur simple Ausgabe damit machen kann.

    for_each(eingabe.crbegin(), eingabe.crend(), [](double ausgabe){cout << ausgabe << ' '; });

    ---------------------------------------------------------------------------------Ende 1.Frage--------------------------------------------------------------------

    0
    F
     1 Antwort
  • Mod

    Das ist aber auch ein bisschen eine alte Art und Weise, das zu schreiben. So wie anno 2010, ca. Du siehst ja vielleicht selbst, dass das nicht unbedingt intuitiv verständlich ist.

    Seither sind aber zwei wesentliche Dinge dazu gekommen:

    1. For-Schleifen, die einfach nur über alle Elemente in einen Container iterieren sollen, schreibt man nun als ranged base for:
    for (auto element: container)
{
    // Tu etwas mit dem Element aus dem Container
}
    1. Es sind allerlei Helferlein dazu gekommen, mit denen man einfacher mit solchen Containersequenzen umgehen kann, unter anderem reverse_view. Das Beispiel hinter dem Link passt ziemlich exakt zu deinem Problem, und zeigt wie man es mit diesen Mitteln auf verschiedene Arten und Weisen lösen kann.

    Letzteres setzt aber einen einigermaßen aktuellen Compiler voraus, weil es "erst" ein paar Jahre alt ist, was für C++-Verhältnisse quasi brandneu ist.

    0
  • F

    @Drgreentom sagte in C++ Lernen - Verständnisfragen:

    Ich habe mir jetzt dazu die Lösung im Buch angesehen:

    for(int i=eingabe.size()-1; i>=0; i--)
     cout << eingabe.at(i) << " ";

    Ich hoffe das Buch erwähnt auch, dass int mit Vorzeichen hier wichtig ist. Wenn man das durch ein auto ersetzt (i bekommt dann den Typ, der von eingabe.size() zurückgegeben wird) dann fliegt einem das um die Ohren. Nur um das nochmal zu unterstreichen, da der Großteil der Diskussion genau darum ging 😉

    0

  • Um mal einen anderen Ansatz zu zeigen:

    std::vector<int> foobar( 10, 1 );
for ( std::size_t i = 0; i < foobar.size(); ++i )
{
   std::cout << foobar.at( foobar.size() - i - 1 ) << "\n";
}

    Man muss eigentlich in fast keinem Fall unbedingt rückwärts iterieren und wenn doch, dann am besten über die von den anderen hier schon genannten Methoden.
    Das rückwärts-durchlaufen führt insbesondere bei Neueinsteigern oft zu Problemen, wenn man die Funktionsweise von C++ ( auch die von positiven ganzzahligen Datentypen ) noch nicht komplett durchdrungen hat.

    Ich verwende eigentlich ausschließlich die Range-Based-Loop und eben die Variante mit Iteratoren, insbesondere dann wenn ich den Iterator z.B. zum Aufruf von "erase()" benötige.

    0
    W
     1 Antwort
  • W

    @It0101 sagte in C++ Lernen - Verständnisfragen:

    Ich verwende eigentlich ausschließlich die Range-Based-Loop und eben die Variante mit Iteratoren, insbesondere dann wenn ich den Iterator z.B. zum Aufruf von "erase()" benötige.

    Hm. Das würde ich nicht machen, denn z.B. vector.erase invalidiert alle nachfolgenden Iteratoren, auch das vorherige end. In der Range-Loop wurde das aber am Anfang geholt. Also eine range-Loop mit erase darin - das kann doch eigentlich nicht sinnvoll gehen?

    0 1 Antwort
  • Mod

    Das ist wahrscheinlich ungünstiger Satzbau und soll heißen, dass die Iterator-Variante dem range-based Loop vorgezogen wird, wenn es um Dinge wie erase geht. Denn anders geht es auch gar nicht, denn vector::erase arbeitet schließlich auf einem Iterator, nicht auf einem Wert. Für so etwas ist dann erase_if gut.

    0

  • @wob sagte in C++ Lernen - Verständnisfragen:

    Hm. Das würde ich nicht machen, denn z.B. vector.erase invalidiert alle nachfolgenden Iteratoren, auch das vorherige end. In der Range-Loop wurde das aber am Anfang geholt. Also eine range-Loop mit erase darin - das kann doch eigentlich nicht sinnvoll gehen?

    Jain. Man muss natürlich trotzdem aufpassen.
    Es sieht in der Regel so aus:

    std::vector<int> foobar;
for ( auto it = foobar.begin(); it != foobar.end(); )
{
    if ( hasToBeDeleted( *it ) )
       it = foobar.erase( it );
   else
        ++it;
}

    Das funktioniert, weil erase dann quasi schon den "neuen" iterator zurückliefert. Ich nutze das, wenn die Möglichkeit besteht, dass mehrere Elemente entfernt werden müssen.

    0
    T
     1 Antwort
  • T

    @It0101 Hier hast du aber auch Iteratoren genutzt und nicht wie von wob vermutet eine range based for loop.

    0 1 Antwort

  • @Tyrdal sagte in C++ Lernen - Verständnisfragen:

    @It0101 Hier hast du aber auch Iteratoren genutzt und nicht wie von wob vermutet eine range based for loop.

    Ja natürlich. Ich fummel doch nicht innerhalb einer Range-Based-Loop mit erase rum.... 🤣

    Dann war das Missverständnis ein anderes, als ich dachte.

    Edit: jetzt hab ich's noch mal gelesen. Es verhält sich im Grunde genau so wie @SeppJ es geschrieben hat.

    0
  • W

    Ah, dann hatte ich dich falsch verstanden. Jetzt, wo ich deinen Post nochmal lese, ist es wohl das "und", was ich nicht richtig verstanden hatte.

    Statt

    Ich verwende eigentlich ausschließlich die Range-Based-Loop und eben die Variante mit Iteratoren, insbesondere dann wenn ich den Iterator z.B. zum Aufruf von "erase()" benötige.

    Wäre klarer gewesen:

    Ich verwende eigentlich ausschließlich die Range-Based-Loop. Wenn ich aber den Iterator z.B. zum Aufruf von "erase()" benötige, verwende ich die Variante mit Iteratoren.

    Das meintest du. Dann ist es natürlich richtig. Ich hatte den Text oben zu schnell gelesen.

    Wobei: in deinen Beispiel würde ich eher das erase-remove-Idiom einsetzen:

    Also statt

    for ( auto it = foobar.begin(); it != foobar.end(); )
{
    if ( hasToBeDeleted( *it ) )
       it = foobar.erase( it );
   else
        ++it;
}

    ...lieber sowas wie:

    foobar.erase(
    std::remove_if(foobar.begin(), foobar.end(), hasToBeDeleted),
    foobar.end()
);

    (da vergesse ich nur sehr, sehr, sehr gerne das 2. Argument von erase. 😕 )

    0
    S
     1 Antwort
  • S

    @wob Müsste nicht inzwischen sowas gehen:

    auto [begin, end] = std::ranges::remove_if(foobar, hastToBeDeleted);
foobar.erase(begin, end);

    Edit: Code angepasst... erase hat gefehlt. Macht es so nicht viel besser.

    0
    F
    T
     2 Antworten
  • F

    @Schlangenmensch sagte in C++ Lernen - Verständnisfragen:

    @wob Müsste nicht inzwischen sowas gehen:

    auto [begin, end] = std::ranges::remove_if(foobar, hastToBeDeleted);
foobar.erase(begin, end);

    Edit: Code angepasst... erase hat gefehlt. Macht es so nicht viel besser.

    Nicht in jedem fall da hier eine range erwartet wird.
    Aber im folgenden falle nicht
    vector enthält folgende werte

    1, 9, 5, 10

    hastToBeDeleted hat die Bedingung <value> <= 5
    Dann würde std::ranges::remove_if(foobar, hastToBeDeleted); wohl nach dem es auf den wert 9 trifft abbrechen. Und Dadurch würde der Wert 5 nicht gelöscht werden
    Oder im schlimmsten falle würde die 9 auch mit gelöscht werden.

    0
    S
    W
     2 Antworten
  • S

    @firefly Nö, warum: https://godbolt.org/z/fv8G9sf7M
    std::ranges::remove_if verschiebt die Elemente so, dass die Elemente, die nicht gelöscht werden am Anfang des Ranges stehen und die, die gelöscht werden am Ende. Und zurück gegeben wird die Subrange der zu löschenden Elemente.

    0
    F
     1 Antwort
  • W

    @firefly sagte in C++ Lernen - Verständnisfragen:

    Dann würde std::ranges::remove_if(foobar, hastToBeDeleted); wohl nach dem es auf den wert 9 trifft abbrechen. Und Dadurch würde der Wert 5 nicht gelöscht werden
    Oder im schlimmsten falle würde die 9 auch mit gelöscht werden.

    Nein, das erase-remove-Idiom ist nicht umsonst ein Idiom (sogar mit einenem Wikipedia-Artikel). Es wäre kein Idiom, wenn solche komischen Dinge passieren würden (wie es funktioniert, hat @Schlangenmensch ja schon geschrieben)

    Edit: und lesen lohnt sich sogar, denn dann erfährt man z.B., dass es mit C++20 auch via std::erase / std::erase_if ginge.

    0
  • F

    @Schlangenmensch sagte in C++ Lernen - Verständnisfragen:

    @firefly Nö, warum: https://godbolt.org/z/fv8G9sf7M
    std::ranges::remove_if verschiebt die Elemente so, dass die Elemente, die nicht gelöscht werden am Anfang des Ranges stehen und die, die gelöscht werden am Ende. Und zurück gegeben wird die Subrange der zu löschenden Elemente.

    Ah ok hab das in der beschreibung überlesen. https://en.cppreference.com/w/cpp/algorithm/ranges/remove

    0
  • T

    @Schlangenmensch sagte in C++ Lernen - Verständnisfragen:

    @wob Müsste nicht inzwischen sowas gehen:

    auto [begin, end] = std::ranges::remove_if(foobar, hastToBeDeleted);
foobar.erase(begin, end);

    Edit: Code angepasst... erase hat gefehlt. Macht es so nicht viel besser.

    Und wo lliegt hier der große Vorteil? Ist doch auch nicht wirklich kürzer als das alte Idiom und macht vom Prinzip her dasselbe.

    0
    S
     1 Antwort
  • S

    @Tyrdal Ich hatte im Kopf, dass es mit der Ranges lib auch in einem Aufruf hätte gehen müssen, ohne dass man den, von @wob erwähnten end() Aufruf vergessen kann. Hatte mich da aber im ersten Schuss vertan, daher der Edit. Die von @wob verlinkten std::erase und std::erase_if sind die schöneren Alternativen.

    0
Anmelden zum Antworten