wie steige ich am besten in das Thema Strings ein? Ich finde Strings in c++ wirklich merkwürdig gelöst, wenn ich mal mit Delphi vergleiche. Was ich in Delphi out of the box an Stringfunktionen hatte, muss ich mir in c++ in Bibliotheken zusammensammeln und überschreite da oft auch noch Grenzen von Datentypen. Der Einstieg ist echt hart, erste Ergebnisse lassen ganz schön auf sich warten...

Ich will Strings der Länge <300 in Variablen schreiben. Erst dachte ich, es sei eine gute Idee, die string-Klasse zu Hilfe zu nehmen, diese scheint mir intuitiver zu sein. Jetzt will ich aber ganz natürliche Operationen darauf machen, wie zum Beispiel tolower(). Das bekomme ich aber nicht auf meine String-Variable angewandt. Wie wende ich es an?

#include <string>
int main(void)
{string test = "Max";}

Also tolower(test) ist schon mal nicht erlaubt. (Ja, ich hatte das included). Ist "Variable" überhaupt der richtige Begriff? Oder sagt man hier "test" ist ein Objekt der Klasse "string". Dann folgt doch für mich daraus, ich kann nur Methoden des Objekts aufrufen? Also in meinem Fall brauche ich eine Lowercase-Funktion, ich würde dann, falls es das geben würde, test.tolower aufrufen? Bin ich für OOP zu alt? Ich glaube mein Problem ist, ich komme total mit Klassen, Funktionen, Konstruktoren, Methoden durcheinander.

Was würdet Ihr im konkreten Fall (Variable und eine Lowercase-Funktion) raten?

Danke, ich hoffe ich nerve nicht zu sehr.

test.c_str()

- Die Memberfunctions (Methoden) von basic_string: http://www.cplusplus.com/reference/string/string/
- Die Algorithmen http://www.cplusplus.com/reference/algorithm/ lassen sich auch auf String-Objekte anwenden, da ein String auch nur ein Container sit.
- Die Stringstreams, sind zum Formatieren und Umwandeln (z.B. von Zahl zu Zeichenkette) sehr nützlich.

Leider ist die Std-Lib von C++ wirklich nicht der König in Sachen String-Manipulation. Wenn du viel mit Strings arbeitest, solltest du dir http://www.boost.org/doc/libs/1_40_0/doc/html/string_algo.html anschauen. Die haben dort sehr viel, auch was für dich: http://www.boost.org/doc/libs/1_40_0/doc/html/string_algo/usage.html#id1685354

Überhaupt gehört Boost auf jeden Rechner eines C++-Proggers.

#include <cctype>
#include <iostream>
int main()
{
    std::string test = "MAX";
    std::cout << test << std::endl; // Ausgabe: MAX
    test = std::tolower(test);
    std::cout << test << std::endl; // Ausgabe: max
    return 0;
}

Also das kann ich mir beim besten Willen nicht vorstellen...
Soweit ich weiß erwartet std::tolower() einen int als Argument...

test = std::tolower(test);

Ich hoffe, dass mein Beispiel funktioniert. Habe momentan kein Compiler bei mir rumliegen um das zu testen...

Genau das war mein Problem. Das tolower() da oben scheint nicht erlaubt zu sein...

"error: cannot convert `std::string' to `int' for argument `1' to `int tolower(int)'"

richtig wäre es so:

#include <iostream>
#include <string>
#include <cctype>

int main()
{
    std::string test = "MAX";
    for ( unsigned int i=0; i < test.size(); i++ )
           test[i]=std::tolower(test[i]);
    std::cout << test << std::endl;   //max
}

Wobei, es sicher bessere Lösungen dafür gibt...

string test="Test String";
for (int i=0;i<test.length();i++) test[i]=tolower(test[i]);

funktioniert die ToLower Funktion so:

#include <cctype>
#include <iostream>
int main()
{
    std::string test = "MAX";
    std::cout << test << std::endl; // Ausgabe: MAX
    test = std::tolower(test);
    std::cout << test << std::endl; // Ausgabe: max
    return 0;
}

Ich hoffe, dass mein Beispiel funktioniert. Habe momentan kein Compiler bei mir rumliegen um das zu testen...

Habe es auch nicht ausprobiert, aber 1. ist es eine C-Funktion (nichts C++-artiges) und 2. konvertiert es nur einen einzelnen Charachter und keine Zeichenkette.
Es ist sowieso blödsinnig jemanden mit C-Krüppelfunktionen anzukommen, wenn er C++ machen will. Weil man hier eigentlich eine for-Schleife bauen müsste:

