C++ Best Practice für Schleife mit Abbruch in der Mitte

[Peter Sahl (Gast)]

Hallo,

im folgenden Code habe ich in f() und g() jeweils eine Variante einer 
Schleife mit Abbruchbedingung in der Mitte. Mit getc() lies sich dies 
vermeiden, mit getline() sehe ich mich dazu gezwungen. Das Beispiel 
liest Zeilen aus einem Stream bis eine Leerzeile kommt.

#include <iostream>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
vector <string> f (istream& is) {
        string s;
        vector <string> v;
        while (1) {
                getline (is, s);
                if ("" == s) {
                        break;
                }
                v.push_back (s);
        }
        return v;
}
vector <string> g (istream& is) {
        vector <string> v;
        for (string s;
                        getline (is, s),
                        "" != s;
            ) {
                v.push_back (s);
        }
        return v;
}
int main (int argc, char** argv) {
        string s = "Line 1\nLine 2\nLine 3\n\nLine 5";
        istringstream iss1 (s);
        for (auto a: f (iss1)) {
                cout << a << endl;
        }
        cout << "---" << endl;
        istringstream iss2 (s);
        for (auto a: g (iss2)) {
                cout << a << endl;
        }
        return 0;
}

% ./a.out
Line 1
Line 2
Line 3
---
Line 1
Line 2
Line 3

Derzeit liebäugle ich mit der Variante in g(), da ich while(1) und 
for(;;) optisch nicht so schön finde.

Wie macht ihr sowas?

[Oliver S. (oliverso)]

Ich würde die Variante nehmen, in der du einfacher auf eof prüfen 
kannst.

Oliver

[Thomas K. (muetze1)]

Ich würde auch keinen Stringvergleich machen sondern die Methode empty() 
bemühen. So wird temporär ein std::string(""), der Vergleich 
durchgeführt und dann wieder verworfen.

[Peter Sahl (Gast)]

Oliver S. schrieb:
> einfacher auf eof prüfen

Das sollte doch eigentlich getline() machen. Trotzdem stürtzt mir der PC 
ab, wenn ich den String nicht vorher selber lösche. Was eigentlich auch 
getline() machen sollte!?

Thomas K. schrieb:
> keinen Stringvergleich machen sondern die Methode empty()
> bemühen

Danke, das gefällt mir gut.

Dann sehen die Schleifen folgendermaßen aus, wobei mir immernoch g() 
besser gefällt. Kennt ihr noch mehr Möglichkeiten solche Schleifen in 
C++ auszudrücken. Oder auch zu Formatieren. In Ada gibts das ja built 
in.

f()

while (1) {
        s.clear ();
        getline (is, s);
        if (s.empty ()) {
                break;
        }
        v.push_back (s);
}

g()

for (   string s;

        s.clear (),
        getline (is, s),
        !s.empty ();
    ) {
        v.push_back (s);
}

Input

string s = "Line 1\nLine 2";

Output

% ./a.out
Line 1
Line 2
---
Line 1
Line 2

[Wilhelm M. (wimalopaan)]

using namespace std;
vector<string> f(istream& is) {
        vector <string> v;
        for(string s; getline(is, s) && !s.empty();) {
            v.push_back(s);
        }
        return v;
}

[Frank M. (ukw) (Moderator)]

Warum packst Du das v.push_back(s) nicht auch noch hinter das letzte 
Semikolon der for-Zeile?

[Dirk K. (merciless)]

Frank M. schrieb:
> Warum packst Du das v.push_back(s) nicht auch noch hinter das letzte
> Semikolon der for-Zeile?

Wozu sollte das gut sein? Der Lesbarkeit dient es nicht...

merciless

[Peter Sahl (Gast)]

Wilhelm M. schrieb:
> &&

Sehr schön. Jetzt prüft es auch explizit auf EOF.

Dirk K. schrieb:
> Frank M. schrieb:
>> Warum packst Du das v.push_back(s) nicht auch noch hinter das letzte
>> Semikolon der for-Zeile?
>
> Wozu sollte das gut sein? Der Lesbarkeit dient es nicht...

