ich bin gerade dabei eine Programm zu schreiben, welches das Log eines Games ausliest.
Leider habe ich bis jetzt nur wenig c++ Erfahrung und hoffe ihr könnt mir ein wenig weiter helfen.

Zunächst mal die Text Datei, welche eingelesen und später bewertet werden soll.

21:39:51.992|Respektlos|Tobiasvon|Salvation|1295|H|
21:39:51.992|Respektlos|Schlitzohr|Salvation|725|H|
21:39:52.271|Respektlos|Tribunus|Rejuvenate|760|H|
21:39:53.007|Tobia|Eleraana|Salvation|725|H|
21:39:53.007|Tobi|Racta|Salvation|1283|H|
21:39:53.007|Tobi|Sephone|Salvation|1283|H|
21:39:53.007|Respektlos|Respektlos|Salvation|783|H|
21:39:53.008|Respektlos|Tribunus|Salvation|1258|H|
21:39:53.008|Tobi|Tobiasvon|Salvation|747|H|
21:39:53.008|Tobi|Schlitzohr|Salvation|725|H|
21:39:54.074|Respektlos|Racta|Salvation|1283|H|
21:39:54.074|Respektlos|Eleraana|Salvation|725|H|
21:39:54.074|Respektlos|Sephone|Salvation|740|H|
21:39:54.075|Respektlos|Respektlos|Salvation|1357|H|
21:39:54.075|Respektlos|Tribunus|Salvation|725|H|
21:39:54.075|Respektlos|Tobi|Salvation|747|H|
21:39:54.075|Respektlos|Schlitzohr|Salvation|725|H|
21:39:54.305|Respektlos|Respektlos|ExitCombat||EC|

Das sind zunächst einmal nur dummi Werte. Die Text Datei hat allerdings immer die selbe Strucktur, sprich in ersten Teil befindet sich die Zeit, anschließend ein Spielername, danach wieder ein Spielername ect.

Bis jetzt habe ich die Textdatei einlesen können und den String in verschiedene Daten wandeln.
Jedoch finde ich meine Lösung alles andere als elegant und ich habe Probleme die Daten weiter zu verarbeiten.
Im folgenden Schritt müsste ich für sämtliche Spieler die in "name1" stehen nun alle Werte der Variable "wert" addieren.
Damit komme ich leider nicht weiter.
Ein anderes Problem ist die Zeit, die ich auch noch nicht vernünftig einlesen kann.

Hier mal mein Programm soweit

#include "stdafx.h"
#include "iostream"
#include "string"
#include "fstream"
#include "cstring"
#include "sstream"
#include "time.h"

using namespace std;

int main(void)
{	
string puffer1;
string einezeile[200];
string newlog;
//char a1[100];
int i=1,j =1;

	ifstream log("C:\\Users\\Philipp\\Desktop\\out.txt");

	if( log.is_open() != true){ cerr << "cannot open data"
	<< endl;
	return 1 ;
	}

	while(getline(log,puffer1,'|')) 
	{
einezeile[i]=puffer1;

i++;
j++;
	} 

	double x;
	char name1[20];
	char name2[20];
	char skillname[20];
	int wert;
	int k=0,l=0,ö=0;
	char dpsorheal[4];
	const char *charpointer1;
	const char *charpointer2;
	const char *charpointer3;
	const char *charpointer4;
	stringstream strs1;
	stringstream strs2;
	bool spielervorhanden;
	//char *pointer1
	for(l=0;l<11;l++)
	{

	///////////////////////////////////////////
	x=atof(einezeile[1+k].c_str());

	///////////////////////////////////////////
	charpointer1=einezeile[2+k].c_str();
	strcpy(name1,charpointer1);

	///////////////////////////////////////////
	charpointer2=einezeile[3+k].c_str();
	strcpy(name2,charpointer2);

         //////////////////////////////////////////	
	charpointer3 =einezeile[4+k].c_str();
	strcpy(skillname,charpointer3);

	//////////////////////////////////////////
	wert =atoi(einezeile[5+k].c_str());

	///////////////////////////////////////////
	charpointer4 = einezeile[6+k].c_str();
	strcpy(dpsorheal,charpointer4);

	k=k+6;

cout <<x<<' '<< name1<<' ' <<name2 <<' '<< skillname<<' '<<wert<<' '<<dpsorheal <<  endl;
	}

}

