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:

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.)

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

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

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

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.

mfg tillt

// 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.

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.