Maximale Array Größe erreicht?! Was tun...

[otze]

so, ich habe mich mal dran gesetzt und zumindes toberflächlich etwas Ordnung rein gebracht. Irgendwann ist mir aufgefallen, dass du die Größen ansich gar nicht einlesen brauchst, ausser um die Korrektheit der Daten zu überprüfen. Es ginge also nochmal etwas kürzer.

Der Code ist nicht komplett, die Datenmittelung und ausgabe musst du noch selbst programmieren. Aber da skriegste sicher hin. Und 100% hübsch ists auch nicht. Aber schonmal ne ganze Ecke kompakter

#include <fstream>
#include <vector>
#include <limits>
#include <iostream>
#include <string>

using namespace std;

//testet, ob das was jetzt im stream kommt ein "<tag attributeName" ist und ließt bis direkt dahinter. 
bool isAttributeTag(ifstream& f,const char* tag, const char* attributeName){
	string token;
	if(f.get() != '<')
		return false;
	f >> token;
	if (token != tag)
		return false;
	f >> token;

	return token == attributeName;
}

//gibt den Wert des Attributs zurück
size_t getIndepSize(const char* filename,const char* attributeName){
	ifstream f(filename);
    while ( f )
    {
		if(isAttributeTag(f,"indep",attributeName)){
			size_t value;
			f >> value;
			return value;
		}
		f.ignore( numeric_limits< streamsize >::max(), '\n' );
	}
	return -1;
}

//ließt alle Werte nach <tag attributeName ....>
vector<double> readValues(const char* filename,const char* tag, const char* attributeName){
	vector<double> values;
	ifstream f(filename);

        //solange Zeilen ignorieren, bis der Tag gefunden wurde
	while(!isAttributeTag(f,tag,attributeName)){
		f.ignore( numeric_limits< streamsize >::max(), '\n' );
	}
        //die Zeile des Tags ebenso ignorieren
	f.ignore( numeric_limits< streamsize >::max(), '\n' );

        //nun Werte lesen
	double value = 0;
	while ( f >> value){
		values.push_back(value);
	}
	return values;
}

int main(int argc, char *argv[])
{
    const char* filename = "test.dat";

    size_t frequencies = getIndepSize(filename,"acfrequency");
	size_t phases = getIndepSize(filename,"phase_urm_var");
	size_t uqs = getIndepSize(filename,"uq");
	cout<<"Anzahl der Frequenzen: "<<frequencies<<endl;
	cout<<"Anzahl der Phasen: "<<phases<<endl;
	cout<<"Anzahl der Spannungen: "<<uqs<<endl;

	//ab hier ist mir aufgefallen, dass man in dem Dateiformat die Werte oben gar nicht braucht.
	vector<double> ua = readValues(filename,"dep","umeneu");
	vector<double> uq = readValues(filename,"indep","uq");

        //testausgabe
	for(size_t i = 0; i != ua.size();++i){
		std::cout<<ua[i]<<std::endl;
	}
	for(size_t i = 0; i != uq.size();++i){
		std::cout<<uq[i]<<std::endl;
	}
}

Das Problem an der "Papierkorb"-Mentalität ist, dass es echt häufig vor kommt, dass Programme eben nicht im Papierkorb landen. Insbesodnere im Universitären bereich werden solche Programme gerne vom einen zum nächsten Studenten weiter gereicht. Oder in einem viertel jahr möchte jemand wieder so eine Datei lesen. Und der frickelt dann weiter in dem Programm rum, bis wirklich niemand mehr versteht, was da passiert. Das Ganze wird dann fehlerhaft und irgendwann weggeworfen, nachdem das Programm ArbeitsWOCHEN verschlungen hat. Darum machs gleich so, dass es zumindest irgendwelchen Grundstandards genügt.

[Javun]

Erstmal vielen Dank für den neuen Quellcode. Ich habe ihn mir lange angesehen und konnte daraus auch bereits einige Dinge lernen.