Um eure Hilfe wäre ich sehr Dankbar,
vielleicht könnt ihr mir ja auch eine elegantere Möglichkeit aufzeigen, die mir Hilft das Programm zu erstellen.

Vielen Dank im voraus
Grüße Phil

was soll der ganze C-Kram hier?

Du verwendest doch schon std::string und std::getline, diese kannst du gleich für's Einlesen der einzelnen Werte nutzen:

string date_time, name1, name2, skillname;
int value;
string dummy, dpsorheal;

while(getline(log, date_time, '|'))
{
  getline(log, name1, '|');
  getline(log, name2, '|');
  getline(log, skillname, '|');
  log >> value;
  getline(log, dummy, '|');
  getline(log, dpsorheal, '|');
}

Um die Werte (je Name) zu speichern, bietet sich eine std::map<std::string, int> an:

std::map<std::string, int> name_value_map;

// in obiger Schleife (nach dem Einlesen des Wertes)
name_value_map[name1] += value;

Leider konnte ich den Code noch nicht so umbasteln damit er bei mir funktioniert.
Ich habe versucht einen iterator einzufügen, das hat leider nur bedingt funktioniert, hier nochmal der code.
So bekomme ich nur 2 Zeilen ausgegeben. Wenn ich die Zeile

// m.insert((name1, value));

verwende bekomme ich eine fehlermeldung

// Parser.cpp : Definiert den Einstiegspunkt für die Konsolenanwendung.
//

#include "stdafx.h"
#include "iostream"
#include "string"
#include "fstream"
#include "cstring"
#include "sstream"
#include "time.h"
#include "map"

using namespace std;

 map<string, int> m;
 map<string, int>::iterator iter; 

int main(void)
{    

string puffer1;
string einezeile[1000];
string newlog;
//int stringcounter[200];
//char a1[100];
int i=1,j=1, ö=1;

    ifstream log("C:\\Users\\Philipp\\Desktop\\out.txt");

    if( log.is_open() != true){ cerr << "cannot open data"
    << endl;
    return 1 ;
    }

string date_time, name1, name2, skillname;
int value;
string dummy, dpsorheal;

while(getline(log, date_time, '|'))
{
  getline(log, name1, '|');
  getline(log, name2, '|');
  getline(log, skillname, '|');
  log >> value;
  getline(log, dummy, '|');
  getline(log, dpsorheal, '|');

  // m.insert((name1, value));
     m[name1]+=value;

}
log.close();
for(iter=m.begin(); iter!=m.end(); iter++)
{
cout << iter->first << iter->second << endl;
}
}

grüße phil

zunächst einmal solltest Du nur lesen was Du brauchst. Die Zeit brauchst Du nach Deiner Problembeschreibung nicht; aber

Phill4563 schrieb:

Ein anderes Problem ist die Zeit, die ich auch noch nicht vernünftig einlesen kann.

.. wenn Du die Zeit doch benötigst, so mache Dir eine kleine Struktur - wie genau das geht? frag' nochmal nach.
Ansonsten würde ich Dir empfehlen, einfach alles zu ignorieren, was Du nicht benötigst. Das geht u.a. mit ignore. Verpackt in ein Helferlein skip<> (s.u.) wird es dann übersichtlich in der Handhabung.

Außerdem kannst Du alle Lese-Befehle hintereinander schreiben und (wichtig!) nach dem letzten Lesen prüfen, ob der Stream nicht in den Fehlerzustand gegangen ist. Alles zusammen:

#include "iostream"
#include "string"
#include "fstream"
#include "cstring"
// #include "sstream" // wird hier nicht benötigt
#include "ctime" // ctime ist C++-Standard
#include "map"
#include "limits" // numeric_limits

using namespace std;

template< char C >
std::istream& skip( std::istream& in )
{
    return in.ignore( std::numeric_limits< std::streamsize >::max(), C );
}

int main()
{    
    map<string, int> m; // Variablen so lokal wie möglich anlegen

    // ifstream log("C:\\Users\\Philipp\\Desktop\\out.txt");
    ifstream log("input.txt");
    if( log.is_open() != true)
    { 
        cerr << "cannot open data" << endl;
        return 1 ;
    }
    string name1;
    int value;
    while( getline( log >> skip<'|'>, name1, '|' ) >> skip<'|'> >> skip<'|'> >> value >> skip<'\n'> )
        m[name1]+=value;
    // log.close(); // unnötig, das erledigt der Destruktor von ifstream
    for(map<string, int>::iterator iter=m.begin(); iter!=m.end(); ++iter)
    {
        cout << iter->first << iter->second << endl;
    }
}

macht das gleiche, was schon Dein Programm tut, ist nur kürzer und übersichtlicher.

Phill4563 schrieb:

Wenn ich die Zeile

// m.insert((name1, value));

verwende bekomme ich eine fehlermeldung

Korrekt müsste es heißen

m.insert(make_pair(name1, value));

, aber das willst Du gar nicht, denn sobald ein Element mit dem Key "Respektlos" eigefügt hast, kannst Du keinen zweiten mit dem gleichem Key einfügen.

Gruß
Werner

Das mit dem Zeit Struckt schau ich mir selbst nochmal an und würde mich nochmal melden

Einzig die Zeile

while( getline( log >> skip<'|'>, name1, '|' ) >> skip<'|'> >> skip<'|'> >> value >> skip<'\n'> )

verstehe ich nohc nicht so ganz, vielleicht koenntest du mir nochmal kurz erläutern was hier passiert

Zusätzlich sollten die Werte für "value" nur dann addiert werden wenn sich in der letzten Spalte ein 'H' befindet.

Grüße Philipp

Einzig die Zeile

while( getline( log >> skip<'|'>, name1, '|' ) >> skip<'|'> >> skip<'|'> >> value >> skip<'\n'> )

verstehe ich nohc nicht so ganz, vielleicht koenntest du mir nochmal kurz erläutern was hier passiert

Hallo Philipp

genau wie dieser Code

int a = 14;
    int b = 78;
    cout << "Die Summe von " << a << " und " << b << " ist " << (a+b) << endl;

das gleiche macht wie

int a = 14;
    int b = 78;
    cout << "Die Summe von ";
    cout << a;
    cout << " und ";
    cout << b;
    cout << " ist ";
    cout << (a+b);
    cout << endl;

macht dieser Code:

string name1;
    int value;
    // Format:       " <Zeit>    |   <name1>  |   <name2>   |<skillname> |     <value> ..Rest..EOL"
    while( getline( log >> skip<'|'>, name1, '|' ) >> skip<'|'> >> skip<'|'> >> value >> skip<'\n'> )
    {
        cout << name1 << " -> " << value << endl;
    }

das selbe wie:

string name1;
    int value;
    for(;;) // Beenden der Schleife s.u.
    {
        log >> skip<'|'>;           // skip <Zeit>
        getline( log, name1, '|' ); // read <name1>
        log >> skip<'|'>;           // skip <name1>
        log >> skip<'|'>;           // skip <skillname>
        log >> value;               // read <value>
        log >> skip<'\n'>;          // skip all until EOL (End Of Line)
        if( log.fail() )
            break;  // <== hier wird die Schleife ggf. beendet

        cout << name1 << " -> " << value << endl;
    }