#include <cctype>
#include <iostream>
int main()
{
    std::string test = "MAX";
    std::cout << test << std::endl; // Ausgabe: MAX
    for(size_t i = 0; i<test.size(); i++)
          test[i] = std::tolower(test[i]);
    std::cout << test << std::endl; // Ausgabe: max
    return 0;
}

Aber sowas findet man fertig in der Boost-String-Algo-Lib.

#include <cctype>

void to_lower(string &str)
{
    for(size_t i = 0; i<str.size(); ++i)
          str[i] = std::tolower(str[i]);
}

Aber Boost ist hier eindeutig lohnenswert, da es nicht nur mit std::string zusammen arbeitet und auch die Locale beachtet!

[http://www.boost.org/doc/libs/1_40_0/doc/html/boost/algorithm/to_lower.html]

void to_lower(WritableRangeT & Input, 
                const std::locale & Loc = std::locale());

"void to_lower". OK, void sagt mir AFAIK "keine Rückgabe". Die Funktion ändert den String direkt. In der Klammer sollte m.E. das Argument stehen. Nur was heißt das darin? Kann mir das jemand erklären? Ich sehe ein Komma, würde also 2 Argumente vermuten. Aber warum 2?

#include <iostream>
#include <string>
#include <algorithm>
#include <locale>

template<typename charT>
class ToLower
{
public:
    ToLower(char const * locale = "")
        : loc(locale)
    { }
    charT operator()(charT c){ return std::tolower(c, loc); }
private:
    std::locale loc;
};

int main()
{
    std::string hallo = "haLLo wELt";
    std::transform(hallo.begin(), hallo.end(), hallo.begin(), ToLower<std::string::value_type>());
    std::cout << hallo << '\n';
}

#include <algorithm>
#include <string>

std::string test = "THIS IS MY STRING";
std::transform(test.begin(), test.end(), test.begin(), std::tolower);

So gehts wohl am besten und am schönsten.

"void to_lower". OK, void sagt mir AFAIK "keine Rückgabe". Die Funktion ändert den String direkt.

Ja. Wenn du eine Kopie haben willst, schau dir to_lower_copy() an.

Squeller schrieb:

In der Klammer sollte m.E. das Argument stehen. Nur was heißt das darin? Kann mir das jemand erklären? Ich sehe ein Komma, würde also 2 Argumente vermuten. Aber warum 2?

Das erste für den zu bearbeitenden String und das zweite für das Locale. Das Locale bestimmt zum Beispiel, welche speziellen Zeichen berücksichtigt werden, also 'ä' in der deutschen und 'é' in der französischen Sprache.

[http://www.boost.org/doc/libs/1_40_0/doc/html/boost/algorithm/to_lower.html]

void to_lower(WritableRangeT & Input, 
                const std::locale & Loc = std::locale());

"void to_lower". OK, void sagt mir AFAIK "keine Rückgabe". Die Funktion ändert den String direkt. In der Klammer sollte m.E. das Argument stehen. Nur was heißt das darin? Kann mir das jemand erklären? Ich sehe ein Komma, würde also 2 Argumente vermuten. Aber warum 2?

Unter Description stehen ja die Bedeutungen der einzelnen Parameter:

Input A range
Loc a locale used for conversion

Wobei du den zweiten Wert nicht explizit angeben mußt, weil der zweite Parameter einen Default-Wert vorgibt:

void to_lower(WritableRangeT & Input, const std::locale & Loc = std::locale());

Nur wenn dir der Default-Wert std::locale() nicht zusagt, gibst du beim Aufruf einen anderen an. In den meisten Fällen dürfte aber std::locale() i.O. sein, da sich dieses nach den Betriebssystem-Einstellungen richtet. Was die Locale ist, weißt Du? Das hat was mit den Zeichencodes für verschiedene Länder und Sprachen zu tun, siehe hier:

http://www.cplusplus.com/reference/std/locale/

Nein, was eine locale ist, habe ich auch nur erahnt... Wie ist das "&" zu verstehen? Hat das was mit Standardwerten zu tun? Mein Problem ist wohl die Komplexität des Ausdrucks. Wenn da jetzt stünde "void ziehbvonaab(int a, int b)" dann ginge es ja...

Ebenso weiß ich noch nicht, wie "WritableRangeT & Input" zu verstehen ist, was ist hier der Datentyp?

template<typename WritableRangeT> // Funktion to_lower erwartet einen genauen Typnamen!!!
void to_lower(WritableRangeT & Input,
                                      const std::locale & Loc = std::locale());

Du mußt als erstes lernen was Templates sind, um WritableRangeT zu verstehen. Bei Templates handelt es sich "nur" um Codeschablonen, die erst zur Compilezeit typisiert werden. Grob gesagt kann WritableRangeT jeder Typ sein, mit dem das Template "kompatibel" ist. Range deutet darauf hin, das es ein Array, String, Vector etc. sein kann. Der vollständige Aufruf müsste so lauten:

string s("HaLLo!");
to_lower<string>(s);     // mit <string> typisiere ich WritableRangeT bzw. das Template

So weiß die Funktion, das s ein String-Objekt ist. Aber da bei solchen einfachen Funktionen der Compiler aus dem übergebenen Wert "s" den Typ string selber feststellen kann, muß man das nicht angeben.

string s("HaLLo!");
to_lower(s);     // <string> setzt der Compiler selbst ein... implizite Typisierung

Der Vorteil von Templates ist, das man Code für verschiedenen Typen benutzen kann. Und man spart sich Copy&Paste in seinem Code. D.h. to_lower kann auch mit Arrays, Vector usw. arbeiten.

Das & steht für By-Reference, also das die Funktion mit dem "original" Objekt arbeitet bzw. dieses manipulieren wird. Weitere Infos gibt es unter http://www.kharchi.eu/wiki/doku.php?id=cpp:std:reference.

Hast du ein vernünftiges C++-Buch, in dem solche Dinge ausführlich und vor allem verständlich erklärt werden? Weil für C++ kommt man mit Try & Error nicht schnell vor ran.

Du mußt als erstes lernen was Templates sind, um WritableRangeT zu verstehen. Bei Templates handelt es sich "nur" um Codeschablonen, die erst zur Compilezeit typisiert werden. Grob gesagt kann WritableRangeT jeder Typ sein, mit dem das Template "kompatibel" ist. Range deutet darauf hin, das es ein Array, String, Vector etc. sein kann. Der vollständige Aufruf müsste so lauten:

string s("HaLLo!");
to_lower<string>(s);     // mit <string> typisiere ich WritableRangeT bzw. das Template

So weiß die Funktion, das s ein String-Objekt ist. Aber da bei solchen einfachen Funktionen der Compiler aus dem übergebenen Wert "s" den Typ string selber feststellen kann, muß man das nicht angeben.

string s("HaLLo!");
to_lower(s);     // <string> setzt der Compiler selbst ein... implizite Typisierung

Der Vorteil von Templates ist, das man Code für verschiedenen Typen benutzen kann. Und man spart sich Copy&Paste in seinem Code. D.h. to_lower kann auch mit Arrays, Vector usw. arbeiten.

Also, geht es darum, dass ich a) einer Funktion dann unterschiedliche, sinnvolle Typen übergeben kann und b) je nach Eingabetyp in der Funktion handeln kann? Bspw. könnte eine Funktion sowohl ein Char-Array als auch einen String bekommen?