Vom Prinzip her ist es doch die gleiche vorgehensweise wie bei mir, nur mit wenigen Änderungen:
-Du verwendest vectoren, in die du erst alle Werte einliest und danach soll dann die Mittlung erfolgen. Ist das denn wirklich sinnvoll? Ist es denn hier nicht besser die Werte direkt beim Auslesen auch schon zu mitteln, so wird doch nur unnötig Speicher belegt, die gar nicht benötigt werden!?
-Du hast Funktionen geschrieben, dadurch muss die Datei auch jedes Mal neu geöffnet werden, wenn man etwas auslesen möchte und es ist nicht möglich alles in einem Rutsch zu machen. Ist das denn sinnvoll?

So nun zu den aufgetretenen Problemen:
Wie kann ich mit vectoren rechnen? Wenn ich Deinem Quellcode folgenden Code hinzufüge zum mitteln der Werte stürzt das Programm ab.

vector<double> um;
    for(size_t i = 0; i != uqs;++i){
               for(size_t j = i*phases*frequencies; j != (i+1)*phases*frequencies;++j){
                          um[i] = um[i] + ua[j];                          
               }                              
               um[i] = um[i] / phases*frequencies;
    }

Und noch eine Frage...Wie sieht es aus, wenn ich jetzt statt normalen double Zahlen, Complexe Zahlen in der Form -3.88856889929e-008+j6.72793836159e-009 in jeder Zeile habe?

[SeppJ]

Javun schrieb:

-Du verwendest vectoren, in die du erst alle Werte einliest und danach soll dann die Mittlung erfolgen. Ist das denn wirklich sinnvoll? Ist es denn hier nicht besser die Werte direkt beim Auslesen auch schon zu mitteln, so wird doch nur unnötig Speicher belegt, die gar nicht benötigt werden!?

Wenn es nicht extrem viele Werte sind, schadet es auch nicht. Wem mangelt es schon an Speicher? In 99% der Fälle möchte man ja hinterher komplexere Sachen machen, als nur alle Werte addieren. Wenn es dich stört, dann kannst du es auch ändern, sollte funktionieren.

-Du hast Funktionen geschrieben, dadurch muss die Datei auch jedes Mal neu geöffnet werden, wenn man etwas auslesen möchte und es ist nicht möglich alles in einem Rutsch zu machen. Ist das denn sinnvoll?

Jain. Dateien öffnen und schließen dauert in der Regel eine halbe Ewigkeit. Daher bloß nicht in der Einleseschleife selber machen! Aber so drei vier mal an unkritischen Stellen wie hier ist ok. Wenn man nicht alles in einem Rutsch lesen kann, bietet es sich, wie oben, an, alles im Arbeitsspeicher zu hinterlege, um dann nötigenfalls mehrmals sehr schnell über diese Daten gehen zu können.

So nun zu den aufgetretenen Problemen:
Wie kann ich mit vectoren rechnen?

Erst einmal gar nicht. Ein std::vector ist ein Vektor im informatischen Sinn und hat gar keine Rechenoperationen. So wie ich dich verstehe, möchtest du aber sowieso auf den Elementen rechnen. Und auf die kannst du wie bekannt zugreifen und mit ihnen recnhen (sofern ihr Datentyp Rechnen erlaubt)

Wenn ich Deinem Quellcode folgenden Code hinzufüge zum mitteln der Werte stürzt das Programm ab.

um hat eine Größe von 0.

Und noch eine Frage...Wie sieht es aus, wenn ich jetzt statt normalen double Zahlen, Complexe Zahlen in der Form -3.88856889929e-008+j6.72793836159e-009 in jeder Zeile habe?

Es gibt eine Klasse std::complex, mit der du alles fertig hast, um mit komplexen Zahlen zu rechnen. Um das Einlesen deines Formates musst du dich aber selber kümmern, die bringt nur Rechenoperationen, keine Lese-/Schreiboperationen. Aber bevor du wieder so eine Parserorgie wie oben veranstaltest, gebe ich dir mal einen (ungetesteten) Tipp. So oder so ähnlich sollte man das lesen können:

