Auslesen von komplexen Zahlen aus einer Datei

Du weißt, dass

f.seekg(ios::cur);

Den get-Zeiger auf die aktuelle Position setzt, also rein garnix bewirkt ?
Die Variable var ist übrigens nur ein unnötiger Platzhalter.

Du kannst gleich

if(f.peek() == 'j'){ //...

schreiben.

Und statt

f.seekg((ios::cur)-1); // oder  +1

f.unget(); // oder entsprechend get()

Du kannst natürlich auch ignore() einsetzen, mit dem man auch mehrere Zeichen überspringen kann.

Javun

Danke für die Tipps, aber es ändert leider nichts an der Situation. Es wird immer die gleiche Zeile, Zahl eingelesen.

Vllt. hab ich ja auch nur ein Verständnisproblem damit.

Wenn f.seekg(ios::cur) jetzt auf die Stelle 0 zeigt, dann müsste es doch nach f>>xyz auf eine Stelle X zeigen oder etwa nicht?

f.seekg(ios::cur) zeigt jedoch immer auf die gleiche Stelle und ich verstehe nicht warum...

Javun schrieb:

Wenn f.seekg(ios::cur) jetzt auf die Stelle 0 zeigt, dann müsste es doch nach f>>xyz auf eine Stelle X zeigen oder etwa nicht?

f.seekg(ios::cur) zeigt jedoch immer auf die gleiche Stelle und ich verstehe nicht warum...

Ahh... kennst du denn keinen get-Zeiger ?
Der zeigt immer darauf wo du grad bist mit lesen.
tellg() zeigt dir an, wo er ist, mit seekg() kannst du ihn setzten.

ios::cur ist einfach die aktuelle Position des get-Zeigers.
Wenn du

DeinIfstream.seekg(ios::cur + 1);

schreibst, heißt das, du inkrementierst den get-Zeiger der, bzw. deiner Datei.
Stattdessen könntest du auch

DeinIfstream.ignore();

Schreiben. Damit liest und ignorierst du 1 Zeichen (wenns mehr sein sollen, guck in der Referenz).
Die Funktion get() inkrementiert den get-Zeiger, und gibt dir den gelesenen Wert unformatiert zurück.
peek() macht dasselbe, nur das er den Zeiger nicht inkrementiert.
unget() liest ein Zeichen rückwärts, bzw. der get-Zeiger wird dekrementiert, und der eingelesene Wert wird unformatiert zurückgegeben.

Der Shift-Operator nun, liest den gegebenen Wert ein, und inkrementiert den gZeiger jeweils um die Länge des Eingegebenen + 1.

Bspw: "5050aergaerg!" steht in der Datei.

Liest du einen Integer a mit

DeinFileStream>>a;

ein, ist tellg() (die Position des get-Zeigers) 5 (und a 5050).

Hättest du alles in der Referenz nachlesen können.

Javun

Vom Prinzip her hab ich das alles Verstanden, ich versteh nur nicht ganz was das mit meinem Problem zu tun hat.

Ganz simpel gefragt, wie schaff ich es das er in die nächste Zeile sprint. Vorher hats ja auch funktioniert, dass einzige was ich jetzt ändern wollte, war die Überprüfung ob reel oder komplex. Das funktioniert ja jetzt soweit nur springt er einfach nicht in die nächste Zeile bzw. zur nächsten Zahl...

Deshalb kann ich nur meine Frage wiederholen:

Wenn f.seekg(ios::cur) jetzt auf die Stelle 0 zeigt, dann müsste es doch nach f>>xyz auf eine Stelle X zeigen oder etwa nicht?

f.seekg(ios::cur) zeigt jedoch immer auf die gleiche Stelle und ich verstehe nicht warum...

Wenn cur immer auf die gleiche Stelle zeigt, dann wäre es ja totaler Schwachsinn. Ich habe es so verstanden, dass cur immer auf die aktuelle Position zeigt.

Und wenn ich eben soetwas wie f>>xyz mache, dann muss sich diese Postion doch ändern??? Tut sie aber nicht!

ios::cur zeigt auch immer auf die aktuelle Position.
Die Position wird sich bei erfolgreichem Lesen auch erhöhen, wenn du den Shift-Operator nutzt. Wenn du willst, dass er in die nächste Zeile springt, nimm

f.ignore(max_wert, '\n');

Das dürfte dann in die nächste Zeile springen.

Javun

Also irgendwie drehen wir uns im Kreis. Anstatt eine Lösung zu finden treten immer mehr neue Probleme auf.

Ich mein die Problemstellung ist doch simpel.

Ich bin an einer Stelle x, will nun die Stelle x+2 überprüfen und zurückspringen zu x und dann ganz normal mit meinem vorhandenen Routine weitermachen.

Das habe ich hier versucht umzusetzen nur leider will das nicht funktionieren, da cur IMMER auf die gleiche Stelle zeigt, obwohl es das eigentlich nicht sollte...

double real, imag;
    char plus, j, var; 
    int a = 0;
    int b = 0;
    for(int p=0; p<7770; p++){
                f>>real;                 // double Zahl wird erfolgreich gelesen
                f.seekg((ios::cur)+1);   // der Zeiger wird +1 genommen
                var = f.peek();          // es wird das nächste Element gelesen

                if(var == 'j'){          // es wird kontrolliert ob das Element ein j war
                  f.unget();             // nun soll zurückgesprungen werden an das Ende der ausgelesenen double Zahl
                  f>>plus>>j>>imag;      // nun lesen wir den Rest der Zeile aus, beim nächsten Durchlauf soll nun auch die nächste Zahl/Zeile gelesen werden, aber cur zeigt IMMER auf die gleiche Stelle
                  if(plus == '-'){
                          imag *= -1;
                  }
                }
                else{
                   imag = 0;
                   f.unget(); 
                }
               complexNumbers[p]=complex<double>(real,imag);
    }

SeppJ

Das ist ja nicht mehr auszuhalten, wie hier der Einäugige mit den Blinden über Farbe diskutiert. Ich erbarme mich heute Abend oder morgen mal. Nur damit wir uns recht verstehen:

Du suchst eine Funktion, die aus einem vorgegebenen istream einen std::vector<complex> macht? Die Zahlen können dabei in zwei Formaten vorliegen
a) realteil (plus oder minus) j imaginärteil
b) realteil
und sind jeweils durch Zeilenumbruch getrennt. Soweit richtig? Und was markiert das Ende? Wenn etwas kommt, das nicht diesem Format entspricht?

