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

[Javun]

Also mein Quellcode sieht derzeit so aus (keine großartigen Veränderungen zu vorher.

Ich habe den Code schon einige Male durchgesehen, aber ich konnte nicht feststellen, wo die letzte Teile doppelt gelesen wird?

der Größe x erschaffen, sodass das Array auch außerhalb der Schleife verfügbar ist. Das war so ziemlich der Hauptgrund, warum ich es nicht alles in einem Rutsch gemacht habe.

Zu den auftretenden Fehlern. Das ist schwer zu sagen, was da genau schiefläuft. Ich habe das Programm mit bis zu 100 Werten getestet, die alle korrekt gemittelt und ausgegeben wurden. Nun sollen bei den anstehenden Simulationen jedoch ca. 100.000 Werte analysiert werden und genau da treten dann Fehler auf. Wenn ich x zahlen der Form y*10^-9 addiere und dann durch x teile (um zu mitteln), dann kann das Ergebnis wohl kaum z*10^256 sein, dies passiert z.B. bei der 10. Mittlung! Weiterhin bekomme ich an einigen Stellen als Ergebnis -1.#QNAN raus.

#include <fstream>
#include <iostream>
#include <string>
#include <sstream>
#include <cmath>

using namespace std;

int main(int argc, char *argv[])
{  
    ifstream f;                      // Datei-Handle
    string s;                            
    size_t pos1;
    size_t pos2;

// Anzahl der Frequenzen ermitteln
    int acfrequency_anzahl;                         // Anzahl der Frequenzen
    string abgl1 = "<indep acfrequency ";           // Anfang
    string abgl2 = ">";                             // Ende
    f.open("rausch_simu.dat", ios::in);             // Öffne Datei aus Parameter
    while (!f.eof())                                // Solange noch Daten vorliegen
    {
        getline(f, s);                              // Lese eine Zeile
        pos1 = s.find(abgl1);
        pos2 = s.find(abgl2);

        if(pos1 != string::npos && pos2 != string::npos){
                    string acfrequency_str = s.substr(int(pos1)+19, int(pos2)-int(pos1)-1);
                    stringstream acfrequency_ss(acfrequency_str);
                    acfrequency_ss >> acfrequency_anzahl;
                    pos1 = string::npos;
                    pos2 = string::npos;
                    break;
           }
    }
    f.close();                                      // Datei wieder schließen
    cout<<"Anzahl der Frequenzen: "<<acfrequency_anzahl<<endl;

// Anzahl der Phasen ermitteln
    int phase_urm_var_anzahl;                         // Anzahl der Phasen
    abgl1 = "<indep phase_urm_var ";  // Anfang
    abgl2 = ">";                    // Ende
    f.open("rausch_simu.dat", ios::in);             // Öffne Datei aus Parameter
    while (!f.eof())                                // Solange noch Daten vorliegen
    {
        getline(f, s);                              // Lese eine Zeile
        pos1 = s.find(abgl1);
        pos2 = s.find(abgl2);

        if(pos1 != string::npos && pos2 != string::npos){
                    string phase_urm_var_str = s.substr(int(pos1)+21, int(pos2)-int(pos1)-1);
                    stringstream phase_urm_var_ss(phase_urm_var_str);
                    phase_urm_var_ss >> phase_urm_var_anzahl;
                    pos1 = string::npos;
                    pos2 = string::npos;
                    break;
           }
    }
    f.close();                                      // Datei wieder schließen
    cout<<"Anzahl der Phasen: "<<phase_urm_var_anzahl<<endl;

// Anzahl der Eingangsspannungen ermitteln
    int uq_anzahl;                   // Anzahl der unterschiedlichen Spannungsquellen
    abgl1 = "<indep uq ";          
    abgl2 = ">";                  
    f.open("rausch_simu.dat", ios::in);             // Öffne Datei aus Parameter
    while (!f.eof())                                // Solange noch Daten vorliegen
    {
        getline(f, s);                              // Lese eine Zeile
        pos1 = s.find(abgl1);
        pos2 = s.find(abgl2);

        if(pos1 != string::npos && pos2 != string::npos){
                    string uq_str = s.substr(int(pos1)+10, int(pos2)-int(pos1)-1);
                    stringstream uq_ss(uq_str);
                    uq_ss >> uq_anzahl;
                    pos1 = string::npos;
                    pos2 = string::npos;
                    break;
           }
    }
    f.close();                                      // Datei wieder schließen
    cout<<"Anzahl der Spannungen: "<<uq_anzahl<<endl;

// Eingangsspanunngen in das Array uq schreiben
    double uq[uq_anzahl];
    abgl1 = "<indep uq ";          
    abgl2 = ">";                  
    f.open("rausch_simu.dat", ios::in);             // Öffne Datei aus Parameter
    while (!f.eof())                                // Solange noch Daten vorliegen
    {
        getline(f, s);                              // Lese eine Zeile
        pos1 = s.find(abgl1);
        pos2 = s.find(abgl2);

        if(pos1 != string::npos && pos2 != string::npos){
                    for(int q=0; q<uq_anzahl; q++){
                            getline(f, s);
                            double zahl;
                            double ehoch;
                            double gzahl;
                            string zahlvorz_str = s.substr(2, 1);
                            string zahl_str = s.substr(3, 13);
                            string ehochvorz_str = s.substr(17, 1);
                            string ehoch_str = s.substr(18, 3);
                            stringstream zahl_ss(zahl_str);
                            zahl_ss >> zahl;
                            stringstream ehoch_ss(ehoch_str);
                            ehoch_ss >> ehoch;                                 
                            if(zahlvorz_str=="+"){                                                                       
                                                  zahl = 0 + zahl;                                                             
                            }
                            else{
                                                  zahl = 0 - zahl;   
                            }
                            if(ehochvorz_str=="+"){
                                                   ehoch = pow(10, 0+ehoch);
                            }
                            else{
                                                   ehoch = pow(10, 0-ehoch);  
                            }                                
                            uq[q]=zahl * ehoch;
                    }
                    pos1 = string::npos;
                    pos2 = string::npos;
                    break;                    
           }
    }
    f.close();                                      // Datei wieder schließen

// Ergebnisse mitteln und in das Array ua schreiben
    double ua[uq_anzahl];
    int avg_anzahl = acfrequency_anzahl*phase_urm_var_anzahl;
    abgl1 = "<dep umeneu acfrequency phase_urm_var uq>";              
    f.open("rausch_simu.dat", ios::in);             // Öffne Datei aus Parameter
    while (!f.eof())                                // Solange noch Daten vorliegen
    {
        getline(f, s);                              // Lese eine Zeile
        pos1 = s.find(abgl1);

        if(pos1 != string::npos){
                    for(int q=0; q<uq_anzahl; q++){
                            double gzahl;
                            for(int p=0; p<avg_anzahl; p++){
                                    getline(f, s);
                                    long double zahl;
                                    long double ehoch;
                                    string zahlvorz_str = s.substr(2, 1);
                                    string zahl_str = s.substr(3, 13);
                                    string ehochvorz_str = s.substr(17, 1);
                                    string ehoch_str = s.substr(18, 3);
                                    stringstream zahl_ss(zahl_str);
                                    zahl_ss >> zahl;
                                    stringstream ehoch_ss(ehoch_str);
                                    ehoch_ss >> ehoch;                                 
                                    if(zahlvorz_str=="+"){                                                                       
                                                          zahl = 0 + zahl;                                                             
                                    }
                                    else{
                                                          zahl = 0 - zahl;   
                                    }
                                    if(ehochvorz_str=="+"){
                                                           ehoch = pow(10, 0+ehoch);
                                    }
                                    else{
                                                           ehoch = pow(10, 0-ehoch);  
                                    }                                
                                    gzahl = zahl * ehoch;
                                    ua[q] = ua[q] + gzahl;
                            }
                            ua[q] = ua[q] / avg_anzahl;
                    }
                    pos1 = string::npos;
                    break;                    
           }
    }
    f.close();                                      // Datei wieder schließen

// Uq, Ua in die Datei ready.csv schreiben
    stringstream ss;
    ss <<"ready.csv" ;
    string filename = ss.str();
    ofstream fout;
    fout.open(filename.c_str(), ios::trunc);
    cout<<endl <<"Uq -------> Ua" <<endl;
    for(int q=0; q<uq_anzahl; q++){
            fout<<uq[q] <<";" <<ua[q] <<endl;
            cout<<uq[q] <<"------->" <<ua[q] <<endl;
    }
    fout.close();
    cout<<endl <<"ready.csv Datei wurde erfolgreich erstellt." <<endl;

// Dos Fenster nicht schließen
    cin.get();
    cin.get();
}

[Javun]

Edit: Fehler verschwinden sobald ich ua[q] bzw uq[q] vorher auf 0 setze. Findet ihr sonst noch Fehler?

Ich habe nun auch begonnen den Quellcode entsprechen den Empfehlungen hier anzupassen. Ich habe die 1. drei Dateiaufrufe, also zur Bestimmung der Frequenz-, Phasen- und Spannungsanzahl in einen Dateiaufruf gepackt. Hat dazu noch irgendjmd. Verbesserungsvorschläge?

der Größe x erschaffen kann, dass auch außerhalb der Schleife verfügbar ist.

Hier schon Mal der bisher angepasste Quellcode:

int main(int argc, char *argv[])
{  
// Anzahl der Frequenzen, Phasen und Spannungen ermitteln                          
    int acfrequency_anzahl;                         // Anzahl der Frequenzen
    int phase_urm_var_anzahl;                         // Anzahl der Phasen
    int uq_anzahl;                   // Anzahl der unterschiedlichen Spannungsquellen
    ifstream f;                      // Datei-Handle
    f.open("rausch_simu.dat", ios::in);             // Öffne Datei aus Parameter
    while (!f.eof())                                // Solange noch Daten vorliegen
    {
        string s;            
        getline(f, s);                              // Lese eine Zeile
        size_t pos_frequenzen_anfang = s.find("<indep acfrequency ");
        size_t pos_phase_anfang = s.find("<indep phase_urm_var ");
        size_t pos_uq_anfang = s.find("<indep uq ");
        size_t pos_ende = s.find(">");         

        if(pos_frequenzen_anfang != string::npos && pos_ende != string::npos){
                    string acfrequency_str = s.substr(int(pos_frequenzen_anfang)+19, int(pos_ende)-int(pos_frequenzen_anfang)-1);
                    stringstream acfrequency_ss(acfrequency_str);
                    acfrequency_ss >> acfrequency_anzahl;
           }
        if(pos_phase_anfang != string::npos && pos_ende != string::npos){
                    string phase_urm_var_str = s.substr(int(pos_phase_anfang)+21, int(pos_ende)-int(pos_phase_anfang)-1);
                    stringstream phase_urm_var_ss(phase_urm_var_str);
                    phase_urm_var_ss >> phase_urm_var_anzahl;
            }
        if(pos_uq_anfang != string::npos && pos_ende != string::npos){
                    string uq_str = s.substr(int(pos_uq_anfang)+10, int(pos_ende)-int(pos_uq_anfang)-1);
                    stringstream uq_ss(uq_str);
                    uq_ss >> uq_anzahl;
           }
    }
    f.close();                                      // Datei wieder schließen
    cout<<"Anzahl der Frequenzen: "<<acfrequency_anzahl<<endl;
    cout<<"Anzahl der Phasen: "<<phase_urm_var_anzahl<<endl;
    cout<<"Anzahl der Spannungen: "<<uq_anzahl<<endl;

// Dos Fenster nicht schließen
    cin.get();
    cin.get(); 
}

[SeppJ]

Bezüglich deiner Arrayprobleme: Du weißt wohl nicht, was ein vector ist?

Mehr Fehler sind die gleichen Fehler wie vorher:

while (!f.eof())                                // Solange noch Daten vorliegen

Nein, das heißt es eben nicht. while (!f.eof()) heißt "solange der letzte Lesevorgang nicht an eof gescheitert ist".

Was sollen die ganzen Casts?

Ist das substr-Gefummel wirklich nötig? Ich kenne dein Dateiformat und das was du aus der Datei lesen möchtest nicht, aber es sieht unnötig kompliziert aus.

[314159265358979]

Kannst du das Format nochmal genauer erklären? Ich habs nicht wirklich verstanden...

[Javun]

SeppJ schrieb:

Bezüglich deiner Arrayprobleme: Du weißt wohl nicht, was ein vector ist?

Mehr Fehler sind die gleichen Fehler wie vorher:

while (!f.eof())                                // Solange noch Daten vorliegen

Nein, das heißt es eben nicht. while (!f.eof()) heißt "solange der letzte Lesevorgang nicht an eof gescheitert ist".

Was sollen die ganzen Casts?

Ist das substr-Gefummel wirklich nötig? Ich kenne dein Dateiformat und das was du aus der Datei lesen möchtest nicht, aber es sieht unnötig kompliziert aus.

Und wie würde es denn korrekt heißen? Das ist ehrlichgesagt auch nicht auf meinen Mist gewachsen, dass sind Muster Lösungen aus Büchern und Foren.

Ich habe doch auf der Seite 2 eine komplette Beispiel Datei gepostet?! Casten muss ich die Werte doch, wie soll ich sonst auf einem string eine Zahl machen?

Kannst du das Format nochmal genauer erklären? Ich habs nicht wirklich verstanden...

Ich habe doch auf der Seite 2 eine komplette Beispiel Datei gepostet?! Aber hier nochmal. Noch zur Info. Der Aufbau der Datei wird immer gleich bleiben. Einzig und alleine die Anzahl der Werte zwischen <indep ...></indep> wird varrieren.

<Qucs Dataset 0.0.15>
<indep Urm 1>
  +5.30751744861e-007
</indep>
<indep y 1>
  +1.78631210467e-008
</indep>
<indep acfrequency 2>
  +6.72000000000e+002
  +6.82000000000e+002
</indep>
<indep phase_urm_var 2>
  -1.80000000000e+002
  +1.80000000000e+002
</indep>
<indep uq 2>
  +1.00000000000e-015
  +1.00000000000e-007
</indep>
<dep umeneu acfrequency phase_urm_var uq>
  +1.67213405084e-008
  +1.59303541061e-008
  +1.67213405084e-008
  +1.59303541061e-008
  +1.98703688153e-008
  +1.89304207570e-008
  +1.98703688153e-008
  +1.89304207570e-008
</dep>
<dep U_ME1.v acfrequency phase_urm_var uq>
  +1.67213405084e-008+j2.04770597862e-024
  -1.59303541061e-008-j1.95084128199e-024
  +1.67213405084e-008-j2.04770597939e-024
  -1.59303541061e-008+j1.95084128199e-024
  +1.98703688153e-008+j2.04770597708e-024
  -1.89304207570e-008-j1.95084128276e-024
  +1.98703688153e-008-j2.04770598324e-024
  -1.89304207570e-008+j1.95084128276e-024
</dep>
<dep V1.i acfrequency phase_urm_var uq>
  +1.20871499877e-029-j9.87023297137e-014
  -1.16867391765e-029+j9.54326193230e-014
  -1.20871499877e-029-j9.87023297137e-014
  +1.16867391765e-029+j9.54326193230e-014
  +1.20871499877e-029-j1.17290338855e-013
  -1.16867391765e-029+j1.13404863803e-013
  -1.20871499877e-029-j1.17290338855e-013
  +1.16867391765e-029+j1.13404863803e-013
</dep>
<dep V2.i acfrequency phase_urm_var uq>
  +3.05172413793e-013+j9.87023297137e-014
  +3.05172413793e-013-j9.54326193230e-014
  +3.05172413793e-013+j9.87023297137e-014
  +3.05172413793e-013-j9.54326193230e-014
  +3.05172413793e-013+j1.17290338855e-013
  +3.05172413793e-013-j1.13404863803e-013
  +3.05172413793e-013+j1.17290338855e-013
  +3.05172413793e-013-j1.13404863803e-013
</dep>
<dep _net3.v acfrequency phase_urm_var uq>
  -1.64510637319e-017-j4.94667241197e-019
  +7.32282543222e-018-j4.94667241197e-019
  +7.72323624342e-018+j4.94667241197e-019
  -1.60506529207e-017+j4.94667241197e-019
  -1.64510637319e-017+j1.21295118047e-017
  +7.32282543222e-018-j1.31188462871e-017
  +7.72323624342e-018+j1.31188462871e-017
  -1.60506529207e-017-j1.21295118047e-017
</dep>
<dep _net5.v acfrequency phase_urm_var uq>
  +5.30999999984e-007-j4.94602214599e-019
  +5.31000000007e-007-j4.94602214599e-019
  +5.31000000008e-007+j4.94602214599e-019
  +5.30999999984e-007+j4.94602214599e-019
  +5.30999999984e-007+j1.21295768313e-017
  +5.31000000007e-007-j1.31187812605e-017
  +5.31000000008e-007+j1.31187812605e-017
  +5.30999999984e-007-j1.21295768313e-017
</dep>
<dep _net7.v acfrequency phase_urm_var uq>
  +1.67213394919e-008-j4.94665193491e-019
  -1.59303550987e-008-j4.94669192038e-019
  +1.67213395161e-008+j4.94665193491e-019
  -1.59303551221e-008+j4.94669192038e-019
  -8.01296312012e-008+j1.21295138524e-017
  -1.18930420750e-007-j1.31188482379e-017
  -8.01296311770e-008+j1.31188442394e-017
  -1.18930420773e-007-j1.21295098538e-017
</dep>
<dep _net0.v acfrequency phase_urm_var uq>
  -2.34580397786e-028+j9.43255890062e-018
  +1.40412606860e-028+j2.06676039130e-018
  +2.34580397786e-028+j6.55264687996e-018
  -1.40412606860e-028-j5.23805174582e-018
  -3.64817874990e-027+j2.74845250725e-017
  -4.47757913230e-027+j1.23666810299e-017
  +3.64817874990e-027+j6.36629963156e-017
  +4.47757913230e-027+j5.05509262921e-018
</dep>
<dep _net1.v acfrequency phase_urm_var uq>
  -1.67213405084e-008+j9.43255685292e-018
  +1.59303541061e-008+j2.06676234214e-018
  -1.67213405084e-008+j6.55264892767e-018
  +1.59303541061e-008-j5.23805369666e-018
  -1.98703688153e-008+j2.74845230248e-017
  +1.89304207570e-008+j1.23666829808e-017
  -1.98703688153e-008+j6.36629983633e-017
  +1.89304207570e-008+j5.05509067837e-018
</dep>
<dep _net4.v acfrequency phase_urm_var uq>
  -1.01645106429e-015-j4.94667241197e-019
  -9.92677175497e-016-j4.94667241197e-019
  -9.92276763832e-016+j4.94667241197e-019
  -1.01605065263e-015+j4.94667241197e-019
  -1.00000000016e-007+j1.21295118047e-017
  -9.99999999927e-008-j1.31188462871e-017
  -9.99999999923e-008+j1.31188462871e-017
  -1.00000000016e-007-j1.21295118047e-017
</dep>
<dep _net2.v acfrequency phase_urm_var uq>
  +1.00000000000e-015
  +1.00000000000e-015
  +1.00000000000e-015
  +1.00000000000e-015
  +1.00000000000e-007
  +1.00000000000e-007
  +1.00000000000e-007
  +1.00000000000e-007
</dep>
<dep _net6.v acfrequency phase_urm_var uq>
  +3.68300032776e-005-j4.90157015602e-019
  -3.50877965602e-005-j4.98964115049e-019
  +3.68300032776e-005+j4.90157015602e-019
  -3.50877965603e-005+j4.98964115049e-019
  +4.36659736817e-005+j1.21340220303e-017
  -4.17956677725e-005-j1.31231431609e-017
  +4.36659736818e-005+j1.31143360615e-017
  -4.17956677725e-005-j1.21252149308e-017
</dep>

[SeppJ]

Javun schrieb:

Und wie würde es denn korrekt heißen? Das ist ehrlichgesagt auch nicht auf meinen Mist gewachsen, dass sind Muster Lösungen aus Büchern und Foren.

Wenn das in einem C++-Buch drin steht, dann hast du eines der vielen extrem schlechten Bücher. Der Rest deines Codes bestätigt dies. Es geistert leider viel Literatur in Sachen C++ herum, die eher schadet als nützt.

Ich habe doch auf der Seite 2 eine komplette Beispiel Datei gepostet?!

Wie gesagt, dein Code ist so unleserlich, das kann man nicht entziffern. Wie wäre es mal mit einer mündlichen Beschreibung des Formats?

Casten muss ich die Werte doch, wie soll ich sonst auf einem string eine Zahl machen?

Ohne Worte.
Ich schiebs's mal auf das Buch. Scheint eines von der ganz üblen Sorte zu sein. Darf ich erfahren, welches? Das ist ja sogar noch schlimmer als Jürgen Wolf...

[ganze Datei in einem wirr aussehenden Format]

Und meinst du, daraus kann irgendjemand irgendwas ablesen? Genauso könnte ich dir hier den Anfang einer Bilddatei schicken:

����JFIF



��a
                ExifMM*
�




�

�
(

1�
2�
�i
�WCASIO COMPUTER CO.,LTD.EX-Z19      H
H
             1.002010:09:11 23:41:26!��
t��
|�"
�'
d�0221�����

�
��
��

��
Ē

�	
�

̒|TԠ0100�


�

��
V��
�

�
�
�
V��
&�
�


�	
�


X
��2010:09:11 23:41:262010:09:11 23:41:26
�*8��
                                               ��

��8�QVC*
@�
Qy
� Qy� 
 $
� 

 !VQ "
	 #
 2d 3

 4
� 9
 :
 <

 =
=	 A
� B

 H
� e
L� f
L� ��VY0
0


0
0
00V�0


0	

0000
0
0
0
0 
0,

0-
�����
                                                               

!'#))'#&%,1?5,.;/%&7K7;ACFGF*5MSMDR?EFD


                                                   D-&-DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD��
�






















Ist doch lupenklar, wie das Format funktioniert!

Tut mir leid, dass ich dir nicht mehr helfe, da fehlen einfach zu viele Grundlagen, um dir etwas erklären zu können. Und irgendwie auch die Einsicht, dass dir diese Grundlagen fehlen.

[fdfdg]

Warum so hart, SeppJ? Er ist laut eigener Aussage blutiger Anfänger, da weiß man bei vielen Sachen nicht, wie man was erklären soll.
Abgesehen davon, dass er das Format schon erklärt hat. Ich hab's glasklar verstanden. Sonst stell konkrete Fragen dazu.

[SeppJ]

fdfdg schrieb:

Warum so hart, SeppJ? Er ist laut eigener Aussage blutiger Anfänger, da weiß man bei vielen Sachen nicht, wie man was erklären soll.

Ich hatte eher den Eindruck einer blutigen Wand. Und zwar das Blut von meinem Kopf der dagegen anrennt .

Abgesehen davon, dass er das Format schon erklärt hat. Ich hab's glasklar verstanden. Sonst stell konkrete Fragen dazu.

Dann bist du jetzt dran .

[fdfdg]

Was soll man da groß erklären? Da sind vier relevante Sektionen, die jeweils Gleitkommawerte enthalten. Mit denen soll irgendwie hantiert werden (z.B. gemittelt)

Welche Bedeutung genau die Werte haben, kann uns ja egal sein, ist nicht relevant.

[Javun]

Wenn das in einem C++-Buch drin steht, dann hast du eines der vielen extrem schlechten Bücher. Der Rest deines Codes bestätigt dies. Es geistert leider viel Literatur in Sachen C++ herum, die eher schadet als nützt.

Möchte ich gar nicht abstreiten, dass das Buch vllt. nicht gut ist, aber der Code ist nachvollziehbar für einen Anfänger. Manchmal hab ich das Gefühl ich rede hier gegen eine Wand. Ich schreibe lieber 2000 für einen Anfäger VERSTÄNDLICHE Zeilen. Als das ganze in kompakte 20 Zeilen zu packen und davon dann nicht eine Zeile vernünftig erklären zu können. Ich habe jede einzelne Zeile in dem Buch verstanden, jedoch nicht einen eurer Tipps oder eurer Verbesserungsvorschläge. Da kann sich ja jetzt jeder selbst seinen Teil zu denken, ob das Buch schlecht ist oder.....

Wie gesagt, dein Code ist so unleserlich, das kann man nicht entziffern. Wie wäre es mal mit einer mündlichen Beschreibung des Formats?

Gefragt war nach dem Dateiformat und ich habe gesagt das ich eine komplette Beispieldatei gepostet habe, woraus das Dateiformat klar hervorgeht. Was das jetzt jedoch mit meinem Quellcode zutun hat musst Du mir beantworten?! Aber das ist wieder das Prinzip des Bemängelns statt zu Helfen.

Ohne Worte.
Ich schiebs's mal auf das Buch. Scheint eines von der ganz üblen Sorte zu sein. Darf ich erfahren, welches? Das ist ja sogar noch schlimmer als Jürgen Wolf...

Ich arbeite hier mit 5 verschiedenen Büchern, sowie einem Script von meiner Uni. In allen steht dazu das selbe. Auch Wikipedia sagt nichts anderes: http://de.wikipedia.org/wiki/Typumwandlung
Mag sein das es bessere, andere Möglichkeiten gibt, aber sind diese wirklich für einen Anfänger zu empfehlen?! Ich denke eher nicht...

Und meinst du, daraus kann irgendjemand irgendwas ablesen? Genauso könnte ich dir hier den Anfang einer Bilddatei schicken:

Siehe dazu meine Antwort oben. Jeder der sich die Datei nur 1 Sekunde angesehen hat erkennt das Dateiformat und auch meine Erklärungen waren sehr ausführlich. Ich gehe Mal davon aus, dass Du es gar nicht gelesen hast, sondern mir hier nur einen auf den Deckel geben willst...

Tut mir leid, dass ich dir nicht mehr helfe, da fehlen einfach zu viele Grundlagen, um dir etwas erklären zu können. Und irgendwie auch die Einsicht, dass dir diese Grundlagen fehlen.

Warum versucht Du andauernd Menschen zu belehren und ihnen zu sagen, wie sie etwas zu machen haben. Ich habe ein Programm geschrieben welches FUNKTIONIERT!!! Dazu habe ich dann noch einige Fragen gehabt. Wie wärs damit diese Fragen zu beantworten?! Es ist wirklich bewundernswert wie viele Antworten Du auf meinen Thread gegeben hast, jedoch nicht eine konkrete Antwort/Lösungsvorschlag mit Erklärung.

Ich habe den Quellcode auch unserem Professor für Informatik gezeigt und nun für alle eine klare Ansage. Der Code funktioniert so wie er ist! Natürlich könnte man 1000 Sachen verbessern und er meinte auch das es ansich ein 20 Zeilen Programm wäre. Aber die klare Aussage war, warum mit vectoren beschäftigen wenn es auch mit arrays funktioniert. Es geht um die Funktion und um die schnelle Umsetzung. Ich bin kein Informatiker und will das später auch nie werden. Es geht einzig und allein darum simple Problemstellungen in ein Programm umsetzen zu können, damit man die Arbeiten nicht per Hand machen muss (sprich Auswertung).

Schönes Beispiel:

for(int i=0, i<b, i++){
 a = a + a;
}

Lässt sich auch einfacher schreiben als a*b, aber wieso jmd. die Malrechnung erklären (falls er sie noch nicht kann) wenn es auch mit gegebenen Kenntnissen funktioniert.

Letztlich sollte man sich gerade als Moderator vllt. aneignen, dass man Fragen gezielt beantwortet bzw. auch darauf achtet das andere Mitgliedern das tun. Nicht jedoch selber mit schlechtem Beispiel voran gehen...Ich habe jedoch nicht eine vernünftige Antwort auf meine Frage erhalten.

Ich hoffe ihr kommt nicht irgendwann mal in die gleiche Situation, wo ihr vllt. etwas Programmieren muss was in die Richtung Physik geht und dann gleich ein Diplom in diesen Fächern vorrausgesetzt wird, ihr jedoch nur 3-4 Tage dafür zeit habt.

Was soll man da groß erklären? Da sind vier relevante Sektionen, die jeweils Gleitkommawerte enthalten. Mit denen soll irgendwie hantiert werden (z.B. gemittelt)

Welche Bedeutung genau die Werte haben, kann uns ja egal sein, ist nicht relevant.

Vielen Dank an Dich, dass sich zumindest einer die Mühe gemacht hat meine Beiträge überhaupt zu lesen. SeppJ verfolgt eher das Prinzip ganz egal was da steht, es kann nur Mist sein. Deshalb bekomme ich statt Hilfe auch nur Belehrungen.

[SeppJ]

Javun schrieb:

Letztlich sollte man sich gerade als Moderator vllt. aneignen, dass man Fragen gezielt beantwortet bzw. auch darauf achtet das andere Mitgliedern das tun. Nicht jedoch selber mit schlechtem Beispiel voran gehen...Ich habe jedoch nicht eine vernünftige Antwort auf meine Frage erhalten.

Deswegen versuche ich, als Moderator, auch schon seit Tagen, dich dazu zu bringen, mal das zu liefern, was für eine vernünftige Antwort nötig ist. Aber das war wohl vergebene Mühe. Ich geb's auf.

[otze]

Javun schrieb:

Ich schreibe lieber 2000 für einen Anfäger VERSTÄNDLICHE Zeilen. Als das ganze in kompakte 20 Zeilen zu packen und davon dann nicht eine Zeile vernünftig erklären zu können.

Lieber 20 richtige Zeilen als 2000 falsche. Wir haben dir ja beispielsweise bei deinem Gleitkommeformat schon einen 1-Zeiler(!) präsentiert, der genau das Selbe macht. Offensichtlich kann dein Buch nicht gut sein, wenn es dir nicht mitteilt, wie du Fließkommawerte einlesen kannst.

Nebenbei:

int uq_anzahl;
//...
double uq[uq_anzahl];

Das ist kein valides C++. Das läuft nur mit dem GCC. Und auch nur, wenn du die Compilererweiterungen anktivierst. So gut ist dein Buch.

Gefragt war nach dem Dateiformat und ich habe gesagt das ich eine komplette Beispieldatei gepostet habe, woraus das Dateiformat klar hervorgeht.

tut es nicht. Da ist keine Semantik dabei. Als WAS die Einträge bedeuten. Nicht WIE sie aussehen.

Warum versucht Du andauernd Menschen zu belehren und ihnen zu sagen, wie sie etwas zu machen haben. Ich habe ein Programm geschrieben welches FUNKTIONIERT!!!

offensichtlich nicht. Sonst hättest du einfach mehr zeilen einlesen können und es würde funktionieren. Im Laufe des Threads wurden dir nebenbei schon einige Fehler in deinem Code (FUNKTIONIERT!!!) aufgezeigt. Das was du bist, bezeichnen wir hier als Wand.

//edit Weil e smich so aufregt:
Uns ist es völlig egal, ob du ein Lauffähiges Programm hast, oder nicht. Uns ist es auch egal, ob du 100000 falsche Werte einließt. Es ist dein Projekt, nicht unseres. Du darfst es beliebig gegen die Wand fahren. Oder einen Schritt zurück gehen und deine Mentalität anschauen.

Fast alle hier, die gerade mit dir diskutieren kamen als blutige Anfänger in dieses Board. Ihnen wurde hier geholfen, solange sie Hilfe annahmen. Und jetzt geben sie freiwillig dieses Wissen nochmal weiter. Sie alle Wissen, was für nen scheiss sie am Anfang programmiert haben. Und das er fast zu 100% Ausschuß war, der mehr Zeit und Mühe als Nutzen gebracht hat. Und nun sehen sie dich, der jeden guten Ratschlag ablehnt.

[Javun]

Deswegen versuche ich, als Moderator, auch schon seit Tagen, dich dazu zu bringen, mal das zu liefern, was für eine vernünftige Antwort nötig ist. Aber das war wohl vergebene Mühe. Ich geb's auf.

Was sollte ich den noch liefern?
-Ich habe die zu analysierende Datei gepostet!
-Ich habe den Aufbau der Datei ausführlich beschrieben!
-Ich habe den Zweck des Programmes erläutert!
-Ich habe erläutert, was das Programm genau machen muss!

Jeder der diese Beiträge von mir gelesen hat, der hätte das Programm auch umgehend selber schreiben können. Nur denke ich immer noch, dass Du diese Beiträge von mir nicht gelesen hast (Kam mir zumindest auf Grund Deiner Antwort so vor)

Lieber 20 richtige Zeilen als 2000 falsche. Wir haben dir ja beispielsweise bei deinem Gleitkommeformat schon einen 1-Zeiler(!) präsentiert, der genau das Selbe macht. Offensichtlich kann dein Buch nicht gut sein, wenn es dir nicht mitteilt, wie du Fließkommawerte einlesen kannst.

So falsch können Sie ja nicht gewesen sein, wenn das Programm seinen Zweck erfüllt hat. Es ging darum innerhalb einer gewissen Zeit, hier ca. 7 Tage, ein funktionsfähiges Programm auf die Beine zu stellen. Ich hätte etwas mehr Verständnis erwartet, dass ich wohl kaum in der Lage bin mir die Programmiersprache in 7 Tagen beizubringen. In dem Buch habe ich dazu nichts gefunden, vllt. stand es auch drin, aber wie bereits erwähnt in 7 Tagen konnte ich nun wirklich nicht alles lesen, deshalb habe ich es mit den einfachsten Mitteln versucht.

Du bist jetzt der erste der mir sagt, dass es sich um Fließkommawerte handelt, die man in C++ so ... einlesen kann. Diese Information hätte mir damals weitergeholfen, aber stattdessen wurden aus meinen 30 Zeilen, 2 Zeilen ohne das ich erfuhr wieso, weshalb, warum?

Das ist kein valides C++. Das läuft nur mit dem GCC. Und auch nur, wenn du die Compilererweiterungen anktivierst. So gut ist dein Buch.

Dann hatte ich hier wohl Glück und ich wäre Dir dankbar, wenn Du mir sagen könntest warum das falsch ist bzw. wie es richtig aussehen müsste.

tut es nicht. Da ist keine Semantik dabei. Als WAS die Einträge bedeuten. Nicht WIE sie aussehen.

Ich habe zusätzlich auf Seite 2 eine ausführliche Beschreibung der Datei geschrieben und ich denke Sie ist selbst erklärend für jeden der sich auch nur 2 Minuten mit meiner Problemstellung beschäftigt hat.

offensichtlich nicht. Sonst hättest du einfach mehr zeilen einlesen können und es würde funktionieren. Im Laufe des Threads wurden dir nebenbei schon einige Fehler in deinem Code (FUNKTIONIERT!!!) aufgezeigt. Das was du bist, bezeichnen wir hier als Wand.

und ua[x] vor Beginn der Rechnung auf 0 zu setzen. Um den Fehler zu finden brauchte ich jedoch mehrere Stunden, jmd. von euch der darin geübt ist hätte den Grund für den Fehler wohl in einer Minute gefunden. Nur leider wart ihr so damit beschäftigt meinen Stil zu kritisieren und mich mit Fragen nach dem Dateiformat zu löchern, dass es zu gar keiner Antwort kommen konnte. (Das Dateiformat war für meine konkrete Fragestellung überhaupt nicht von Bedeutung)

Uns ist es völlig egal, ob du ein Lauffähiges Programm hast, oder nicht. Uns ist es auch egal, ob du 100000 falsche Werte einließt. Es ist dein Projekt, nicht unseres. Du darfst es beliebig gegen die Wand fahren. Oder einen Schritt zurück gehen und deine Mentalität anschauen.

Wie bereits erwähnt habe ich das Projekt nicht gegen die Wand gefahren. Das Programm hat seinen Zweck erfüllt. Alle sind zufrieden und das Programm ist nun im Papierkorb gelandet. Man sollte sich vllt. auch Mal seine eigene Mentalität anschauen und vllt. nicht gerade auf Perfektion bestehen, sondern einfach versuchen bei der Lösung des Problemes zu helfen. Wenn mir sogar ein Prof. sagt, dass das Programm so lauffähig ist und errechnet die korrekten Werte. (Mehr wollte ich doch gar nicht, nur warum kann mir das keiner von euch sagen?!)

Fast alle hier, die gerade mit dir diskutieren kamen als blutige Anfänger in dieses Board. Ihnen wurde hier geholfen, solange sie Hilfe annahmen. Und jetzt geben sie freiwillig dieses Wissen nochmal weiter. Sie alle Wissen, was für nen scheiss sie am Anfang programmiert haben. Und das er fast zu 100% Ausschuß war, der mehr Zeit und Mühe als Nutzen gebracht hat. Und nun sehen sie dich, der jeden guten Ratschlag ablehnt.

Ich möchte Dir gar nicht widersprechen, dass ich hätte vieles besser machen können. Aber ich hatte nur 7 Tage Zeit!!! Sich in dieser Zeit ausführlicher mit der Programmierung zu besprechen und Nebenbei noch dem Job und dem Studium nachzugehen halte ich für schwer bis unmöglich. Daher ging es mir primär darum ein funktionierendes Programm zu schreiben und das habe ich zum Glück selbst hinbekommen. Wenn ich die Zeit gehabt hätte, dann hätte ich mir gerne jeden Rat zu Herzen genommen und mich damit ausführlich beschäftigt. Mir ging es aber eher um so einfach wie möglich!

Warum mache ich mir jetzt überhaupt die Mühe und schreibe das hier rein?!
Ich finde es einfach schade wie mit neuen Mitgliedern umgegangen wird. Es sollte einfach mehr Rücksicht auf die Anfänger genommen werden und wenn man wirklich helfen will, dann sollte man seine Antwort auch nach der Fragestellung ausrichten.

Ich bin mir 100% sicher, dass jeder von euch mein Problem innerhalb von 5 Minuten hätte komplett lösen können und mir dazu auch noch eine ausführliche Erklärung hätte liefern können. Daraus hätte ich dann wirklich was lernen können. Stattdessen haben wir hier auf 4 Seiten größtenteils über Dinge diskutiert, die nichts mit meiner Fragestellung zu tun haben. Das demotiviert eher, als es einem weiterhilft.

Ich bin weiterhin für alle Tipps dankbar, denn auch wenn das Programm bereits seinen Dienst erfolgreich geleistet hat, würde ich gerne aus meinen "Fehlern" lernen um es evt. das nächste Mal schneller und einfacher hinzubekommen...

[Javun]

Noch als kleiner Nachtrag...

Der Code

double zahl;
                            double ehoch;
                            double gzahl;
                            string zahlvorz_str = s.substr(2, 1);
                            string zahl_str = s.substr(3, 13);
                            string ehochvorz_str = s.substr(17, 1);
                            string ehoch_str = s.substr(18, 3);
                            stringstream zahl_ss(zahl_str);
                            zahl_ss >> zahl;
                            stringstream ehoch_ss(ehoch_str);
                            ehoch_ss >> ehoch;                                
                            if(zahlvorz_str=="+"){                                                                      
                                                  zahl = 0 + zahl;                                                            
                            }
                            else{
                                                  zahl = 0 - zahl;  
                            }
                            if(ehochvorz_str=="+"){
                                                   ehoch = pow(10, 0+ehoch);
                            }
                            else{
                                                   ehoch = pow(10, 0-ehoch);  
                            }                                
                            uq[q]=zahl * ehoch;

wie empfholen ersetzt durch den Code:

f.ignore(2) >> uq[q];
    f.ignore( numeric_limits< streamsize >::max(), '\n' );

funktioniert nicht und liefert falsche Ergebnisse

[otze]

änder mal den code so:

f.open("rausch_simu.dat", ios::in);
while ( f )
{
    getline(f, s);
    pos1 = s.find(abgl1);
    pos2 = s.find(abgl2);
    if(pos1 != string::npos && pos2 != string::npos){
        for(int q=0; q<uq_anzahl; q++){
            f >> uq[q]
        }
    }
}

jetzt wo man das Dateiformat besser kennt, muss man deinen Code ja nicht mehr dechiffrieren und weiß, dass auf jeder Zeile nur ein double liegt.

Nur leider wart ihr so damit beschäftigt meinen Stil zu kritisieren und mich mit Fragen nach dem Dateiformat zu löchern, dass es zu gar keiner Antwort kommen konnte.

Ja, bei deinem Codestil kann man das nicht erwarten. Wie du oben gesehen hast, war es schon etwas schwierig rauszukriegen, dass du da eigentlich nur doubles einlesen willst und dafür 2x den selben umständlichen Code schreibst. Bei dem Code hat man einfach keine Lust, etwas anderes zu sagen als: mach es neu. Er ist eine Zumutung. Für Wartung eines solchen Codes verlang tman normalerweise eine Stange Geld. Es ist auch nicht hilfreich, wenn du dann eingeschnappt reagierst, wenn man dir das sagt.

[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?