Und irgendwas habe ich doch sicher übersehen: an so einer Funktionssignatur "..(WritableRangeT ...) sehe ich doch gar nicht, welche(r) Typ(en) denn nun erlaubt sind?

Das & steht für By-Reference, also das die Funktion mit dem "original" Objekt arbeitet bzw. dieses manipulieren wird. Weitere Infos gibt es unter http://www.kharchi.eu/wiki/doku.php?id=cpp:std:reference.

Hast du ein vernünftiges C++-Buch, in dem solche Dinge ausführlich und vor allem verständlich erklärt werden? Weil für C++ kommt man mit Try & Error nicht schnell vor ran.

Ja, habe ein Buch von Dirk Louis. Muss ich nochmal lesen, ich glaube da stand etwas in der Zeiger-Ecke, eine Giftküche, an der ich schnell vorbeigelesen hatte.

#include <algorithm>
#include <string>

std::string test = "THIS IS MY STRING";
std::transform(test.begin(), test.end(), test.begin(), std::tolower);

ganz ehrlich, merkt ihr es noch? er will einen string per tolower umwandeln und bekommt templates, boost oder qt vorgesetzt. Irgendwas stimmt da doch ganz gewaltig nicht...

C++ ... kompliziertes Denken ... irgendwas war da.

ganz ehrlich, merkt ihr es noch? er will einen string per tolower umwandeln und bekommt templates, boost oder qt vorgesetzt. Irgendwas stimmt da doch ganz gewaltig nicht...

Vielleicht hast du nichts bemerkt, aber es geht hier in diesem Topic schon laaange nicht mehr um "Wie mache ich Zeichen klein?". Es geht hier mittlerweile um C++-Syntax und -Features, am Beispiel von to_lower. Es könnte aber auch jede andere Funktion aus C++ sein! Er hätte bei jeder anderen C++-Funktion die gleichen Fragen gestellt. Er lernt noch C++, das hat nichts mit Boost oder so zu tun. Wer kein C++ kann, wird nun mal solche Fragen stellen. Das er noch kein C++ kann, kann ja wohl C++ oder Boost nichts für.