Wie kann ich Zaheln in einer txt lesen und vergleichen??

--(0)-----(1)----(2)----(3)-(4)---(5)-----(6)---(7)-(8)

Kommt diese Zeile auch in der Datei vor?

30.392 683825 764608 0 0 683825 2512256 0 0

Ist immer nur die erste Zahl eine reelle Zahl und die restlichen sind natürliche Zahlen, oder ist das nun Zufall?

Ich würde eine Struktur erstellen mit 8 Datenelementen, den operator>> überladen und die Zahlen dann einlesen.

--(0)-----(1)----(2)----(3)-(4)---(5)-----(6)---(7)-(8) Sollte nur zur verdeutlichung dienen, welche zahl nun die 0. 1. 2. usw. ist, kommt also nicht vor!!

Die erste Zahl ist ein Zeitstempel mit 100stel sec Anzeige, welcher aber ignoriert werden kann. Benütigt werden nur (1)(2)(3)(4)(5)(6)(7)(8)

Das mit der Struktur versuche ich gleich mal THX

Dann kannst du ja mal deinen Quellcode zeigen.

uhhhhhh mein "Quelltext" ist eher ein "horrortriptext"

Habe nicht all zu viel produktives zusammenbekommen bin auch im Programmieren ned so fit habe mehr rumgespielt wie sonst was und versucht die Zeilen zu kopieren, also über die fixe Struktur des Zahlenstrings.
Also etwas was mit der eigentlichen lösung "noch nichts" zu tun hat

Funktioniert auch nicht und deswegen habe ich gedacht bevor ich mich da weiter verlaufe poste ich hier meine frage

#include <algorithm>
#include <fstream> 
#include <iterator>	
#include <iostream> 
#include <limits>		

using namespace std;

struct Eintrag 
{ 
    static int const N = 8; 
    double prefix_; 
    int ps_[N]; 
}; 

istream& operator>>( istream& in, Eintrag& e ) 
{ 
    const streamsize ALL = numeric_limits< streamsize >::max(); 
    in.ignore ( ALL, e.prefix_); 
    in.ignore( ALL, ' ' );					
    const char* tags = " "; 
    const char* tag = tags; 
    for( int i=0; i<Eintrag::N; ++i, ++tag ) 
        in.ignore( ALL, *tag ) >> e.ps_[i]; 
    return in.ignore( ALL, '\n' );	
} 

ostream& operator<<( ostream& out, const Eintrag& e ) 
{ 
    copy( e.ps_, e.ps_ + Eintrag::N, ostream_iterator< int >( out, " " ) );
    return out; 
} 

int main() 
{ 
    using namespace std; 

    ifstream f1("test.txt"); 
    ofstream f2("n_test.txt"); 

    copy( istream_iterator< Eintrag >(f1), istream_iterator< Eintrag >(), ostream_iterator< Eintrag >(f2, "\n") );

	f1.close ();
	f2.close ();
    return 0; 

}

Belli

Ich würde das Einlesen wie folgt bewerkstelligen (ungetestet):

#include <algorithm>    // copy
#include <fstream>
#include <iterator>        // i(o)stream_iterator
#include <iostream>
#include <limits>        // numeric_limits

using namespace std;

struct Eintrag
{
    static int const N = 8;
    double prefix_;
    int ps_[N];
};

istream& operator>>( istream& in, Eintrag& e )
{
    in >> e.prefix_;

    for( int i=0; i<Eintrag::N; ++i)
        in >> e.ps_[i];

    return in;   
}

int main()
{
    using namespace std;

    ifstream f1("test.txt");

    Eintrag e;

    while(f1 >> e)   //Einlesen
    {
        //Zur Überprüfung ausgeben:
        for(int i = 0; i < 8; ++i)
           cout << e.ps_[i] << ' ';

        cout << '\n';
    }

    return 0;

}

SeppJ

Ein bisschen viel ignore, oder? Mal ehrlich: Hast du das selber geschrieben oder sind das zusammenkopierte Codefetzen, die du selber nicht verstehst? Codestil und Kenntnisstand scheinen bei dir nämlich überhaupt nicht zusammen zu passen. Wer kennt denn schon Streamoperatoren, ohne mit den Grundfunktionen der Streams umgehen zu können?