Javun

SeppJ schrieb:

Das ist ja nicht mehr auszuhalten, wie hier der Einäugige mit den Blinden über Farbe diskutiert. Ich erbarme mich heute Abend oder morgen mal. Nur damit wir uns recht verstehen:

Du suchst eine Funktion, die aus einem vorgegebenen istream einen std::vector<complex> macht? Die Zahlen können dabei in zwei Formaten vorliegen
a) realteil (plus oder minus) j imaginärteil
b) realteil
und sind jeweils durch Zeilenumbruch getrennt. Soweit richtig? Und was markiert das Ende? Wenn etwas kommt, das nicht diesem Format entspricht?

Das ist alles soweit korrekt.

Beendet wird das ganze durch "</indep>", das ist die Zeile nach der letzten Zahl. Es liegt jedoch auch die Anzahl der insgesamt auszulesenden Zahlen vor. Letztlich geht es daher nur um die for()-Schleife...

Was anderes kann nicht vorkommen, es liegt entweder eine komplexe oder eine reele Zahl vor!

SeppJ

Javun schrieb:

Beendet wird das ganze durch "</indep>", das ist die Zeile nach der letzten Zahl. Es liegt jedoch auch die Anzahl der insgesamt auszulesenden Zahlen vor.

Ahh, ok. Merkwürdiges Format, wo die Anzahl der werte drinsteht, aber das macht die Sache sogar noch einfacher.

