also ich bin ein kleiner unscheinbarer Programmierer.
Will es zumindestens werden...
Habe ein Projekt aufgebrummt bekommen.

Programm:

Worte eines Textes sollen aus einer Textdatei eingelesen
und alle Buchstaben in Kleinbuchstaben verwandelt werden.
Danach sollen die Worte sortiert und wieder ausgegeben werden.
Interpunktionen und Zahlen werden dabei ignoriert. Die
Ausgabe soll dabei nach den beiden Anfangsbuchstaben der
Worte gruppiert werden. Innerhalb dieser Gruppen erfolgt die
Ausgabe in umgekehrter alphanumerischer Reihenfolge. Doppelte
Worte werden nur einmal mit der Häufigkeit ihres Auftretens
ausgegeben.

Tja das ist mein Ziel...
umwandeln von groß in klein letter habe ich schon...
**Mein Problem, TXT einlesen und ausgeben und die Sortierung...

Wäre nett wir mir jemand helfen könnte.
Danke im voraus.

Gruß MiKe

HAbe da solch ein code von meiner Lehrerin bekommen.
ich/sie weiss aber auch nicht was die einzelnen funktionen machen.

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

using namespace std;

int main() {
fstream fin( "list.txt" );
string buffer;
string tmp_array[200];
int i=0;
while (fin.good()) {
getline(fin,buffer);
tmp_array[i]=buffer;
i++;
}
fin.close();
return 0;
}

klappt bloß irgendwie nicht. wieso=?

mh... helft mir schnell... bitte...

Mike

Edit, hat sich zwischenzeitlich erledigt

MiKe1990 schrieb:

HAbe da solch ein code von meiner Lehrerin bekommen. ...

...
while (fin.good()) {
getline(fin,buffer);

das ist irreführend. 'getline' liest Zeilen, in der Aufgabe steht, dass Du Worte lesen sollst!

Diese Aufgabe hat ja bei einigen Leuten den sportlichen Ehrgeiz geweckt wie man hier sieht:

Mizar schrieb:

Die Aufgabe kommt mir mehr als bekannt vor:
http://www.c-plusplus.net/forum/viewtopic-var-t-is-227605-and-highlight-is-.html

... und bei mir auch:

#include <algorithm>    // copy
#include <fstream>
#include <iostream>
#include <string>
#include <set>

struct read_alpha
{
    explicit read_alpha( std::string& wort )
        : m_wort( wort )
    {}
    friend std::istream& operator>>( std::istream& in, const read_alpha& rd )
    {
        std::istream::sentry ok( in );
        if( ok )
        {
            typedef std::istream::traits_type Traits;
            std::string wort;
            const std::ctype< char >& ctype_ = std::use_facet< std::ctype< char > >( in.getloc() );
            for( Traits::int_type m = in.rdbuf()->sgetc()       // Lese bis EOF oder Wortende (s.break)
                ; !Traits::eq_int_type( m, Traits::eof() ); m = in.rdbuf()->snextc() )
            {
                const char c = Traits::to_char_type( m );
                if( ctype_.is( std::ctype_base::space, c ) )
                    break;                                      // Abbruch bei Wortende
                if( ctype_.is( std::ctype_base::alpha, c ) )    // nur Buchstaben
                    wort.push_back( ctype_.tolower( c ) );      // ggf. in Kleinbuchstaben wandeln
            }
            swap( rd.m_wort, wort ); // Eingabe übernehmen (Bem.: kann/darf leer sein!)
        }
        return in;
    }
private:
    std::string& m_wort;
};

template< int Limit >
struct MikesOrder
{
    bool operator()( const std::string& a, const std::string& b ) const
    {
        int idx = 0;
        std::string::const_iterator ia = a.begin(), ib = b.begin();
        for( ; ia != a.end() && ib != b.end(); ++ia, ++ib, ++idx )
        {
		    if( *ia < *ib )
			    return idx < Limit;
		    else if( *ib < *ia )
			    return idx >= Limit;
        }
	    return (idx < Limit && ia == a.end() && ib != b.end())
            || (idx >= Limit && ia != a.end() && ib == b.end() );
    }
};

int main()
{
    using namespace std;
    set< string, MikesOrder< 2 > > worte;
    ifstream datei( "input.txt" );
    datei.imbue( locale("german") ); // damit die Umlaute auch als Buchstaben erkannt werden
    for( string wort; datei >> read_alpha( wort ); )
        if( !wort.empty() ) 
            worte.insert( wort );
    copy( worte.begin(), worte.end(), ostream_iterator< string >( cout, "\n" ) );
    return 0;
}

Mit dieser Datei als Input:

Anton rief A als er Annegret sah. 
Rigeros rieselte aller Schnee!
Risiko sagte der schnauzige Riesenbär 5 mal.
Aber nein, aber ja - aber aber ab dafür!

erhält man diese Ausgabe:

a
aber
ab
als
aller
anton
annegret
dafür
der
er
ja
mal
nein
risiko
rigeros
riesenbär
rieselte
rief
sah
sagte
schnee
schnauzige

Tipp an Mike: schreibe zunächst mal ein Programm, welches die Worte aus der Datei in einen vector einliest und anschließend wieder ausgibt.

#include <algorithm> // copy
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <iterator> // ostream_iterator

using namespace std;

int main() 
{
    fstream fin( "list.txt" );
    vector< string > worte;
    for( string wort; fin >> wort; )
        worte.push_back( wort );
    copy( worte.begin(), worte.end(), ostream_iterator< string >( cout, "\n" ) );
    return 0;
}

- versuche nach dem Einlesen die Worte von allen nicht-Buchstaben zu befreien
- dann konvertiere sie zu Kleinbuchstaben
- dann sortiere den vector zunächst alphanumerisch
- dann nach der in der Aufgabe geforderten Methode
- und zum Schluss entferne die doppelten Worte.

.. wenn Du Fragen zu den einzelnen Punkten hast, frage möglichst konkret nach.

Gruß
Werner