.. das alles einen Ausdruck zu schreiben, sieht vielleicht erst mal kryptisch aus, aber das ist reine Gewöhnung.

Phill4563 schrieb:

Zusätzlich sollten die Werte für "value" nur dann addiert werden wenn sich in der letzten Spalte ein 'H' befindet.

kein Problem, lies es einfach mit ein:

string name1;
    int value;
    string dpsorheal; // was ist das? WoW?
    // Format:                " <Zeit>    |   <name1>  |   <name2>   |<skillname> |     <value>         |   <dpsorheal>  | ..Rest..EOL"
    while( getline( getline( log >> skip<'|'>, name1, '|' ) >> skip<'|'> >> skip<'|'> >> value >> skip<'|'>, dpsorheal, '|' ) >> skip<'\n'> )
    {
        if( dpsorheal == "H" )
            m[name1]+=value;
    }

Bem.: das letzte skip<'\n'> wäre hier nicht mehr notwendig, da kein '|' hinter dem zuletzt gelesenen '|' steht.

Gruß
Werner

danke nochmals

Grüße Phill

Phill4563 schrieb:

21:39:54.305|Respektlos|Respektlos|ExitCombat||EC|

ich habe gerade gesehen, dass die Spalte 'value' nicht immer einen Zahlenwert enthält, ...

Hallo Philipp,

so ein Problem löst man z.B. dadurch, dass man nicht direkt eine Zahl (hier ein int) einliest, sondern ein Objekt einer selbst geschriebenen Klasse, welches erst mal prüft, ob das was da kommt eine Zahl sein könnte oder eben nicht. Ich nenne den Typ eines solchen Objekts mal ' opt ' für 'optional' und dann sähe das so aus:

struct opt // opt für optional; liest ein int, wenn eine Zahl kommt, sonst wird der Wert =0 gesetzt
{
    explicit opt( int& value )
        : value_( value )
    {}
    friend std::istream& operator>>( std::istream& in, opt o ) // Lesefunktion für den Wrapper 'opt'
    {
        char c;
        if( in >> c && in.putback( c ) ) // lese das nächste Zeichen 'c' und stelle es auch gleich zurück!
        {
            if( ('0' <= c && c <= '9') || c == '-' || c == '+' ) // könnte eine Zahl sein
                in >> o.value_; // dann lese die Zahl
            else
                o.value_ = 0; // sonst definiert auf 0 setzen
        }
        return in;
    }
private:
    int& value_;
};

anschließend muss man die Einlesesequenz nur um das ' opt ' erweitern - ergo:

string name1;
    int value;
    string dpsorheal;                                                            //<-- hier optional lesen -->
    // Format:                " <Zeit>    |   <name1>  |   <name2>   |<skillname> |       [<value>]          |   <dpsorheal>  | ..Rest..EOL"
    while( getline( getline( log >> skip<'|'>, name1, '|' ) >> skip<'|'> >> skip<'|'> >> opt(value) >> skip<'|'>, dpsorheal, '|' ) >> skip<'\n'> )
    { // usw.

Gruß
Werner

friend std::istream& operator>>( std::istream& in, opt & /*<-- Referenz*/ o )

das opt Objekt der Einlesefunktion müsste doch eien Referenz sein, oder irre ich mich da Werner?

friend std::istream& operator>>( std::istream& in, opt & /*<-- Referenz*/ o )

.. probier's mal aus! wenn Du nicht gerade einen MSVC6-Compiler verwendest, sollte der Code dann gar nicht übersetzt werden. Der Ausdruck 'opt(value)' in dem while-Statemant erzeugt ein temporäres Objekt!
wenn Referenz, dann

friend std::istream& operator>>( std::istream& in, const opt& /*<-- const Referenz*/ o )

Das opt-Objekt selbst wird ja gar nicht verändert!

.. hätte ich vielleicht gleich dazu schreiben sollen, weil diese Nachfrage kommt fast immer.

Gruß
Werner

Wieso geht das dann?
Oder anders gefragt, warum ergibt das keinen Fehler, kompiliert aber mit Referenz nicht?

mit Referenz
Ohne Referenz

Grüße
Phill

Das nicht, aber wird es nicht kopiert? Das ist ja nur ein Call-By-Value. Und Strukturen, die eine Referenz als Member halten sind doch nicht kopierbarbar.

doch kopierbar sind sie; nur nicht zuweisbar. Zumindest nicht ohne dass man einen eigenen Zuweisungsoperator schreibt.

Skym0sh0 schrieb:

.. kompiliert aber mit Referenz nicht?

weil der Standard es schlicht nicht zulässt. Ich finde die Stelle, wo das steht, eben nicht wieder. Aber eine non-const reference auf ein temporäres Objekt ist nicht zulässig. Und deshalb compiliert es mit Referenz nicht - so der Compiler die Regel beherzigt.

Gruß
Werner

Ich finde die Stelle, wo das steht, eben nicht wieder.

§8.5.3 schrieb:

4.
Given types “cv1 T1” and “cv2 T2,” “cv1 T1” is reference-related to “cv2 T2” if T1 is the same type as T2, or T1 is a base class of T2. “cv1 T1” is reference-compatible with “cv2 T2” if T1 is reference-related to T2 and cv1 is the same cv-qualification as, or greater cv-qualification than, cv2.

5.
A reference to type “cv1 T1” is initialized by an expression of type “cv2 T2” as follows:
If the reference is an lvalue reference and the initializer expression

• is an lvalue (but is not a bit-field), and “cv1 T1” is reference-compatible with “cv2 T2,” or
• has a class type (i.e., T2 is a class type), where T1 is not reference-related to T2, and can be implicitly converted to an lvalue of type “cv3 T3,” where “cv1 T1” is reference-compatible with “cv3 T3”106 (this conversion is selected by enumerating the applicable conversion functions (13.3.1.6) and choosing the best one through overload resolution (13.3)),

then the reference is bound to the initializer expression lvalue in the first case and to the lvalue result of the conversion in the second case (or, in either case, to the appropriate base class subobject of the object).

Eine non-const lvalue-Referenz muss also immer zu einem non-const lvalue gebunden werden.
Das waren die gewöhnlichen Semantiken für lvalue-Referenzen.

Erst im nächsten Abschnitt wird dann für const-lvalue -Referenzen erklärt..

Otherwise, the reference shall be an lvalue reference to a non-volatile const type (i.e., cv1 shall be const), or the reference shall be an rvalue reference.
If the initializer expression

• is an xvalue, class prvalue, array prvalue or function lvalue and “cv1 T1” is reference compatible with “cv2 T2”, or
• has a class type (i.e., T2 is a class type), where T1 is not reference-related to T2, and can be implicitly converted to an xvalue, class prvalue, or function lvalue of type “cv3 T3”, where “cv1 T1” is reference-compatible with “cv3 T3”

then the reference is bound to the value of the initializer expression in the first case and to the result of the conversion in the second case (or, in either case, to an appropriate base class subobject). [...]

Otherwise, a temporary of type “cv1 T1” is created and initialized from the initializer expression using the rules for a non-reference copy-initialization (8.5). The reference is then bound to the temporary.

Achtung: Die letzten beiden Sätze treffen nicht immer zu.
schreibt, dann trifft das auf die obige Erklärung zu;

std::string const& = std::string{};

Wenn man jedoch

std::string const& = "ABC";

Dann trifft es auf die letzte Erklärung zu.

Zumindest nicht ohne dass man einen eigenen Zuweisungsoperator schreibt.

Wie sollen sie dann zuweisbar sein? Es ist klar festgelegt, dass eine Referenz ihren Referenten nicht ändern kann:

A reference cannot be changed to refer to another object after initialization. Note that initialization of a reference is treated very differently from assignment to it.

Daher ist in Klassen immer ein Zeiger besser aufgehoben.