double real, imag;
char plus, j;
input_stream >> real >> plus >> j >> imag;
complex<double> value(real, imag);
// Und besser noch prüfen, ob der Stream noch lebt und plus=='+' und j=='j' sind.

[otze]

Javun schrieb:

Vom Prinzip her ist es doch die gleiche vorgehensweise wie bei mir, nur mit wenigen Änderungen:

Wie gesagt: ich habe deinen Code nur aufgeräumt. Ich habe nichts geändert, was mehr als 5 Minuten Denkarbeit erfordert hätte.

-Du verwendest vectoren, in die du erst alle Werte einliest und danach soll dann die Mittlung erfolgen. Ist das denn wirklich sinnvoll? Ist es denn hier nicht besser die Werte direkt beim Auslesen auch schon zu mitteln, so wird doch nur unnötig Speicher belegt, die gar nicht benötigt werden!?

Ist die Speicherauslastung für dein Programm denn Relevant? Also planst du eine Datei einzulesen die mehr als 2GB groß ist? In dem Fall musst du vermutlich eh ganz anders vor gehen.

-Du hast Funktionen geschrieben, dadurch muss die Datei auch jedes Mal neu geöffnet werden, wenn man etwas auslesen möchte und es ist nicht möglich alles in einem Rutsch zu machen. Ist das denn sinnvoll?

Es ist von der Funktionalität her das, was du vorher gemacht hast. Nur aufgeräumt. Einen kompletten Dateiparser zu schreiben hätte die 5 Minuten-Grenze überschritten(zumal die Beschreibung des Dateiformats dafür einfach nicht ausreicht). Wenn man wüsste, dass die Tags immer in der selben Reihenfolge auftauschen, dann könnte man mit 10 Minuten überlegen noch eine einfache Lösung basteln, aber das kannst du ja nun sicherlich auch.

Wie kann ich mit vectoren rechnen?

Du solltest deinem Vektor mitteilen, wie groß er denn überhaupt sein soll. Siehe meinen Code.

Und noch eine Frage...Wie sieht es aus, wenn ich jetzt statt normalen double Zahlen, Complexe Zahlen in der Form -3.88856889929e-008+j6.72793836159e-009 in jeder Zeile habe?

Da brauchst du wohl eine Handlösung. std::complex ließt die Zahl nur als (real,imag) ein. und um einfach 2 doubles hintereinander zu lesen, ist das j an der falschen Stelle (ganz am Ende wäre Knorke).
Wie ich das machen würde:

std::vector<complex<double> > complexNumbers;
double real, imag;
char sign;
f >> real;
sign = f.get();
f.get();//ignoriere j
f >> imag;
if(sign == '-'){
    imag *=-1;
}
complexNumbers.push_back(std::complex<double>(real,imag));

[Javun]

Also wenn ich den vorhandenen Code entsprechend ändere:

vector<double> readComplexNumbers(const char* filename,const char* tag, const char* attributeName){
    vector<complex<double> > complexNumbers;
    ifstream f(filename);

        //solange Zeilen ignorieren, bis der Tag gefunden wurde
    while(!isAttributeTag(f,tag,attributeName)){
        f.ignore( numeric_limits< streamsize >::max(), '\n' );
    }
        //die Zeile des Tags ebenso ignorieren
    f.ignore( numeric_limits< streamsize >::max(), '\n' );

        //nun Werte lesen
    double real, imag;
    char plus, j; 
    while ( f >> >> real >> plus >> j >> imag){
        if(plus == '-'){
             imag *=-1;
        } 
        complexNumbers.push_back(std::complex<double>(real,imag)); 	
    }
    return complexNumbers;
}

Dann bekomme ich folgende Fehlermeldung:

59 O:\Rausch Simu\Unbenannt2.cpp conversion from `std::vector<std::complex<double>, std::allocator<std::complex<double> > >' to non-scalar type `std::vector<double, std::allocator<double> >' requested

Mir ist jedoch nicht ganz klar wo der Fehler liegt?!

Du solltest deinem Vektor mitteilen, wie groß er denn überhaupt sein soll. Siehe meinen Code.

