Beim Dateiauslesen in Schleife "zurückgreifen"

Erding

Hallo,

habe grad folgendes Problem, Quelltext unten. Ich habe eine Datei Daten.dat, in der zeilweise je 3 Werte stehen, ich nenne sie x, y, z. Diese sollen ausgelesen, damit eine Rechnung angestellt werden und in einbe neue Datei ausgegeben werden. Soweit sogut. Nun muss bei der Berechnung nicht das "aktuelle" x genutzt werden, bei welchem sich die While-Schleife gerade befindet, sondern quasi das aus der letzte Zeile (es geht um (x_i - x_i-1)/(y_i - y_i-1)

Optimaler weise benötige ich sogar das x aus der letzten Zeile UND aus der nächsten ((x_i+1 - x_i-1)/(y_i+1 - y_i-1))!

Wie baue ich sowas in meinen Code ein? Habe es schon versucht, mit c=(letztesx-x)/(letztesy-y) und das Programm danach erst das aktuelle letztesx = x und letztesy = y definieren zu lassen, sodass man immer das letzte nimmt. Ist aber nicht so zufriedenstellend...

#include <iostream>
#include <fstream>
int main() {
    double x, y, z, a, b, c;
    std::ofstream out;
    std::fstream io;
    out.open("Daten.dat",std::ios::app);
    out << "# Zeit x  Wert b  Wert c " << std::endl;
    std::ifstream in("Bewegung.dat");
    in.ignore(80,'\n');
    while (!in.eof()) {
          in >> x >> y >> z;
          a = x
          b = 9.81 * y * 6.51
          c = ([nächstes x] - [letztes x]) / ([nächstes y] - [letztes y]
          std::ofstream out;
          std::fstream io;
          out.open("Ausgabe.dat",std::ios::app);
          out << a << "  " << b << "  " << c << std::endl;
          }
          in.close();
    return 0;
}

Hoffe mich versteht jemand

Gruß,
Erding

_matze

Warum muss unbedingt alles in einer Schleife passieren? Trenne die beiden Aufgaben (Einlesen, Berechnen+Ausgeben) doch einfach. Lies deine Werte in einen std::vector ein. Und im Anschluss kannst du in einer zweiten Schleife ganz in Ruhe berechnen und dabei ganz easy im std::vector navigieren.

Würde auch zuerst einlesen, außer wenn die Datei zu groß ist. Dann machst du dir ein double x[3] und schiebst durch.

Tachyon

Erstmal muss man fragen, ob Du den Code überhaupt verstehst...

#include <iostream>
#include <fstream>
int main() {
    double x, y, z, a, b, c;
    std::ofstream out; //man kann hier direkt eine Datei öffnen
    std::fstream io; //wozu? Du benutzt das nirgends.
    out.open("Daten.dat",std::ios::app); //braucht man nicht, siehe oben
    out << "# Zeit x  Wert b  Wert c " << std::endl;
    std::ifstream in("Bewegung.dat"); //hier machst Du es direkt, nicht wie oben bei out
    in.ignore(80,'\n');
    while (!in.eof()) { 
          in >> x >> y >> z;
          a = x
          b = 9.81 * y * 6.51
          c = ([nächstes x] - [letztes x]) / ([nächstes y] - [letztes y]
          std::ofstream out; //was soll das? Du hast oben schon ein ofstream-Objekt angelegt
          std::fstream io; //wozu? Du benutzt das nirgends und hast oben schon ein Objekt mit gleichem Namen angelegt.
          out.open("Ausgabe.dat",std::ios::app); //siehe oben
          out << a << "  " << b << "  " << c << std::endl;
          }
          in.close(); //passiert automatisch. out schließt Du ja auch nicht.
    return 0;
}

Mal Hand aufs Herz, hast Du das selbst geschrieben, oder irgendwo abgetippt?

Werner Salomon

Hallo Erding,

willkommen im C++-Forum.

Dein Problem ist eine typische Anwendung für einen Queue-Meachanismus. Dazu kannst Du die std::queue verwenden, in der in Deinem Fall immer die letzten beiden Einträge gespeichert werden.

Ich habe Deinen Code noch etwas entrümpelt - dann sieht es so aus:

#include <iostream>
#include <fstream>
#include <deque>
#include <utility> // std::pair<>
#include <limits> // numeric_limits<>::max()

std::istream& skipline( std::istream& in )
{
    return in.ignore(std::numeric_limits< std::streamsize >::max(),'\n');
}

int main() {
    std::ofstream out1("Daten.dat",std::ios::app);
    out1 << "# Zeit x  Wert b  Wert c " << std::endl;

    std::ofstream out2("Ausgabe.dat",std::ios::app);
    std::ifstream in("Bewegung.dat");
    in >> skipline;
    std::deque< std::pair< double, double > > pipe;
    for( double x, y; in >> x >> y >> skipline; pipe.push_back( std::make_pair( x, y ) ) ) {
        if( pipe.size() < 2 )
            continue;
        double a = x;
        double b = 9.81 * y * 6.51;
        double c = (x - pipe.front().first) / (y - pipe.front().second);
        out2 << a << "  " << b << "  " << c << std::endl;
        pipe.pop_front();
    }
    return 0;
}

noch ein Tipp in Zeile 24 steht noch 9.81, was wahrscheinlich die Erdbeschleunigung sein soll. Dafür verwendet man besser sogenannte sprechende Konstanten. Schreibe vor Dein main-Programm

namespace physics
{
    const double g = 9.80665; // m/s^2 nach http://de.wikipedia.org/wiki/Erdbeschleunigung
}

und die Zeile 24 wird zu

double b = physics::g * y * 6.51;

Gruß
Werner

Beim Dateiauslesen in Schleife &quot;zurückgreifen&quot;

Beim Dateiauslesen in Schleife "zurückgreifen"