[/cpp]

#include <iostream>
#include <string>
#include <fstream>

using namespace std;

void satzlesen();

struct satz
{
    int woerter;   
    int vokale;
    int konsonanten;
    int ziffern;
    int leerzeichen;
    int sonderzeichen;
    };

//Eine Enumeration der Zeichenarten. Jeder Zeichenart ist ein int Wert zugeordnet.
//Variablen koennen diese Enumeration als Datentyp benutzen. 
//So werden Ausdruecke wie z.B. zeichenart zeichen1 = ziffer; moeglich
enum zeichenart {vokal = 0, konsonant = 1, ziffer = 2, leerzeichen = 3, sonderzeichen = 4};

//Funktion, die zu implementieren ist
zeichenart zeichenart_von_character(char c)
{

}

//Funktion, die zu implementieren ist

satz satz_aus_string(string einSatz) 
{

}

string ganzersatz;

void satzlesen(string ganzer_text)
{
    int i;
    for (i=0; i < ganzer_text.size() && (ganzer_text[i] != ("." || "?" || "!")); i++)
    {
        ganzersatz[i] = ganzer_text[i];             
        cout << ganzersatz[i];
        }
}

//Der text der .txt-Datei wird als string mit dem namen text eingelesen.
int main ()
{
	string text;
	ifstream infile;
	infile.open ("xy.txt");
	if (!infile.is_open())
	{
        cout << "File open error ";
        cin.get();
        return 1;
        }

	if (infile && !infile.eof()){
		getline(infile, text);
		infile.close();
	}
	satzlesen(text);

    cin.get();
    cin.get();
    return 0;
}

[cpp]

[/cpp]

void satzlesen(const std::string& ganzer_text)
{
    for(int i=0; i < ganzer_text.size() && ganzer_text.at(i) != '.' && ganzer_text.at(i) != '?' && ganzer_text.at(i) != '!'; ++i)
        std::cout << (ganzersatz.at(i) = ganzer_text.at(i));
}

Edit: so isses schöner

ganzer_text[i] != '.' && ganzer_text[i] != '?' && ganzer_text[i] != '!')

Einfacher wäre jedoch die Verwendung von isalpha() aus <cctype> (um nur alle Buchstaben als Wort zuzulassen).
Schau dir für deine weiteren Aufgaben (Ziffern, Leerzeichen, etc.) auch die anderen Funktionen aus <cctype> an...

[code]

#include <iostream>
#include <string>
#include <fstream>

using namespace std;

void satzlesen();

struct satz
{
    int woerter;   
    int vokale;
    int konsonanten;
    int ziffern;
    int leerzeichen;
    int sonderzeichen;
    };

//Eine Enumeration der Zeichenarten. Jeder Zeichenart ist ein int Wert zugeordnet.
//Variablen koennen diese Enumeration als Datentyp benutzen. 
//So werden Ausdruecke wie z.B. zeichenart zeichen1 = ziffer; moeglich
enum zeichenart {vokal = 0, konsonant = 1, ziffer = 2, leerzeichen = 3, sonderzeichen = 4};

//Funktion, die zu implementieren ist
zeichenart zeichenart_von_character(char c)
{

}

//Funktion, die zu implementieren ist

satz satz_aus_string(string einSatz) 
{

}

//*************************************************************************************************************************************************

int j =0; //definieren 2er globalen variablen
int o =0;

string saetze[22]; //Definieren eines String Arrays und eines Strings. Text hat 22 saetze.
string ganzersatz;

void satzlesen(string ganzer_text)
{
    while (j<22)
    {

    int i =0;     
    if (j ==0)//Beim ersten Druchgang wird diese if anweisung ausgefuehrt.
    {
        for (; i < ganzer_text.size() && (ganzer_text[i] != '.' && ganzer_text[i] != '?' && ganzer_text[i] != '!'); i++)
        {
            ganzersatz[i] = ganzer_text[i];             
            }
        }

    i =0;

    if (j >0)//bei allen anderen Durchgaengen wird nur noch diese if anwisung ausgefuehrt
    {    
         for (int k=o; k < ganzer_text.size() && (ganzer_text[k] != '.' && ganzer_text[k] != '?' && ganzer_text[k] != '!'); k++)
         {
             ganzersatz[i] = ganzer_text[k];             
             }
         }

    saetze[j] = ganzersatz;
    o = o + saetze[j].size();
    ganzersatz = "";
    j++;
    }       
    }        