Doch ich finde schon. Weil es die geschweiften Klammern spart.

for (
        string s;

        s.clear (),

        getline (is, s) &&
        !s.empty ();

        v.push_back (s)
    );

[Wilhelm M. (wimalopaan)]

Wobei ich das eher generisch machen würde:

template<typename T, typename P>
auto read_if(std::istream& is, P predicate) {
    std::vector<T> v;
    for(T item{}; getline(is, item) && predicate(item);) {
        v.push_back(item);
    } 
    return v;
}

und dann:

int main () {
    std::string s{"Line 1\nLine 2\nLine 3\n\nLine 5"};
    std::istringstream iss1{s};
    for (const auto& a: read_if<std::string>(iss1, [](const auto& s){return !s.empty();})) {
        cout << a << endl;
    }
}

[leo (Gast)]

Wilhelm M. schrieb:
> for (const auto& a: read_if<std::string>(iss1, [](const auto&
> s){return !s.empty();})) {

Ja, schaut sehr uebersichtlich und lesbar aus ;-) Der W. schafft es doch 
immer den Obfuscation-Wettbewert zu gewinnen.

SCNR, leo

[Wilhelm M. (wimalopaan)]

leo schrieb:
> Ja, schaut sehr uebersichtlich und lesbar aus ;-) Der W. schafft es doch
> immer den Obfuscation-Wettbewert zu gewinnen.

Das hängt immer zu 50% vom Leser ab ;-)

[leo (Gast)]

Wilhelm M. schrieb:
> leo schrieb:
>> Ja, schaut sehr uebersichtlich und lesbar aus ;-) Der W. schafft es doch
>> immer den Obfuscation-Wettbewert zu gewinnen.
>
> Das hängt immer zu 50% vom Leser ab ;-)

Yep. Meine Erfahrung sagt mir a) die weitaus meiste Zeit verbringe ich 
mit Lesen von Code und b) kuerzerer Code ist lesbarer und verbirgt 
weniger Fehler.

leo

[Peter Sahl (Gast)]

Wilhelm M. schrieb:
> eher generisch machen

Wie hältst du es mit den ganzen Strings?

Wenn ich etwas generisch machen will dann kommt meist etwas heraus was 
dem folgenden strukturell recht ähnlich sieht. Und ich erwische mich 
dabei, wie ich schon längst aufgehöhrt habe an meinem Programm zu 
arbeiten, sondern eigentlich am Compiler bastel.

Dann nehm ich meist einfach wieder nur char und string.

template <typename P
        , typename CharT
        , typename Traits = char_traits <CharT>
        , typename Allocator = allocator <CharT>
        , typename S = basic_string <CharT, Traits, Allocator>
        , typename V = vector <S>>
V h (basic_istream <CharT, Traits>& is, P predicate) {
        V v;
        for (
                   S s
                ;  s.clear ()
                ,  getline (is, s)
                && predicate (s)
                ;  v.push_back (s)
        );
        return v;
}

[Dirk K. (merciless)]

Peter Sahl schrieb:
> Dirk K. schrieb:
>> Wozu sollte das gut sein? Der Lesbarkeit dient es nicht...
>
> Doch ich finde schon. Weil es die geschweiften Klammern spart.
Lol, aber Schleifenköpfe auf mehrere Zeilen verteilen,
ganz großes Kino. Ich empfehle Lektüre zum
Thema "Clean Code" (https://clean-code-developer.de/).

merciless

[Wilhelm M. (wimalopaan)]

Peter Sahl schrieb:
> Wenn ich etwas generisch machen will dann kommt meist etwas heraus was
> dem folgenden strukturell recht ähnlich sieht. Und ich erwische mich
> dabei, wie ich schon längst aufgehöhrt habe an meinem Programm zu
> arbeiten, sondern eigentlich am Compiler bastel.

Ist doch vollkommen unnötig.