Letztlich geht es daher nur um die for()-Schleife...

Bei diesem Monsterthread (und das ist ja schon der 2. zu diesem Thema) habe ich den Eindruck, dass fehlende Abstraktion das Problem ist. Alles hübsch in Unterprobleme eingeteilt würde alles viel einfacher und insgesamt kürzer machen. Ich erinnere mich noch mit Grauen an das Monstrum aus deinem vorherigen Thread.

Was anderes kann nicht vorkommen, es liegt entweder eine komplexe oder eine reele Zahl vor!

Ausgezeichnet. Habe gerade keine Zeit, aber morgen. Sollte schnell gehen und dürfte nicht lang werden.

Javun

Ersteinmal vielen Dank, dass Du Dir die Mühe machen möchtest. Aber ich würde auch schon gern erfahren, wo denn mein Fehler genau liegt.

Im Großen und Ganzen funktioniert ja soweit alles. Einziges Problem ist momentan die Unterscheidung von reelen und komplexen Zahlen. Ich habe es versucht mit den Tipps der anderen User hier zu lösen, jedoch bin ich hier zu keinem "richtigen" Ergebnis gekommen.

Für einen geübten Programmierer ist der Fehler bestimmt in weniger als einer Minute gefunden, deswegen würde ich mich sehr freuen, wenn mir jmd. evt. Heute noch einen Tipp geben könnte...

double real, imag;
    char plus, j, var;
    int a = 0;
    int b = 0;
    for(int p=0; p<7770; p++){
                f>>real;                 // double Zahl wird erfolgreich gelesen
                f.seekg((ios::cur)+1);   // der Zeiger wird +1 genommen
                var = f.peek();          // es wird das nächste Element gelesen

                if(var == 'j'){          // es wird kontrolliert ob das Element ein j war
                  f.unget();             // nun soll zurückgesprungen werden an das Ende der ausgelesenen double Zahl
                  f>>plus>>j>>imag;      // nun lesen wir den Rest der Zeile aus, beim nächsten Durchlauf soll nun auch die nächste Zahl/Zeile gelesen werden, aber cur zeigt IMMER auf die gleiche Stelle
                  if(plus == '-'){
                          imag *= -1;
                  }
                }
                else{
                   imag = 0;
                   f.unget();
                }
               complexNumbers[p]=complex<double>(real,imag);
    }

Sag mal, das j kannst du genauso am Anfang und nicht mitten im Einzulesenen "String" platzieren.
Dann kannst du gleich zu Anfang sehen, ob du auch eine imaginäre Zahl einliest.

Also sähen deine Zahlen so aus:

j-9.35124373769e-017-1.53956708493e-017

Probier mal sowas in der Art:

char  j;// Wofür ist das ?
    int a = 0, b = 0;//Wofür auch immer die da sind ...
    for(int p=0; p<7770; p++)
	{
                double real, imag;
				char var= f.get();
                f>>real;                 // double Zahl wird gelesen

                if(var == 'j')	
                  f>>imag; //Brauchst du hier überhaupt ein plus Char ?

                else
                   imag = 0;

               complexNumbers.at(p)=complex<double>(real,imag);
    }

Javun

Hacker schrieb:

Sag mal, das j kannst du genauso am Anfang und nicht mitten im Einzulesenen "String" platzieren.
Dann kannst du gleich zu Anfang sehen, ob du auch eine imaginäre Zahl einliest.

Also sähen deine Zahlen so aus:

j-9.35124373769e-017-1.53956708493e-017

