Wie kann ich "istream& operator>>" 2 mal verwenden?

[kuko]

Hallo an alle
jetzt hat es mich auch mal hier hineingetrieben und hoffe, dass mir jm. weiterhelfen kann.

Es geht um die Zeilen [15][25][40][51]....Wie muss ich diese umschreiben, dass [40]auf [15] zugreift und [51] auf [25].
Ich habe keine Ahnung wie das gehen soll und habe auch nichts gefunden.

Ich weiß, dass das Programm macht so keinen Sinn macht. Es ist nur die eine vereinfachte Version meines Problems. Also geht es mir nur um das Prinzip der Umsetzung.

Über ein paar Tips würde ich mich sehr freuen schöne Grüße

Kurt

#include <fstream> 
#include <iterator>
#include <iostream> 

using namespace std; 

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

// 1. istream ----------------------------------------
istream& operator>>( istream& in, Eintrag& e )		// Beim 1. while() hier
{ 
    in >> e.prefix_; 

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

    return in;   
} 
//  2. istream ---------------------------------------
istream& operator>>( istream& in, Eintrag& e ) 		// Beim 2. while() hier
{ 
    in >> e.prefix_; 

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

    return in;   
} 
//--------------------------------------------------
int main() 
{ 
    ifstream f1("test.txt"); 

	Eintrag e; 
    while(f1 >> e)									// 1. istream aufrufen
    { } 

	for(int i = 0; i < 8; ++i) 
        cout << e.ps_[i] << ' '; 

	f1.close ();
// -------------------------------------------------
	ifstream f1("test.txt"); 

	Eintrag e; 
    while(f1 >> e)									// 2. istream aufrufen 
    { } 

	for(int i = 0; i < 8; ++i) 
        cout << e.ps_[i] << ' '; 

	f1.close ();
//-----------------------------------------------------
	getchar();
    return 0; 
}

 

[deepthroat]

Hi.

Ich verstehe dein Problem vermutlich nicht so ganz. Was genau versuchst du denn da umzusetzen?

Wieso hast du zweimal den gleichen Operator definiert?

Willst du den Operator überladen? Dann müssen sich die Argumente in Anzahl oder Typ unterscheiden.

Gruß

 

[sheel]

Hi und Willkommen bei tutorials.de,

das, was du vorhast, geht nicht so direkt.

a) Mach zwei eigene Methoden mit verschiedenem Namen (nicht Operatoren)

oder b) Leite 2 Klassen vom istream ab, jede bekommt einen eigenen Operator.
Dann je nach Verwendung my_istream1 oder my_istream2 verwenden
(oder wie sie eben heißen).

oder c) Eine einzelne Ableitung mit einer Variable, was ausgeführt werden soll.
Im Operator einfach mit if.
Dazu eine Methode, die die Variable umstellen kann.
...

Noch ein (unschönes) d:
Wie c, die Varialbe ist aber global. Damit spart man sich eine Ableitung der Klasse
-> der derzeitige main-Code kann unverändert übernommen werden.
Nur dazwischen die Variable auf einen anderen Wert stellen.

Gruß

 

[kuko]

ok war wohl doch saublöde Formulier von mir, bzw. zu schlecht beschrieben... sorry

dann doch die ausführlichere Variante:


Ich wollte 2 istream& operatoren verwenden im Programm die allerdings sehr unterschiedliche dinge tun

istream& operator>>( istream& in, Eintrag& e )     // 1. streamoperator
{ 
    in >> e.time_; 

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

   return in;   
}

istream& operator>>( istream& in, Eintrag& e )      // 2. streamoperator
{ 
    const streamsize ALL = numeric_limits< streamsize >::max(); 
    string token; 
    (in >> e.time_).ignore( ALL, '[' ) >> token;

    const char* format = token == "Full"? "%_#_[_:%K_(%K)][_:%K_(%K)]%K_(%K)[_:%K_(%K)]_\n": "%_#_[_:%K_(%K)]"  "##"  "%K_(%K)"   "##"    "_\n";

    int* dst = e.ps_; 

//....CODE ausgeschnitten....

    return in; 
}

Aufgerufen durch

void speicher_test()
{ 
    ifstream f1("GAQ7OK~W"); 

	Eintrag e; 

    while(f1 >> e)							// 1. streamoperator
    { } 

	for(int i = 0; i < 8; ++i){ 
		cout << e.ps_[i] << ' '; }

	f1.close ();
}

und durch

int schreiben(string name)														
{
	ifstream f1("GAQ7OK~W"); 
	ofstream f2(name);


	f2.precision(3);														
	f2 << fixed;															

	copy( istream_iterator< Eintrag >(f1), istream_iterator< Eintrag >(), ostream_iterator< Eintrag >(f2, "\n") );	     // 2. streamoperator

	f1.close();																		
	f2.close();																		

	return 0;
}

Nun habe ich aber ds Problem, dass ich es ned und null blicke den Aufruf so zu gestallten, dass 1.Stream zu 1.Stream und 2.Stream zu 2. Stream passt.

Ich hoffe das bringt nun etwas Licht in's dunkel

 

[vfl_freak]

Moin,

istream& operator>>( istream& in, Eintrag& e ) // 1. streamoperator
{}
istream& operator>>( istream& in, Eintrag& e ) // 2. streamoperator
{}

ganz egal, ob beide was unterschiedliches tun (sollen) ...
Wie die Kollegen zuvor schrieben: die Deklarationen sind exakt gleich und das geht nicht !!

Gruß
Klaus

 

[deepthroat]

Du könntest die Operatoren in unterschiedlichen Namensräumen definieren und dann immer den gerade benötigten in den aktuellen Skopus bringen.

PS: Du solltest übrigens die Leseoperationen prüfen, und z.B. erst mit "token" weiterarbeiten, wenn überhaupt etwas eingelesen wurde.

 

[kuko]

Danke****** Ich versuche mal die Lösungen (b) und (a) von "shell"

PS: "deepthroat" eine Prüfung in form eines check (); habe ich schon. Habe nur ein paar codeschnipsel rausgenommen um es kompakter zu visualisieren.

edit:

istream& operator>>( istream& in, Eintrag& e ) // 1. streamoperator
{}
istream& operator>>( istream& in, Eintrag& e ) // 2. streamoperator
{}

Dessen war ich mir bewusst, und ich wusste dass ich das z.B. so lösen könnte:

istream& operator>>( istream& in, Eintrag& e ) // 1. streamoperator
{}
istream& operator>>( istream& in, n_eintrag& e ) // 2. streamoperator
{}

Aber dann hätte ich ne neue struktur "n_eingabe" schreiben müssen, wobei ich doch die alte wiederverwenden wollte.

 

[sheel]

Auf wen bezieht sich das jetzt?

 

[vfl_freak]

Moin,

warum schreibst Du dann nicht einfach EINE Funktion "istream& operator>>( istream& in, Eintrag& e )" und übergibst einen weiteren Parameter, über den innerhalb der Funktion gesteuert wird, welchen Codeteil Du ausführen willst

Gruß
Klaus

 

[sheel]

Mit einem Operator wird das schwer...

meinstream >> meinevariable;

Wohin mit Parameter 3?