Möglichkeit, strings mit mehreren wörtern zu teilen?

[mmm_1482_]

@Schlangenmensch wie kann ich denn auf die einzelnen zeichenketten des string zugreifen?
ich hab im internet noch das gefunden:
char d = s.at(5);
aber bei mir wird das als fehler markiert

[mmm_1482_]

@Th69 es wird zwar nicht explizit gesagt, was der sinn der aufgabe ist, aber ich denke es geht um das splitten eines strings.
ist mit str[0][0] ein mehrdimensionaler array gemeint?

ich hab mich schon an das wort text gewöhnt

[Th69]

@mmm_1482_ sagte in Möglichkeit, strings mit mehreren wörtern zu teilen?:

ist mit str[0][0] ein mehrdimensionaler array gemeint?

Nur indirekt, da du nicht selber alle Dimensionen angegeben hast, da string implizit ein char-Array kapselt (und den Zugriff mittels [x] (bzw. at(x)) anbietet).
Man spricht hier also nicht direkt von einem "mehrdimensionalen Array", obwohl der Zugriff genauso erfolgt (wegen der Möglichkeit der Operator-Überladung in C++).

[DirkB]

@mmm_1482_ Du hast ein Array von Strings.

Bei einem char-Array (auch C-String genannt) musst du die maximale Länge bei der Definition mit angeben.

Bei std::string von C++ musst du das nicht.

Da du aber ein Array von string hast, musst du einen Index benutzen, der aber den ganzen String bezeichnet.

Also s[1].at(5) ist das 6. Zeichen vom 2. string.

[mmm_1482_]

@Th69 oh man ich muss das jetzt alles mal richtig überdenken... das kann was dauern danke

[Swordfish]

@mmm_1482_
Erster Schritt: Funktionen schreiben statt Spaghetticode.
Zweiter Schritt: STL verwenden.

[mmm_1482_]

@DirkB ach cool danke für die info!

[DirkB]

@mmm_1482_ Der Trick ist jetzt, eine Funktion zu schreiben, die einen string zerlegt.

Diese Funktion kannst du mehrmals aufrufen.

[Swordfish]

dub di dub.

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

template<typename T>
void print_wordwise(T begin, T end, std::ostream& os, typename T::value_type separator = ' ')
{
	for (; begin != end; begin = std::find_if(begin, end, [](auto ch) { return !std::isspace(ch); })) {
		while(begin != end && !std::isspace(*begin))  // fuer eine sehr einfache definition von "wort"
			os.put(*begin++);
		os.put(separator);
	}
}

int main()
{
	std::string foo[]{
		"Die Kuh macht muh",
		"Die Katze macht miau",
		"Der Hund macht wau",
	};
	

	for (auto &bar : foo) {
		print_wordwise(bar.begin(), bar.end(), std::cout, '\n');
		std::cout.put('\n');
	}
}

[DirkB]

@Swordfish sagte in Möglichkeit, strings mit mehreren wörtern zu teilen?:

dub di dub.

Das ging ja schnell

[Swordfish]

@DirkB sagte in Möglichkeit, strings mit mehreren wörtern zu teilen?:

Das ging ja schnell

Scherzkeks. Wie oft schreibt man sowas?

Für
@Swordfish sagte in Möglichkeit, strings mit mehreren wörtern zu teilen?:

std::ostream&

will man wahrscheinlich auch einen Template-Parameter.

[Swordfish]

Dieser Beitrag wurde gelöscht!

[mmm_1482_]

@Swordfish das ist echt lieb von dir, aber ich darf solche extras wie auto ostream& usw... gar nicht verwenden.. wenn ich ehrlich bin kann ich es auch gar nicht richtig lesen, obwohl es bestimmt ein besserer lösungsweg ist..
wir dürfe nur array, string und schleifen verwenden. (Auch wenn es für die Aufgabe nicht vorgeschrieben ist, kann ich eine eigene funktion schreiben, aber vieles aus deiner funktion darf ich gar nicht verwenden)
und vieles davon kenne ich gar nicht
zb
ostream ( & ist ne referenz das sehe ich)
diese ganzen doppelpunkte sind wegen der funktionsüberladung da bin mir da aber auch nicht sicher
isspace kenne ich auch nicht..
auto..
wir dürfen keine pointer verwenden...
also ich bin halt echt etwas eingeschränkt

#include <cctype> das dürfen wir gar nicht inkludieren

[Swordfish]

Dann eben ohne das Zeug:

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

int main()
{
	using std::isspace;
	using std::cout;
	using std::string;

	string foo[]{
		"Die Kuh macht muh",
		"Die Katze macht miau",
		"Der Hund macht wau",
	};
	
	for (unsigned i = 0; i < sizeof foo / sizeof *foo; ++i) {
		for (unsigned pos = 0, end = foo[i].length(); pos != end;) {
			while (pos != end && !isspace(foo[i][pos]))
				cout.put(foo[i][pos++]);
			cout.put('\n');

			while (pos != end && isspace(foo[i][pos]))
				++pos;
		}

		std::cout.put('\n');
	}
}

---

Wenn Du std::isspace() nicht verwenden darfst dann schreibst Du Dir eben selbst eine Funktion die rudimentär dasselbe macht.

bool my_isspace(int ch)
{
	return ch == '\t' || ch == '\n' || ch == '\v' || ch == '\f' || ch == '\r' || ch == ' ';
}

[mmm_1482_]

@Swordfish
oha danke

was genau ist damit gemeint (Zeile 17) sizeof foo / sizeof *foo
ist das jetzt ein pointer, oder multiplizierst du da?
diese Art mit [ ...] [... ] haben wir in dieser form echt noch nie verwendet ... wenn ich den code durchgehe verstehe ich einiges, aber einiges nicht
zb auch "cout.put" ich kanne nur cout<<

[mmm_1482_]

@DirkB

cout << str[str_pos].at(l); // aber hier funktioniert es ?

			if (str[str_pos].at(l) == 'x') // warum funktioniert es hier mit den einzelnen zeichen nicht
			{
				cout  << endl;
			}

[DirkB]

@mmm_1482_ sagte in Möglichkeit, strings mit mehreren wörtern zu teilen?:

// aber hier funktioniert es nicht?

was meinst du damit?
Wie äußert sich das?

[mmm_1482_]

@DirkB also zeile 6 wird wirklich jeder buchstabe einzelns ausgegeben, aber in zeile 8 (obwohl genau dieser wert da steht) wird der wert nicht als solches angenommen.
Müsste das in beiden Fällen nicht derselbe Wert sein?

for (; str_pos < text; str_pos++)// gehe jeden string durch
{
	for (; l < str[str_pos].length(); ) // gehe jedes Zeichen des jeweiligen strings durch
	{
		
			cout << str[str_pos].at(l); // aber hier funktioniert es nicht?

			if (str[str_pos].at(l) == 'x') // warum funktioniert es hier mit den einzelnen zeichen
			{
				cout  << endl;
			}
		l++;
	}
	l = 0;
	cout << endl;
	
}

[mmm_1482_]

@DirkB hä auf einmal funktioniert es XD
ach perfekt! das programm läuft danke!