Habe mir Deinen Code angesehen. Aber wo hast Du da definiert wie groß ein vector ist? Bzw. wie macht man sowas?

[Rückgabewert]

In der Signatur der Funktion wird gesagt das es sich beim Rückgabewert um den Typ vector<double> handelt. Tatsächlich 'returnst' du aber einen vector<complex<double> >.

Abhilfe:

vector<complex<double> > readComplexNumbers(const char* filename,const char* tag, const char* attributeName)

lg

[Javun]

Super dank Dir. Nur habe ich jetzt ein Problem beim rechnen mit den complexen vectoren.

#include <fstream>
#include <vector>
#include <limits>
#include <iostream>
#include <string>
#include <complex>

using namespace std;

//testet, ob das was jetzt im stream kommt ein "<tag attributeName" ist und ließt bis direkt dahinter.
bool isAttributeTag(ifstream& f,const char* tag, const char* attributeName){
    string token;
    if(f.get() != '<')
        return false;
    f >> token;
    if (token != tag)
        return false;
    f >> token;

    return token == attributeName;
}

//gibt den Wert des Attributs zurück
size_t getIndepSize(const char* filename,const char* attributeName){
    ifstream f(filename);
    while ( f )
    {
        if(isAttributeTag(f,"indep",attributeName)){
            size_t value;
            f >> value;
            return value;
        }
        f.ignore( numeric_limits< streamsize >::max(), '\n' );
    }
    return -1;
}

//ließt alle Werte nach <tag attributeName ....>
vector<complex<double> > readComplexNumbers(const char* filename,const char* tag, const char* attributeName){
    vector<complex<double> > complexNumbers;
    ifstream f(filename);

        //solange Zeilen ignorieren, bis der Tag gefunden wurde
    while(!isAttributeTag(f,tag,attributeName)){
        f.ignore( numeric_limits< streamsize >::max(), '\n' );
    }
        //die Zeile des Tags ebenso ignorieren
    f.ignore( numeric_limits< streamsize >::max(), '\n' );

        //nun Werte lesen
    double real, imag;
    char plus, j; 
    while ( f >> real >> plus >> j >> imag){
        if(plus == '-'){
             imag *=-1;
        } 
        complexNumbers.push_back(complex<double>(real,imag)); 	
    }
    return complexNumbers;
}

int main(int argc, char *argv[])
{
    const char* filename = "rausch_simu.dat";

    size_t frequencies = getIndepSize(filename,"acfrequency");
    size_t phases = getIndepSize(filename,"phase_urm_var");
    size_t uqs = getIndepSize(filename,"uq");
    cout<<"Anzahl der Frequenzen: "<<frequencies<<endl;
    cout<<"Anzahl der Phasen: "<<phases<<endl;
    cout<<"Anzahl der Spannungen: "<<uqs<<endl;

    //ab hier ist mir aufgefallen, dass man in dem Dateiformat die Werte oben gar nicht braucht.
    vector<complex<double> > ua = readComplexNumbers(filename,"dep","umeneu");
    vector<complex<double> > uq = readComplexNumbers(filename,"indep","uq");
    complex<double> um[uqs];
    for(size_t i = 0; i != uqs;++i){
               um[i] = 0;
               for(size_t j = i*phases*frequencies; j != (i+1)*phases*frequencies;++j){
                             um[i] = um[i] + ua[j];                          
               }                              
               um[i] = um[i] / (phases*frequencies);
    }

        //testausgabe
    for(size_t i = 0; i != ua.size();++i){
        cout<<ua[i]<<endl;
    }
    for(size_t i = 0; i != uq.size();++i){
        cout<<uq[i]<<"----------->"<<endl;
    }
// Dos Fenster nicht schließen
    cin.get();
    cin.get(); 
}

Ergibt den Error:

82 O:\Rausch Simu\Unbenannt2.cpp no match for 'operator/' in 'um[i] / (phases * frequencies)'

Warum kann ich hier nicht teilen? Hat das was mit dem Dateitypen zu tun?

[SeppJ]