//*************************************************************************************************************************************************        

int main ()
{
	string text;
	ifstream infile;
	infile.open ("ETH.txt");
	if (!infile.is_open())
	{
        cout << "File open error ";
        cin.get();
        return 1;
        }

	if (infile && !infile.eof()){
		getline(infile, text);
		infile.close();
	}
	satzlesen(text);

	cout << "Welchen Satz wuerden sie gerne ausgeben?\n";

	int z;
	cin >> z;

	cout << "\n";	
    cout << saetze[z];

    cin.get();
    cin.get();
    return 0;
}

Setz dich nochmal mit theorethischer Informatik auseinander

So, das ist der Fehler: nach dem ersten durchgang wird j inkrementiert (siehe zeile 76). Dann wird j natürlich positiv, also kann nur noch die zweite abfrage richtig sein (zeile 65).

Und @Praktisc...: Das, worum boolsche algebra geht nennt man 't' 'h' 'e' 'o' 'r' 'e' 't' 'i' 's' 'c' 'h' 'e' Informatik

Man könnte noch die Leerzeichen am Satzanfang löschen lassen, aber dazu hatte ich jetzt keine Lust mehr

Und @Praktisc...: Das, worum boolsche algebra geht nennt man 't' 'h' 'e' 'o' 'r' 'e' 't' 'i' 's' 'c' 'h' 'e' Informatik

Es ging ihm wohl eher um die falsche Rechtschreibung.

Also:
Theoretischer Informatik
und
Boolesche algebra

#include <iostream>
#include <vector>
#include <string>

std::vector<std::string> ExtrahiereSaetze(std::string text, bool satzzeichen = true);

int main()
{
	std::string eingabe = "Hey, dies ist ein Satz. Und dies ist gleich noch ein Satz. Test! 1, 2, 3. Na ja, so geht das dann weiter, denke ich. Oder auch nicht?";

	std::vector<std::string> saetze(ExtrahiereSaetze(eingabe, true)); // Per Konstruktor übergeben

	for (const std::string &ref: saetze)// Range-based-for
		std::cout << ref << '\n'; // Endl unnötig
}// Kein return

std::vector<std::string> ExtrahiereSaetze(std::string text, bool satzzeichen)
{
	std::vector<std::string> saetze;

	std::size_t pos = 0, last = 0;

	while ((pos = text.find_first_of("!?.", pos + 1)) != std::string::npos)
	{
		saetze.push_back(text.substr(last, pos - last + satzzeichen ));// Ternärer Operator unnötig
		last = pos + 1;
	}

	return saetze;
}

Hast du bei JW gelernt?

P.S.: Für das entfernen der Leerzeichen wäre nicht viel Arbeit von Nöten gewesen:

std::vector<std::string> ExtrahiereSaetze(std::string text, bool satzzeichen)
std::vector<std::string> ExtrahiereSaetze(std::string text, bool satzzeichen = true)
{
	std::vector<std::string> saetze;

	size_t pos = 0, last = 0;

	while ((pos = text.find_first_of("!?.", pos + 1)) != std::string::npos)
	{
		saetze.push_back(text.substr(last, ((text.length()-1 > pos && text.at(pos+1) == ' ') ? ++pos : pos) - last + satzzeichen )); 
// Mit dem Ternären Operator abfragen: Sind wir am Ende des Satzes? Wenn nicht, ist das nächste Zeichen ein White-Space?
		last = pos + 1;
	}

	return saetze;
}

Hacker kriegt heute den preis für den lesbarsten Code des jahrhunderts

Schon von Malbolge gehört?

Schon von Malbolge gehört?

definitiv besser lesbar.

Das Nutzen des Konstruktos von std::vector ist hier vollkommen irrelevant. Das Ergebnis ist das selbe. Einzig die Lesbarkeit leidet unter der zusätzlichen Klammerung.

