String nach vorkommen von char[x] durchsuchen



  • Hallo,


    dabei soll entweder TRUE oder FALSE zurückgeliefert werden.

    Ich hab es mit:

    vergleich = wort.find(wort_char[x])
    

    versucht, aber dadurch wird nur die position des buchstabens angezeigt,
    man könnte jetzt natürlich noch 'vergleich' so umwandeln, das man
    TRUE oder FALSE zurückgeliefert bekommt, da ich meine Prozedur aber so
    einfach wie möglich halten will, such ich jetzt nach einer "direkten"
    Möglichkeit wo gleich "TRUE" bzw. "FALSE" zurückgeliefert wird,

    über Hilfe würd ich mich freuen(bin Anfänger)

    mfg tillt :xmas1:



  • std::string::find liefert bei Erfolg die Position des ersten Vorkommens, ansonsten std::string::npos. Also einfach mit diesem Wert vergleichen.



  • Danke für deine Antwort 😋
    Gibt es noch eine andere Möglichkeit bzw. Befehl



  • Du musst Dir doch nur eine kleine Funktion schreiben, die testet, ob find npos zurückgibt oder nicht:

    bool stringContainsChar(const std::string& s, char c)
    {
        return (s.find(c) != std::string::npos);
    }
    

    (Ist nicht getestet, aber sowas in der Art suchst Du wohl.)



  • nman schrieb:

    Du musst Dir doch nur eine kleine Funktion schreiben, die testet, ob find npos zurückgibt oder nicht:

    bool stringContainsChar(const std::string& s, char c)
    {
        return (s.find(c) != std::string::npos);
    }
    

    Aus der Sicht des Anwenders steht dann etwa da:

    std::string myTxt = ..;
        if( stringContainsChar( myTxt, 'x' ) )
        {
            // enthält Zeichen
    

    letztlich ist es besser dasselbe ohne eigene Funktion zu schreiben, also:

    std::string myTxt = ..;
        if( myTxt.find( 'x' ) != std::string::npos ) )
        {
            // enthält Zeichen
    

    Man spart keinen Code mit einer Funktion wie 'stringContainsChar' und jeder der die STL kennt, kann sofort sehen, was der Code wirklich tut. Benutzt man eine selbstgeschriebe Funktion, kann man es vielleicht erahnen, aber es ist unsicher.

    Gruß
    Werner



  • Nix für ungut, aber "bool stringContainsChar(string, char)" ist doch ziemlich eindeutig. Dass die Variante, bei der man jedesmal selbst auf npos prüft, besser sein soll, ist einfach Blödsinn, letztlich nehmen sich die nicht viel.

    Nur weil ich weiß, was der Test auf npos macht, heißt das noch lange nicht, dass nicht ein stringContainsChar intuitiver ist.



  • nman schrieb:

    Nix für ungut, aber "bool stringContainsChar(string, char)" ist doch ziemlich eindeutig.

    Nun ... eindeutig ist z.B. das was im Standard steht. Und stringContainsChar steht nicht im Standard. Und es könnte ja auch sein, dass in 'stringContainsChar' nicht nur nur auf das Zeichen x, sondern auch auf das korrespondierende Upper- bzw. Lowercase-Zeichen geprüft wird. Das weiß ja niemand, der nicht in die Funktion hineingesehen hat.

    Ich persönlich habe mir Funktionen dieser Art abgewöhnt. Nach meiner Erfahrung führen sie eher zu Ver- als zu Entwirrung im Code.

    Gruß
    Werner



  • Werner Salomon schrieb:

    Nun ... eindeutig ist z.B. das was im Standard steht.

    Aber nicht unbedingt intuitiv.

    Und es könnte ja auch sein, dass in 'stringContainsChar' nicht nur nur auf das Zeichen x, sondern auch auf das korrespondierende Upper- bzw. Lowercase-Zeichen geprüft wird.

    Sei mir nicht böse, aber das ist alles völlig an den Haaren herbeigezogen. Du musst sowas ja nicht verwenden, aber anderen davon abzuraten, weil das angeblich so verwirrend ist, ist nicht sinnvoll.



  • Vielen Dank für Eure hilfreichende Antworten,
    denke jetzt kriege ich es hin

    mfg tillt 👍



  • Hallo,
    ob find != npos oder contains ist in meinen Augen ein klassisches "wieviel-Abstraktion-ist-gut"-Problem.
    Man kann wohl sagen:

    // Level 0
    size_t i = 0
    for (; i < str.size() && str[i] != 'x'; ++i) {
      ;
    }
    if (i != str.size()) {  // contains x
    }
    
    // Level 1
    if (str.find('x') != string::npos) {  // contains x
    }
    
    // Level 2
    if (contains(str, x)) {  // contains x
    }
    

    Die erste Variante besitzt gar keine problemspezifische Semantik. Es wird nur das "wie" beschrieben. Das "was" muss man sich komplett selbst erarbeiten. Die zweite Variante abstrahiert die Suche. Damit ist das halb "wie" (Suche und Vergleiche gegen Endposition) und halb "was". Die letzte Variante abstrahiert den Algo komplett. Es bleibt nur noch das "was".

    Variante 0 würde ich *grundsätzlich* nicht verwenden. Die Suche in einem String ist eine wiederkehrende Aufgabe, die definitiv in eine Funktion gehört.
    Variante 1, also eine allgemeine Suchfunktion, sollte man imo deshalb auf jeden Fall implementieren - da gibt's keine Ausreden.
    Ob man auf die allgemeine Variante noch eine spezifischere Einschränkung draufstülpt, bleibt letztlich Geschmacksache. Mir persönlich gefällt ein contains deutlich besser als ein find() != npos und nach dem dritten find() != npos würde ich mir so eine Funktion schreiben.

    Aber wie gesagt: ich denke auf der Ebene ist es reine Geschmacksache.



  • HumeSikkins schrieb:

    Hallo,
    ...ist in meinen Augen ein klassisches "wieviel-Abstraktion-ist-gut"-Problem. ..

    😮 👍 💡
    Sehr gute Strukturierung, die (auch in anderen Zusammenhängen) wirklich weiterhilft !

    Danke,

    Simon2.


Log in to reply