So könnte das aussehen:

#include <algorithm>   
#include <fstream>
#include <iterator>    
#include <iostream>
#include <limits>      

using namespace std;

struct Eintrag
{
  static int const N = 8;
  int ps_[N];
};

istream& operator>>( istream& in, Eintrag& e )
{
  const streamsize ALL = numeric_limits< streamsize >::max();
  in.ignore( ALL, ' ' );                  
  for( int i=0; i<Eintrag::N; ++i) // Wenn du sonst immer copy benutzt, dann könntest du es hier auch tun
        in >> e.ps_[i];
  return in.ignore( ALL, '\n' );  
}

ostream& operator<<( ostream& out, const Eintrag& e )
{
  copy( e.ps_, e.ps_ + Eintrag::N, ostream_iterator< int >( out, " " ) );
  return out;
}

int main()
{
  ifstream f1("test.txt");
  ofstream f2("n_test.txt");

  copy( istream_iterator< Eintrag >(f1), istream_iterator< Eintrag >(), ostream_iterator< Eintrag >(f2, "\n") );
}

hustbaer

FillColin schrieb:

Über ein paar spitzfindige Ideeen würde ich mich sehr freuen.

Du postest hier zwar im C++ Forum, aber ... nachdem es danach schreit, und es noch keiner geschrieben hat: wie wär's damit einfach Excel anzuwerfen? Oder evtl. auch Access.

Wenn du es nicht deswegen in C++ machen willst um dabei zu lernen, es nicht automatisiert laufen muss und du keine weiteren komplizierten Berechnungen mit den Daten anstellen willst/musst, ... dann wäre mMn. Excel die schnellste Lösung. Und damit alles andere automatisch Zeitverschwendung.

Belli

Aber so, wie die Datei aussehen soll, kann man sich doch die ignore-Aufrufe sparen?!

Ich hätte das Ganze so gemacht:

#include <iostream>
#include <fstream>
#include <vector>
using namespace std;

struct entry
{
	static const unsigned n = 8;
	unsigned data[n];

	unsigned& operator[](unsigned i)
	{
		return data[i];
	}
};

istream& skip_timestamp(istream& in)
{
	double d;
	return in>>d;
} 

istream& operator>>(istream& in, entry& e)
{
	in >> skip_timestamp;
	for(int i=0; i<entry::n; ++i)
		in >> e.data[i];
	return in;
}

int main()
{
	ifstream file("data.txt");

	vector<entry> entries;
	for(entry e; file>>e; entries.push_back(e));

	// Testausgaben
	for(unsigned i=0; i<entries.size(); ++i)
	{
		for(unsigned u=0; u<entry::n; ++u)
		{
			cout << entries[i][u] << ' ';
		}
		cout << endl;
	}
}

hustbaer

Belli schrieb:

Aber so, wie die Datei aussehen soll, kann man sich doch die ignore-Aufrufe sparen?!

Der erste ist praktisch um den Timestamp zu übergehen.
Der am Zeilenende ist praktisch wenn danach noch weitere Werte kommen können, die ignoriert werden sollen.

FillColin schrieb:

uhhhhhh mein "Quelltext" ist eher ein "horrortriptext"

Habe nicht all zu viel produktives zusammenbekommen bin auch im Programmieren ned so fit habe mehr rumgespielt wie sonst was und versucht die Zeilen zu kopieren, also über die fixe Struktur des Zahlenstrings.
Also etwas was mit der eigentlichen lösung "noch nichts" zu tun hat

Funktioniert auch nicht und deswegen habe ich gedacht bevor ich mich da weiter verlaufe poste ich hier meine frage
// hier folgt der kopierte Code

SeppJ schrieb:

Ein bisschen viel ignore, oder? Mal ehrlich: Hast du das selber geschrieben oder sind das zusammenkopierte Codefetzen, die du selber nicht verstehst?

siehe http://www.c-plusplus.net/forum/p2230263#2230263