Probier mal sowas in der Art:
char  j;// Wofür ist das ?
    int a = 0, b = 0;//Wofür auch immer die da sind ...
    for(int p=0; p<7770; p++)
	{
                double real, imag;
				char var= f.get();
                f>>real;                 // double Zahl wird gelesen
   
                if(var == 'j')	
                  f>>imag; //Brauchst du hier überhaupt ein plus Char ?
                
                else
                   imag = 0;
                
               complexNumbers.at(p)=complex<double>(real,imag);
    }

Leider auch hier immer das gleiche Ergebnis, es wird die gleiche Zeile immer und immer wieder ausgelesen...

Hey,

also hör mal auf SeppJ,

ansonsten solange:

A) Du kennst anfang und ende deiner Zahlenspalte
--- Dann kopier die doch in einen seperaten string

Du weißt das deine Spalte vieeeeele Zeilen hat die alle mit \n Enden?
--- Dann nutze Doch folgendes:

std::string strTextWoAlleZahlenLiegen;
 std::vector<std::string> vecVieeeeeleZahlen;
  //...
 unsigned int zaehler=0;
 if(std::string::npos==zaehler=strTextWoAlleZahlenLiegen.find('\n'))
 { 
    std::cout<<"ERROR";
   }
else
  vecVieeeeeleZahlen.push_back(strTextWoAlleZahlenLiegen.substr(zaehler));

nun haste dann einen vector voller string's die jeweils eine Zahl beinhalten.

Was musste nun tun?
Die Funktion

std::string::find

kennst Du ja mitlerweile, suche also nach einem j
(mit der annahme das das Format kontinuierlich gleich ist)
und schon weisst Du welche Zeile eine Imaginäre und welche Zeile nur einen Realteil enthält.

Nun Kannst Du mit dieser Fallunterscheidung die jeweilige Zeile entsprechend Parsen...

sei gegrüßt

Werner Salomon

SeppJ hat völlig recht. Das kann man einfach nicht so weiter laufen lassen. Javun hat ja auch schon fest estellt, dass Ihr Euch hier im Kreis dreht.

Hallo Javun,
ich werde versuchen es Dir zu erklären. Schritt für Schritt und in mehreren Lektionen. Erstmal was grundsätzliches - versuche Dein Problem immer(!) in mehrere Teilprobleme zu zerlegen. Wenn Du also eine komplizierte Datei einlesen willst, so versuche zunächst die einzelnen Elemente - z.B. hier eine komplexe Zahl - für sich zu lesen. Lesen aus einer Datei heißt lesen aus einem std::ifstream und da dies ein std::istream ist, ist das Lesen wie von std::cin. Das macht keinen Unterschied für da Einlesen an sich.
Auch das kann man noch in kleinere Teile zerlegen. In Deinem Fall in vier: den Realteil, den Operator+/-, das 'j' und den Imaginärteil.

Ich fange ganz einfach an, mit Dingen, die Du schon kennen solltest, wie ich hier gesehen habe:

// --  Lektion 1
#include <iostream>
#include <complex>

int main()
{
    using namespace std;
    cout << "eine imaginaere Zahl bitte: z.B.: -9.351e-017-j1.539e-017 " << endl;
    double real, imag;
    char plus, imagChar;
    while( cin >> real >> plus >> imagChar >> imag )
        cout << "gelesen: " << complex< double >( real, plus == '+'? imag: -imag ) << endl;
    return 0;
}

einfach die vier genannten Dinge als double bzw. char einlesen und eine komplexe Zahl daraus machen. Ein Test ergibt:

eine imaginaere Zahl bitte: z.B.: -9.351e-017-j1.539e-017
-9.351E-017-j1.539e-017
gelesen: (-9.351e-017,-1.539e-017)
0+j0
gelesen: (0,0)
0**2
gelesen: (0,-2)

natürlich ist dem Programm das Zeichen vor dem Realteil egal und beim Operator interessiert nur ob da ein '+' kommt oder was anderes. Das ist noch suboptimal. Aber bevor ich darauf eingehe, kapsele ich diese Funktionalität und zwar mit dem Ziel, so etwas hinschreiben zu können:

complex< double > z;
    while( cin >> /*mal sehn*/( z ) )
        cout << "gelesen: " << z << endl;

weil später, da wo das benutzt wird, will ich mich nicht mehr mit dem detailliertem Format herumschlagen, sondern einfach nur eine komplexe Zahle einlesen, so wie ich ein double lese.

(gleich geht's weiter)

Javun

Vielen Dank für die ausführliche Erklärung

Soweit hatte ich das ja bereits, danach ist mir aufgefallen, dass sowohl reele als auch komplexe Zahlen vorkommen können. Nun geht es um diese Fallunterscheidung...

Ich hab es probiert, aber anscheind war ich da auf dem falschen Weg. Die Möglichkeit erstmal alle Zeilen als string auszulesen und dann zu verarbeiten ist mir bewusst und so sah es auch in der 1. Version des Programmes aus. Nur wurde mir dann von so vielen Usern geraten das auslesen und verarbeiten direkt zu machen, dass ich das nun so umgesetzt habe...

Problem ist nur das ich an dieser Stelle jetzt nicht weiterkomme...

Werner Salomon

Hallo Javun,

wie bereits angekündigt, suche ich eine Möglichkeit das Einlesen einer komplexen Zahl ähnlich aufzurufen, wie das z.B. das Lesen eines double. Der Trick besteht nun darin, dass man sich eine kleine Hilfsstruktur baut, die in in Ihrem Konstruktor eine komplexe Zahl aufnimmt - genauer deren Referenz - und das Einlesen implementiert.

Angenommen da ist eine struct ComplexReader und ich möchte ein Objekt von ComplexReader einlesbar machen, so schreibe ich für ComplexReader einen sogenannten Streaming-Operator.

struct ComplexReader {
    friend std::istream& operator>>( std::istream in, ComplexReader& cr ) {
        // .. hier kann ich lesen was ich will
        return in;
    }
};

Dann bin ich in der Lage so was hinzu schreiben:

ComplexReader cr1;
    if( cin >> cr1 ) {
        // cr1 wurde ohne Fehler gelesen

Jetzt kann man so einem Objekt vor dem lesen natürlich noch eine Referenz mitgeben. Das ganze nochmal

struct ComplexReader {
    ComplexReader( std::complex<double>& z )
        : m_target( z )
    {}
    friend std::istream& operator>>( std::istream in, ComplexReader& cr ) {
        // .. hier kann ich lesen und das Ergebnis nach cr.m_target schreiben
        return in;
    }
private:
    std::complex<double>& m_target;
};

Dann kann man schreiben:

complex<double> z;
    ComplexReader cr1( z );
    if( cin >> cr1 ) {
        // cr1 wurde ohne Fehler gelesen; d.h. 'z' enthält jetzt den gelesen Wert

Das schreibt sich natürlich besser und übersichtlicher in einer Zeile:

complex<double> z;
    if( cin >> ComplexReader( z ); ) {
        // 'z' enthält jetzt den gelesen Wert

und - Oh Schreck das übersetzt nicht. Zumindest nicht mit einem Standard konformen Compiler. Ich will gar nicht erklären warum - das führt uns vom Thema weg.
Die Lösung besteht darin, den Parameter cr im Streaming-Operator const zu machen oder cr per Value zu übergeben. Da das Objekt cr beim Einlesen gar nicht verändert wird, ist dies ohne weiteres möglich.

Gleichzeitig mache ich aus ComplexReader noch ein Template, da std::complex ja auch ein Template ist. Lass Dich davon nicht abschrecken, denke einfach, das T wäre ein double oder float, dann bleibt alles wie gewohnt.

// --   Lektion 2
#include <iostream>
#include <complex>

template< typename T >
struct ComplexReader
{
    typedef T value_type;
    ComplexReader( std::complex< value_type >& target )
        : m_target( target )
    {}
    friend std::istream& operator>>( std::istream& in, ComplexReader cr ) // Bem.: Übergabe Parameter 'cr' per Value
    {
        double real, imag;
        char plus, imagChar;
        if( in >> real >> plus >> imagChar >> imag )
            cr.m_target = std::complex< double >( real, plus == '+'? imag: -imag );
        return in;
    }
private:
    std::complex< value_type >& m_target;
};

int main()
{
    using namespace std;
    cout << "eine imaginaere Zahl bitte: z.B.: -9.351e-017-j1.539e-017 " << endl;
    complex< double > z;
    while( cin >> ComplexReader< double >( z ) )
        cout << "gelesen: " << z << endl;
    return 0;
}

an der Funktionalität hat sich gegenüber Lektion 1 nichts geändert, aber das Einlesen der komplexen Zahl geschieht nur noch in dem Streaming-Operator von ComplexReader. Und das ist die Baustelle für die nächsten Lektionen.

Bevor es weiter geht, beseitige ich noch eine Unschönheit: ComplexReader< double >( z ) ist ein redundanter Ausdruck. Es steht double davor und z ist (und muss) ein complex<double> (sein). Das kann der Compliler für uns erledigen; mit einer sogenannten Factory-Funktion.

template< typename T >
ComplexReader< T > read_complex( std::complex< T >& z )
{
    return ComplexReader< T >( z );
}

und das Einlesen wird zu:

while( cin >> read_complex( z ) )

.. und in der nächsten Lektion geht es wirklich um das Lesen.

Werner Salomon

Javun schrieb:

Soweit hatte ich das ja bereits, danach ist mir aufgefallen, dass sowohl reele als auch komplexe Zahlen vorkommen können. Nun geht es um diese Fallunterscheidung...

Geduld

Lies immer bis zum nächsten Plus alles in einen String und nutze dann eine weitere Funktion/Methode für die Fallunterscheidung.

Die könnte dann z.B. so aussehen(Pseudocode):

MyFunction(string complex_number)
{
REAL a = 0 ,b = 0;
std::string::iterator it = complex_number.begin();
IT LAUFEN LASSEN BIS j auftritt(am ende hört er automatisch auf)
Substring auslesen und umwandeln
if(j aufgetreten)
read zahlen und wandele sie um

a = wert des ersten substrings
b = wert des zweiten. Wenn kein real oder imaginärteil vorhanden ist, haben a und b ja schon die gewünschten werte.

Werner Salomon

Hallo Javun,

die letzte Lektion hat uns beim Lesen nicht weiter gebracht. Aber es war notwendig, um das Problem wirklich zu isolieren. Manchmal ist das sogar wichtiger als eine guter Algorithmus.
Im diesem Schritt widme ich mich nur dem Operator. Die Lösung ist für die Praxis vielleicht übertrieben, aber ich möchte Dir zeigen, dass man wirklich jedes Problem für sich lösen kann und dann die einzelnen Lösungen gar nicht mehr so schwer zu finden sind. Frei nach dem Motto: "Teile und herrsche"

Da hier eine simpler char nicht mehr ausreicht, baue ich wieder eine Struktur - hier PlusMinus . Da diese nur innerhalb von ComplexReader benötigt wird, mache ich sie lokal.

template< typename T >
struct ComplexReader
{
    struct PlusMinus
    {
        friend std::istream& operator>>( std::istream& in, PlusMinus& pm )
        {
            return in >> pm.m_op;
        }
        bool positive() const { return m_op == '+'; }
    private:
        char m_op;
    };

und das Einlesen ändere ich zu

PlusMinus plus;
        char imagChar;
        if( in >> real >> plus >> imagChar >> imag )
            cr.m_target = std::complex< double >( real, plus.positive()? imag: -imag );

wieder ist die Funktionalität gleich geblieben, aber ich habe das Einlesen des Operators isoliert. Als Operatoren sind nur die Zeichen '+' und '-' erlaubt. Und genau das kann ich hier jetzt überprüfen. Falls das nicht passt, so setze ich das Fehlerflag im std::istream.

Alles zusammen sieht dann so aus:

// --   Lektion 3
#include <iostream>
#include <complex>

template< typename T >
struct ComplexReader
{
    struct PlusMinus
    {
        friend std::istream& operator>>( std::istream& in, PlusMinus& pm )
        {
            if( in >> pm.m_op )
            {
                if( pm.m_op != '+' && pm.m_op != '-' )
                    in.setstate( std::ios_base::failbit );
            }
            return in;
        }
        bool positive() const { return m_op == '+'; }
    private:
        char m_op;
    };

    typedef T value_type;
    ComplexReader( std::complex< value_type >& target )
        : m_target( target )
    {}
    friend std::istream& operator>>( std::istream& in, ComplexReader cr ) // Bem.: Übergabe Parameter 'cr' per Value
    {
        double real, imag;
        PlusMinus plus;
        char imagChar;
        if( in >> real >> plus >> imagChar >> imag )
            cr.m_target = std::complex< double >( real, plus.positive()? imag: -imag );
        return in;
    }
private:
    std::complex< value_type >& m_target;
};
template< typename T >
ComplexReader< T > read_complex( std::complex< T >& z )
{
    return ComplexReader< T >( z );
}

int main()
{
    using namespace std;
    cout << "eine imaginaere Zahl bitte: z.B.: -9.351e-017-j1.539e-017 " << endl;
    complex< double > z;
    while( cin >> read_complex( z ) )
        cout << "gelesen: " << z << endl;
    return 0;
}

und ein kleiner Test zeigt

eine imaginaere Zahl bitte: z.B.: -9.351e-017-j1.539e-017
-9.3124E-002+j1.5E+017
gelesen: (-0.093124,1.5e+017)
9-X5  // das j ist ihm immer noch egal
gelesen: (9,-5)
9?j5
-> Lesefehler kein + und kein -

Du meinst vielleicht, dass man das auch direkt im Streaming-Operator von ComplexReader machen kann, aber der Unterschied ist, dass PlusMinus den Stream auf Fehler setzt, wenn das Format nicht passt, und anschließend nichts mehr gelesen wird. Das hat bei der Analyse des Fehlers und für ein mögliches wieder aufsetzen große Vorteile.

In der nächsten Lektion kommt das 'j dran.

Javun

Warum müsst ihr das denn alles kompliziert machen?! Ich bin Dir wirklich dankbar, dass Du Dir die Mühe machst, aber da ist einfach so viel neues bei, da sitz ich ja noch Wochen dran, wenn ich mir jede Funktion und sowas wie struct, friend usw. beibringen muss.

Ich wollte doch einfach nur Wissen, wo MEIN Fehler liegt, d.h. MEINEN Quellcode korrigieren. Aber seitdem ich hier im Forum bin hab ich meinen Quellcode schon 5 Mal komplett neu geschrieben und ganz ehrlich besser ist er dadurch nicht geworden. Die Fehler sind fast die gleichen, nur mit dem unterschied das ich jetzt jede 10 Zeile nicht mehr verstehe und von daher das Programm nicht anpassen kann.

Also ich bitte ich um einen Tipp, Hilfestellung zu meinen Quellcode.

Was muss in der for()-Schleife stehen und warum? Das wäre wirklich super, wenn mir das jmd. sagen könnte...

Ich habe schon eine Lösung wie ich es machen würde, aber das wird wahrscheinlich 99,999999% der Personen hier im Forum nicht gefallen. Weil es die "Idioten"-Lösung ist. Aber anscheinend scheint das die einzig machbare zu sein, denn ich dreh mich hier die ganze Zeit im Kreis und komm der Lösung kein Stück näher.