Das der Ternäre Operator überflüssig ist, war mir klar: Ich habe das nur zum besseren Verständnis hinzugefügt.

Deine For-Schleife ist C++0x und hier nicht gefragt. Wenn es danach geht hätte ich die Ausgabe auch mit std::copy in einer Zeile lösen können. Aber auch hier war mir das Verständnis wichtiger.

Das std::endl unnötig ist, würde ich so nicht sagen. Es gibt Konsolen (insbesondere unter Linux), die einen einmaligen Impuls brauchen. Und da das Programm keine performancekritischen Operationen ausführt, sehe ich diesen Kritikpunkt ohnehin nicht ein.

Das return schreibe ich hier im Forum grundsätzlich immer aus Gründen der Kompatibilität, da viele Anfänger alte Compiler benutzen müssen.

Und das Entfernen des Leerzeichens: Auch hier war mir das Verständnis wichtiger, weshalb ich einen Einzeiler gemeiden habe.

Interessant finde ich aber, dass du alles mögliche kritisierst, was nicht von Bedeutung ist, aber Dinge außen vor lässt, die tatsächlich Sinn gehabt hätten.

Ich kritisiere mich hier mal selber und sage z.B., dass ich den std::string hätte als konstante Referenz übergeben sollen. Hab ich aber aus Gründen des Verständnisses auch nicht getan.

Wie dem auch sei, auf solche Schwanzvergleiche lege ich keinen Wert. Du hast hier aber definitiv den kürzeren gezogen

Nein, ich habe nicht bei JW gelernt. Tatsächlich habe ich das Buch nicht mal ansatzweise berührt.

Sieht aber ein wenig so aus... egal.

fghfgh schrieb:

Das Nutzen des Konstruktos von std::vector ist hier vollkommen irrelevant. Das Ergebnis ist das selbe. Einzig die Lesbarkeit leidet unter der zusätzlichen Klammerung.

Findest du es wahr, zugegebenermaßen, ein sehr stilistischer Kommentar.
Den werd' ich mir künftig verkneifen.

fghfgh schrieb:

Das std::endl unnötig ist, würde ich so nicht sagen. Es gibt Konsolen (insbesondere unter Linux), die einen einmaligen Impuls brauchen. Und da das Programm keine performancekritischen Operationen ausführt, sehe ich diesen Kritikpunkt ohnehin nicht ein.

Also, ich umformuliere meine Aussage bezüglich endl: Willst du, dass der Ausgabepuffer geleert wird?

fghfgh schrieb:

Das return schreibe ich hier im Forum grundsätzlich immer aus Gründen der Kompatibilität, da viele Anfänger alte Compiler benutzen müssen.

Kein Anfänger kann diesen Code verstehen, also wird er auch nicht in der Lage sein, dir zu Helfen und ist damit irrelevant.

fghfgh schrieb:

Interessant finde ich aber, dass du alles mögliche kritisierst, was nicht von Bedeutung ist, aber Dinge außen vor lässt, die tatsächlich Sinn gehabt hätten.

Ich kritisiere mich hier mal selber und sage z.B., dass ich den std::string hätte als konstante Referenz übergeben sollen. Hab ich aber aus Gründen des Verständnisses auch nicht getan.

Du hast Recht, das hätte wirklich Sinn gemacht. Wieso hast du so eine Faustregel ignoriert (ich auch, hab aber den Code nicht geschrieben sondern nur überflogen)? Und hier ist garantiert auch Schluss mit Verständnis! Es ist doch (auch jedem Anfänger) sehr klar, was eine Konstante Referenz ist!?!

fghfgh schrieb:

Wie dem auch sei, auf solche Schwanzvergleiche lege ich keinen Wert. Du hast hier aber definitiv den kürzeren gezogen

Aber definitiv nicht den kürzeren Schwanz

Ab auf die Wiese.

Edit: wo ist meine Rechtschreibung denn falsch?

Hacker ist halt in der Pubertät. Schwierige Phase.

Tja, hast du ein Glück! Du bist noch nicht dadrin.