Dateitypen? Du meinst wohl Datentypen? Und dann lautet die Antwort: Ja. complex kennt folgende arithmetische Operatoren:
http://www.cplusplus.com/reference/std/complex/complex/operators/
Du siehst, du kannst einen complex<T> durch einen complex<T> oder durch einen T teilen. Bei dir ist T = double. Und wenn du nun durch einen size_t teilen möchtest, dann weiß der Compiler nicht, was er nehmen soll. Wandle deinen size_t in einen double um, zum Beispiel durch Cast oder indem du 1.0 dranmultiplizierst.

[otze]

Javun schrieb:

Habe mir Deinen Code angesehen. Aber wo hast Du da definiert wie groß ein vector ist? Bzw. wie macht man sowas?

oops, gar nicht gesehen, dass ich das nicht mehr drin hatte.

so machst du das:

std::vector<complex<double> > deinVektor(deineVektorgröße);

und das:

complex<double> um[uqs];

ist immer noch falsch.

und mach dich mit Referenzen vertraut:

http://www.cplusplus.com/reference/stl/vector/

dann musst du nicht mehr so im trüben fischen.

[314159265358979]

@SeppJ: Das verstehe ich nicht. complex hat doch einen operator / (complex, double), wieso wird der nicht einfach genommen?

[SeppJ]

314159265358979 schrieb:

@SeppJ: Das verstehe ich nicht. complex hat doch einen operator / (complex, double), wieso wird der nicht einfach genommen?

Ganz ehrlich: Den genaue Mechanismus der hier greift, weiß ich nicht. camper ist der Spezialist, wenn es um die Möglichkeiten und Unmöglichkeiten impliziter Konvertierungen geht. Die Funktion ist jedenfalls definiert als

template<class T> complex<T> operator/(const complex<T>& lhs, const T& val);

Und wenn der COmpiler jetzt auf dein complex<double>/size_t stößt, dann passt das nicht dazu, weil du einmal T=double und einmal T=size_t hättest. Ich meine, beim automatischen Auflösen von Templateargumenten hat der Compiler wenig, bis gar keine Freiheit, was hier bestätigt wird. Aber wie gesagt: Die genaue Regel kann ich nicht auswendig, weil man es so selten braucht. Die Standardspezialisten hier könnten dir bestimmt den genauen Paragraphen zitieren, der dies regelt.

Würdest du operator/<double>(complex_number, size_t_number) schreiben, schaltest du die automatische Herleitung der Templateparameter aus und es greifen wieder die impliziten Konvertierungen wie du sie kennst und es sollte funktionieren.

edit: Jupp:

#include <complex>

int main()
{
  std::complex<double> a;
  a/1.;                        // Geht
  std::operator/<double>(a,1); // Geht
  a/1;                         // Geht nicht
}

[camper]

314159265358979 schrieb:

@SeppJ: Das verstehe ich nicht. complex hat doch einen operator / (complex, double), wieso wird der nicht einfach genommen?

Den gibt es gerade nicht. Es existiert eine Spezialisierung des Templates

template<class T> complex<T> operator/(const complex<T>&, const T&);

mit dieser Form für T=double.
Problem hierbei ist, wie von SeppJ schon dargestellt, dass sich dieses T nicht eindeutig aus dem Funktionsaufruf ableiten lässt (T=size_T wäre schließlich genauso möglich). Also wird diese Spezialisierung gar nicht erst betrachtet.

[314159265358979]

Achja genau, da war doch diese Template-Regel. Danke

[Javun]

Vielen Dank für die ganzen Tipps. Ich habe den Quellcode dementsprechend angepasst und er funktioniert jetzt auch. Leider jedoch noch nicht ganz korrekt. Beim Auslesen der Datei werden zwar ca. die ersten 2100 Zeilen korrekt ausgelesen und in den complexen vector ua geschrieben. Die folgenden Werte werden jedoch anscheinend nicht ausgelesen bzw. nicht korrekt ausgelesen, da ich bei Ausgabe den Wert (0,0) angezeigt bekomme.

Daher vermute ich Mal, dass etwas mit einer Auslese Funktion nicht stimmt:

vector<complex<double> > readComplexNumbers(const char* filename,const char* tag, const char* attributeName){
    vector<complex<double> > complexNumbers;
    ifstream f(filename);

        //solange Zeilen ignorieren, bis der Tag gefunden wurde
    while(!isAttributeTag(f,tag,attributeName)){
        f.ignore( numeric_limits< streamsize >::max(), '\n' );
    }
        //die Zeile des Tags ebenso ignorieren
    f.ignore( numeric_limits< streamsize >::max(), '\n' );

        //nun Werte lesen
    double real, imag;
    char plus, j; 
    while ( f >> real >> plus >> j >> imag){
        if(plus == '-'){
             imag *=-1;
        } 
        complexNumbers.push_back(complex<double>(real,imag)); 	
    }
    return complexNumbers;
}

[otze]

na, dann schau dir doch mal die Zeile 2100 an und schau, ob da nicht vielleicht irgendwas anders ist?

[Javun]

otze schrieb:

na, dann schau dir doch mal die Zeile 2100 an und schau, ob da nicht vielleicht irgendwas anders ist?

otze schrieb:

na, dann schau dir doch mal die Zeile 2100 an und schau, ob da nicht vielleicht irgendwas anders ist?

Vom Prinzip ist eigentlich nichts anders das ist ja gerade das komische. Deswegen habe ich auch vermutet, dass irgendetwas an der Auslesefunktion nicht stimmt...

Habe es nun mit einer anderen Datei ausprobiert, die zwar andere Werte enthält, aber natürlich genauso aufgebaut ist. Da stürzt das Programm leider ab

Also irgendwo muss da noch ein Fehler drinstecken...

#include <fstream>
#include <vector>
#include <limits>
#include <iostream>
#include <string>
#include <complex>

using namespace std;

//testet, ob das was jetzt im stream kommt ein "<tag attributeName" ist und ließt bis direkt dahinter.
bool isAttributeTag(ifstream& f,const char* tag, const char* attributeName){
    string token;
    if(f.get() != '<')
        return false;
    f >> token;
    if (token != tag)
        return false;
    f >> token;

    return token == attributeName;
}

//gibt den Wert des Attributs zurück
size_t getIndepSize(const char* filename,const char* attributeName){
    ifstream f(filename);
    while ( f )
    {
        if(isAttributeTag(f,"indep",attributeName)){
            size_t value;
            f >> value;
            return value;
        }
        f.ignore( numeric_limits< streamsize >::max(), '\n' );
    }
    return -1;
}

//ließt alle Werte nach <tag attributeName ....>
vector<complex<double> > readComplexNumbers(const char* filename,const char* tag, const char* attributeName){
    vector<complex<double> > complexNumbers;
    ifstream f(filename);

        //solange Zeilen ignorieren, bis der Tag gefunden wurde
    while(!isAttributeTag(f,tag,attributeName)){
        f.ignore( numeric_limits< streamsize >::max(), '\n' );
    }
        //die Zeile des Tags ebenso ignorieren
    f.ignore( numeric_limits< streamsize >::max(), '\n' );

        //nun Werte lesen
    double real, imag;
    char plus, j; 
    while ( f >> real >> plus >> j >> imag){
        if(plus == '-'){
             imag *=-1;
        } 
        complexNumbers.push_back(complex<double>(real,imag)); 	
    }
    return complexNumbers;
}
//ließt alle Werte nach <tag attributeName ....>
vector<double> readValues(const char* filename,const char* tag, const char* attributeName){
    vector<double> values;
    ifstream f(filename);

        //solange Zeilen ignorieren, bis der Tag gefunden wurde
    while(!isAttributeTag(f,tag,attributeName)){
        f.ignore( numeric_limits< streamsize >::max(), '\n' );
    }
        //die Zeile des Tags ebenso ignorieren
    f.ignore( numeric_limits< streamsize >::max(), '\n' );

        //nun Werte lesen
    double value = 0;
    while ( f >> value){
        values.push_back(value);
    }
    return values;
} 

int main(int argc, char *argv[])
{
    const char* filename = "rausch_simu.dat";

    size_t frequencies = getIndepSize(filename,"acfrequency");
    size_t phases = getIndepSize(filename,"phase_urm_var");
    size_t uqs = getIndepSize(filename,"uq");
    cout<<"Anzahl der Frequenzen: "<<frequencies<<endl;
    cout<<"Anzahl der Phasen: "<<phases<<endl;
    cout<<"Anzahl der Spannungen: "<<uqs<<endl<<endl;

    //ab hier ist mir aufgefallen, dass man in dem Dateiformat die Werte oben gar nicht braucht.
    vector<complex<double> > ua = readComplexNumbers(filename,"dep","umeneu");
    vector<double> uq = readValues(filename,"indep","uq");
    vector<complex<double> > um(uqs);
    double var = phases*frequencies;

    for(size_t i = 0; i != uqs-1;++i){
               um[i] = 0;
               for(size_t j = (i*var); j != ((i+1)*var);++j){
                             um[i] = um[i] + ua[j];          
               }                              
               um[i] = um[i] / var;
    }
        //testausgabe
    for(size_t i = 0; i != ua.size();++i){
        cout<<ua[i]<<endl;
    } 
/*    for(size_t i = 0; i != uqs;++i){
        cout<<uq[i]<<"----------->"<<um[i]<<endl;
    } */
// Dos Fenster nicht schließen
    cin.get();
    cin.get(); 
}

[otze]

Dann starte das Programm einmal mit deinem Debugger und überprüfe dnan, in welcher Zeile es abstürzt.

[Javun]

otze schrieb:

Dann starte das Programm einmal mit deinem Debugger und überprüfe dnan, in welcher Zeile es abstürzt.

Verblüffend ist ja, dass das Programm abstürzt, wenn ich es aus Dev-C++ starte, aber wenn ich die .exe so direkt aufrufe stürzt das Programm nicht ab. Auch wenn ich auf Debuggen (Fehlersuche) in Dev-C++ klicke funktioniert das Programm ohne abzustürzen. Klicke ich jedoch auf Kompilieren + Ausführen, dann stürzt das Programm ab.

Komische Welt...

Leider hab ich aber immer noch nicht rausgefunden, wo mein Fehler beim Auslesen der Datei ist?! Ist denn die folgende Funktion so korrekt?

vector<complex<double> > readComplexNumbers(const char* filename,const char* tag, const char* attributeName){
    vector<complex<double> > complexNumbers;
    ifstream f(filename);

        //solange Zeilen ignorieren, bis der Tag gefunden wurde
    while(!isAttributeTag(f,tag,attributeName)){
        f.ignore( numeric_limits< streamsize >::max(), '\n' );
    }
        //die Zeile des Tags ebenso ignorieren
    f.ignore( numeric_limits< streamsize >::max(), '\n' );

        //nun Werte lesen
    double real, imag;
    char plus, j;
    while ( f >> real >> plus >> j >> imag){
        if(plus == '-'){
             imag *=-1;
        }
        complexNumbers.push_back(complex<double>(real,imag));    
    }
    return complexNumbers;
}

[Javun]

Weiß denn keiner Rat?

Habe alles ausprobiert, aber wie gesagt ab einer gewissen Zeile fängt das Programm an die complexen Zahlen nicht mehr korrekt auszulesen, sondern einfach (0,0) zu setzen...Weiterhin ist mir aufgefallen, dass nicht alle Zeilen erfolgreich eingelesen werden. z.B. sind in der Datei 2310 Zeilen die ausgelesen werden müssten, jedoch speichert die Funktion in dem Vector nur 1300 Zeilen...

Wie kann das angehen? Muss doch ein Fehler in meiner Funktion sein?

[Javun]

So ich habe den Fehler nun korrigiert und zumindest das Auslesen der Datei funktioniert jetzt problemlos.

Bei der Mittlung bin ich mir jedoch nicht ganz sicher, da ich da an einigen Stellen komische Ergebnisse herausbekomme. Evt. könnte sich das ja Mal einer ansehen...