Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Fehlerfreies Kapitel 8, Logfile-Klasse

Werbeanzeige

Co1m

Frischling

  • »Co1m« ist der Autor dieses Themas

Beiträge: 19

Wohnort: Häusern

Beruf: Informatikkaufmann

  • Private Nachricht senden

1

09.09.2007, 18:15

Fehlerfreies Kapitel 8, Logfile-Klasse

Hallo zusammen,
ich hätte eine bitte an alle, die C++ erfahren genung sind.
Bitte schreibt Listing 8.11 (LogFile) Klassen so um das dies unter Visual Express 2005 fehlerfrei laufen.
Bekannte Probleme sind ja 'fopen' probleme sowie die 'vsprintf' probleme.
Ich habe dieses Forum durchsucht und auch alle Vorschläge umgesetzt. Jedoch ohne Erfolg.
Ich beziehe mich hier auf folgende Threads:
https://www.spieleprogrammierer.de/phpBB…opic.php?t=5449
https://www.spieleprogrammierer.de/phpBB…opic.php?t=8014

Dankbar wäre ich auch für alternativ einfache LogFileClassen die ich in meine Projekte (ohne weiteres / Probleme) einbinden kann.

Dann könnte man zukünftig auch immer auf diesen Thread verweisen.

Mit freundlichen Grüßen

Daniel alias Co1m

Co1m

Frischling

  • »Co1m« ist der Autor dieses Themas

Beiträge: 19

Wohnort: Häusern

Beruf: Informatikkaufmann

  • Private Nachricht senden

2

09.09.2007, 19:19

Lösung

Hallo zusammen,
durch hilfe von "kaid" habe ich folgende Lösung für das Problem mit fopen und vsprintf gefunden:
Hier der neue Code umd fopen Warnung zu beheben:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

void CLogfile::CreateLogfile (const char *LogName)
{
    // Logfile leeren und Kopf schreiben

    fopen_s(&m_Logfile, LogName, "w");  //ÄNDERUNG

    Textout ("<html><head><title>Logfile</title></head>");
    Textout ("<body><font face='courier new'>");
    WriteTopic ("Logfile", 3);

        ...
    
    // Logfile schließen und mit append wieder öffnen

    fclose (m_Logfile);
    fopen_s(&m_Logfile, LogName, "a"); //ÄNDERUNG


} // CreateLogfile


Alter Code sah ja so aus:

C-/C++-Quelltext

 
1
2
3

m_Logfile = fopen (LogName, "w");
...
m_Logfile = fopen (LogName, "a");


Um die vsprintf Warnung wegzubekommen folgende Änderung vornehmen:
3 Mal muss in den Funktionen fTextout (kommt 4 mal vor, da überladen)
dieser Code:

C-/C++-Quelltext

 
1

TCHAR buffer[MAX_BUFFER];

durch diesen ersetzt werden (Strg+H)

C-/C++-Quelltext

 
1

char *buffer = new char[MAX_BUFFER];

und dieser Code:

C-/C++-Quelltext

 
1

vsprintf (buffer, Text, pArgList);

durch diesen ersetzt werden (Strg+H)

C-/C++-Quelltext

 
1

vsprintf_s(buffer,MAX_BUFFER, Text, pArgList);


Noch ein Hinweis: Da ich selber noch kein C++-Crack bin... ich verstehe nicht genau was da gemacht wird... da das 8te Kapitel imo für Anfänger unzulänglich erklärt wird, würde es mich sehr freuen wenn jemand erklären würde was man da genau gemacht hat und warum.

Mit freunlichen Grüßen

Daniel alias Co1m

Co1m

Frischling

  • »Co1m« ist der Autor dieses Themas

Beiträge: 19

Wohnort: Häusern

Beruf: Informatikkaufmann

  • Private Nachricht senden

3

10.09.2007, 10:35

Fehlen von Singelton.hpp

Hallo zusammen,
ein weiterer Fehler meinerseits, der mir aufgefallen ist als ich die drei Dateien
[list]Logfile.cpp
Logfile.hpp
Singleton.hpp[/list]für ein neues Projekt eingebunden habe war, dass die Datei Singleton.hpp nicht gefunden wurde.
Lösung:

Logfile.hpp:

C-/C++-Quelltext

 
1
2
3
4

#include <windows.h>
#include <stdio.h>
#include <Singleton.hpp>
...

Neuer Code Logfile.hpp:

C-/C++-Quelltext

 
1
2
3
4

#include <windows.h>
#include <stdio.h>
#include "Singleton.hpp"
...


Alternativ könnte man den Pfad wo die Datei Singleton im Include Verzeichnispfad einbinden unter Extras => Optionen => VC++-Verzeichnisse und dort Include-Dateien auswählen.

Grüße

Daniel alias Co1m

Co1m

Frischling

  • »Co1m« ist der Autor dieses Themas

Beiträge: 19

Wohnort: Häusern

Beruf: Informatikkaufmann

  • Private Nachricht senden

4

10.09.2007, 11:05

Kompletter Code

Hallo,
hier mal mein aktueller kompletter Code.
Diese ist FAST Bugfrei, auf den einen Bug komme ich am Ende zu sprechen.
Logfile Klasse besteht aus 3 Dateien sowie eine Main / Test-File.
[list]Logfile.cpp
Logfile.hpp
Singleton.hpp
A_START.cpp[/list]
Logfile.hpp

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

#ifndef __Clogfile
#define __Clogfile

// Includes

//

#include <windows.h>
#include <stdio.h>
#include "Singleton.hpp"

// Defines

#define MAX_BUFFER 4096             // Maximale Größe für den Buffer

#define L_FAIL false                // Funktion war erfolgreich

#define L_OK   true                 // Funktion ist fehlgeschlagen

#define Log_File Clogfile::Get () // Makro zur einfachen Verwendung


// Farben für den Text

enum FONTCOLORS
{
    BLACK,
    RED,
    GREEN,
    BLUE,
    PURPLE
};

// Klassendeklaration

//

class Clogfile : public TSingleton<Clogfile>
{
    // Memberfunktionen

    public:

        Clogfile       ();
        ~Clogfile      ();
        void CreateLogfile  (const char *LogName);
        void WriteTopic     (const char *Topic, int Size);
        void Textout        (const char *Text);
        void Textout        (int Color, const char *Text);
        void Textout        (int Color, bool List, const char *Text);
        void TextoutF       (const char *Text, ...);
        void TextoutF       (int Color, const char *Text, ...);
        void TextoutF       (int Color, bool List, const char *Text, ...);
        void FunctionResult (const char *Name, bool Result);

        // Membervariablen

        private:

        FILE *m_logfile;

};

#endif


Logfile.cpp:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177

#include "logfile.hpp"

// Konstruktor

// Aufgabe: Bisher noch keine

Clogfile::Clogfile ()
{

}

// Destruktor

// Aufgabe: Gibt Ende-Meldung aus und schließ das Logfile

Clogfile::~Clogfile ()
{
    // logfile-Ende schreiben und Datei schließen

    Textout ("<br><br>===End of logfile===</font></body></html>");
    fclose (m_logfile);
}

// Createlogfile

// Aufgabe: logfile erstellen und Kopf schreiben

void Clogfile::CreateLogfile (const char *LogName)
{
    // logfile leeren und Kopf schreiben

    fopen_s(&m_logfile, LogName, "w");
    Textout ("<html><head><title>Logfile</title></head>");
    Textout ("<body><font face='courier new'>");
    WriteTopic ("Logfile", 3);

    // Aktuelle Build-Konfiguration ausgeben

    #ifdef _DEBUG
    Textout ("BUILD: DEBUG<br>");
    #else
    Textout ("BUILD: RELEASE<br>");
    #endif

    // Link für E-Mail-Adresse schreiben

    Textout ("<a href='mailto:Daniel.Mislovic@gmail.com?subject=Logfile'>");
    Textout ("Send E-Mail to me</a><br><br>");

    // logfile schließen und mit append wieder öffnen

    fclose (m_logfile);
    fopen_s(&m_logfile, LogName, "a");
}

// WriteTopic

// Aufgabe: Überschrift erzeugen

void Clogfile::WriteTopic (const char *Topic, int Size)
{
    // Überschrift schreiben und flushen

    Textout ("<table cellspacing='0' cellpadding='0' width='100%%' ");
    Textout ("bgcolor='#DFDFE5'>\n<tr>\n<td>\n<font face='arial' ");
    TextoutF ("size='+%i'>\n", Size);
    Textout (Topic);
    Textout ("</font>\n</td>\n</tr>\n</table>\n<br>");
    fflush (m_logfile);
}

// Textout

// Aufgabe: Text ins logfile schreiben (schwarz)

void Clogfile::Textout (const char *Text)
{
    // Text schreiben und flushen

    fprintf (m_logfile, Text);
    fflush (m_logfile);
}

// Textout

// Aufgabe: Text ins logfile schreiben (farbig)

void Clogfile::Textout (int Color, const char *Text)
{
    Textout (Color, false, Text);
}

// Textout

// Aufgabe: Text ins logfile schreiben (farbig, Liste)

void Clogfile::Textout (int Color, bool List, const char *Text)
{
    //Listen-Tag schreiben

    if (List == true)
    Textout ("<li>");

    // Farbtag schreiben

    switch (Color)
    {
        case BLACK:
            Textout ("<font color=black>");  break;
        case RED:
            Textout ("<font color=red>");    break;
        case GREEN:
            Textout ("<font color=green>");  break;
        case BLUE:
            Textout ("<font color=blue>");   break;
        case PURPLE:
            Textout ("<font color=purple>"); break;
    };

    // Text schreiben

    Textout (Text);
    Textout ("</font>");

    if (List == false)
        Textout ("<br>");
    else
        Textout ("</li>");
}

// TextoutF

// Aufgabe: formatierten Text ins logfile schreiben (schwarz)

void Clogfile::TextoutF (const char *Text, ...)
{
    char *buffer = new char[MAX_BUFFER];    // char-Buffer

    va_list pArgList;                       // Liste der übergebenen Argumente


    // String aus den Argumenten erstellen

    va_start (pArgList, Text);
    vsprintf_s(buffer,MAX_BUFFER, Text, pArgList);
    va_end (pArgList);

    // Erzeugten String schreiben

    Textout (buffer);
}

// TextoutF

// Aufgabe: formatierten Text ins Logfile schreiben (farbig)

void Clogfile::TextoutF (int Color, const char *Text, ...)
{
    char *buffer = new char[MAX_BUFFER];    // char-Buffer

    va_list pArgList;                       // Liste der übergebenen Argumente


    // String aus den Argumenten erstellen

    va_start (pArgList, Text);
    vsprintf_s(buffer,MAX_BUFFER, Text, pArgList);
    va_end (pArgList);

    // Erzeugten String schreiben

    Textout (Color, buffer);
}

// TextoutF

// Aufgabe: formatierten Text ins logfile schreiben (farbig, Liste)

void Clogfile::TextoutF (int Color, bool List,const char *Text, ...)
{
    char *buffer = new char[MAX_BUFFER];  // char-Buffer

    va_list pArgList;          // Liste der übergebenen Argumente


    // String aus den Argumenten erstellen

    va_start (pArgList, Text);
    vsprintf_s(buffer,MAX_BUFFER, Text, pArgList);
    va_end (pArgList);

    // Erzeugten String schreiben

    Textout (Color, List, buffer);
}

// FunctionResult

// Aufgabe: OK oder ERROR für Funktionsaufruf ausgeben

void Clogfile::FunctionResult (const char *Name, bool Result)
{
    if (L_OK == Result)
    {
        Textout("<table width='100%%' cellSpacing='1' cellPadding='5'");
        Textout(" border='0' bgcolor='#C0C0C0'><tr><td bgcolor=");
        TextoutF("'#FFFFFF' width='35%%'>%s</TD>", Name);
        Textout("<td bgcolor='#FFFFFF' width='20%%'><font color =");
        Textout("'green'>OK</FONT></TD><td bgcolor='#FFFFFF' ");
        Textout("width='35%%'>-/-</TD></tr></table>");
    }
    else
    {
        Textout("<table width='100%%' cellSpacing='1' cellPadding='5'");
        Textout(" border='0' bgcolor='#C0C0C0'><tr><td bgcolor=");
        TextoutF("'#FFFFFF' width='35%%'>%s</TD>", Name);
        Textout("<td bgcolor='#FFFFFF' width='20%%'><font color =");
        Textout("'red'>ERROR</FONT></TD><td bgcolor='#FFFFFF' ");
        Textout("width='35%%'>-/-</TD></tr></table>");
    }
}


Singleton.hpp:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

#ifndef TSINGLETON
#define TSINGLETON

template <class T>
class TSingleton
{
    protected:

        // Membervariablen

        static T *m_pSingleton;   // Statisches Objekt


    public:

        // Memberfunktionen


        // Destruktor

        //

        virtual ~TSingleton ()
        {
        }

        // Get

        //

        // Aufgabe: Wenn nötig, statisches Objekt erzeugen und

        // Zeiger darauf zurückgeben

        //

        inline static T* Get ()
        {
            // Existiert schon eine Instanz?

            if (!m_pSingleton)
                m_pSingleton = new T;   // Nein, dann neue Instanz erzeugen


            // Zeiger auf die Instanz zurückgeben

            return (m_pSingleton);

        } // Get


        // Statisches Objekt freigeben

        //

        static void Del ()
        {
            // Gab es eine Instanz?

            if (m_pSingleton)
            {
                delete (m_pSingleton);  // Ja, dann freigeben

                m_pSingleton = NULL;    // und Zeiger auf NULL setzen

            }

        } // Del


};

// Die statische Variable erzeugen

//

template <class T>
T* TSingleton<T>::m_pSingleton = 0;

#endif


A_START.cpp:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

#include <iostream>
#include "Logfile.hpp"

using namespace std;

// Hauptprogramm

//

int main ()
{
    cout << "Hello World" << endl;


    float Kontrolle = 123.001f; // Variable zum Testen

    int test = 5;
    
    //###################################

    //TEST FÜR LOGFILE

    //###################################


    // Neues Logfile erstellen

    Log_File->CreateLogfile ("Logfile.html");

    // Überschrift erzeugen

    Log_File->WriteTopic ("Überschrift Größe 0", 0);
    Log_File->WriteTopic ("Überschrift Größe 1", 1);
    Log_File->WriteTopic ("Überschrift Größe 2", 2);
    Log_File->WriteTopic ("Überschrift Größe 3", 3);
    Log_File->WriteTopic ("Überschrift Größe 4", 4);

    // Unformatierten Text ausgeben

    // Für Absatz einfach <br> in den Text hängen

    Log_File->Textout ("Unformatierter Text.<br>");

    // Formatierter Text in Farbe, automatischer Absatz, reiner Text

    Log_File->Textout (BLACK, "Schwarzer Text Blub");
    Log_File->Textout (RED, "Roter Text Blub");
    Log_File->Textout (BLUE, "Blauer Text Blub");
    Log_File->Textout (GREEN, "Grüner Text Blub");
    Log_File->Textout (PURPLE, "Purple Text Blub");

    //Benutzung von Int Variablen, beachte Formatierungsspezifizierer %i

    Log_File->TextoutF ("Kontrollvariable:i %i", test);
    Log_File->Textout("<br>");
    
    /*Liste ausgeben von Int Variablen HIER FEHLER, DESHALB AUSKOMMENTIERT
    Log_File->TextoutF("Inhalt von test lautet: i%", test);
    Log_File->TextoutF(RED, true, "Inhalt von test lautet: i%", test);
    Log_File->TextoutF(BLUE, true, "Inhalt von test lautet: i%", test);
    Log_File->TextoutF(GREEN, true, "Inhalt von test lautet: i%", test);
    Log_File->TextoutF(PURPLE, true, "Inhalt von test lautet: i%", test);
    */

    // Liste ausgeben, Benutzung von Float Variablen

    Log_File->TextoutF (BLACK, true, "Liste Kontrolle: %f", Kontrolle);
    Log_File->TextoutF (BLACK, true, "Liste Kontrolle: %f", Kontrolle*2.0f);
    Log_File->TextoutF (BLACK, true, "Liste Kontrolle: %f", Kontrolle*4.0f);

    // Erfolgreiche und Fehlgeschlagene Funktionen

    Log_File->FunctionResult ("Funktion_Eins", L_OK);
    Log_File->FunctionResult ("Funktion_Zwei", L_OK);
    Log_File->FunctionResult ("Funktion_Header_Laden", L_OK);
    Log_File->FunctionResult ("Funktion_Level_ASD_Laden", L_FAIL);
    Log_File->FunctionResult ("Funktion_Sound_Laden", L_OK);
    Log_File->FunctionResult ("Funktion_Drei", L_OK);
    Log_File->FunctionResult ("Funktion_Vier", L_FAIL);
    Log_File->FunctionResult ("Funktion_Fünf", L_OK);
    Log_File->FunctionResult ("Funktion_Sechs", L_OK);
    Log_File->FunctionResult ("Funktion_Sieben", L_FAIL);

    // Logfile schließen

    Log_File->Del ();

    return 0;
}


Puhhh... sehr sehr viel Code für jemanden wie mich ;-)...
Kommen wir nun zum BUG...
Ich habe im main() mal einen Abschnitt auskommentiert, sobald dieser nicht Auskommentiert ist bringt das Programm während der Laufzeit einen "Debug Assertion Failed"...
D.h. Einmaliges Aufrufen funktioniert, aber mehrfaches aufrufen nicht... irgendwie...
Pretty Strange...

Vielleicht kann mir ja jemand von euch weiterhelfen.

Mit freundlichen Grüßen

Daniel

David_pb

Community-Fossil

Beiträge: 3 886

Beruf: 3D Graphics Programmer

  • Private Nachricht senden

5

10.09.2007, 11:24

Da hätt ich noch ein paar Fragen:

o Wieso machst du das?

C-/C++-Quelltext

 
1
2
3

// logfile schließen und mit append wieder öffnen 

fclose (m_logfile); 
fopen_s(&m_logfile, LogName, "a");


o Wieso hältst du dich nicht an die "constcorrectness"?

o Wieso nutzt du nicht weiterhin die (konformen) Methoden fopen, vsprintf?

o Wieso gibst du den Speicher von buffer in TextoutF nie frei (das bringt doch nur Memoryleaks)?

o Wieso verwendest du nicht einfach char buffer[ MAX_BUFFER ] (dann hättest du dein Freigabeproblem nicht)?

o Wieso verwendest du ein Singleton?

o Wieso gibt das Singleton einen Zeiger zurück und keine Referenz?

o Wieso prüfst du in der Funktion TSingleton::Del ob der Zeiger m_pSingleton 0 ist?

o Wieso schließt CreateLogfile eine evtl geöffnete Datei nicht vor dem öffnen einer weiteren Datei?

o Wieso verwendest du nicht den Debugger um zu sehen wo die etwas behauptet wird was nicht stimmt?
@D13_Dreinig

Co1m

Frischling

  • »Co1m« ist der Autor dieses Themas

Beiträge: 19

Wohnort: Häusern

Beruf: Informatikkaufmann

  • Private Nachricht senden

6

10.09.2007, 11:40

wow... ich versuche jetzt mal nicht beleidigt zu sein... :cry:
Also, ich bin Noop. Ich habe mich mit dem Buch C++ für Spieleprogrammierer bis Kapitel 8 Durchgekämpft, was soweit auch ganz gut funktioniert hat.
Die 3 Files Logfile.cpp Logfile.hpp Singleton.hpp sind aus dem Buch von Heiko Kalista.

Zitat

o Wieso nutzt du nicht weiterhin die (konformen) Methoden fopen, vsprintf?

Weil ich dann einige Warnings bekomme das diese Veraltet sind. Ich wollte ein sauberes File. Mit Hilfe von "kaid" habe ich bzw. er diese so umgeschrieben (wie oben im Zweiten Post beschrieben) damit die Warnings nicht mehr kommen.

Zitat


o Wieso hältst du dich nicht an die "constcorrectness"?

Weil ich nicht weiß was das bedeutet?! Wie gesagt C++ Beginner...

Auf die restlichen Fragen kann ich nur so Antworten das ich dieses Logfile so übernommen habe und es nur Fehlerfrei bügeln wollte. Ich selbst habe zu wenig erfahrung um dir zu sagen warum Heiko Kalista es so gemacht hat.
Deshalb ja dieser Thread.

Zitat


o Wieso verwendest du nicht den Debugger um zu sehen wo die etwas behauptet wird was nicht stimmt?


Debugger kommt erst in Kapitel 8.8 dran :-D, Logfile ist 8.6
Habe es versucht, aber auch hier fehlt mir das wissen.

Vielleicht sollte ich doch bei Java bleiben, was?

Ich würde mich sehr über eine freundliche Antwort freuen.

Grüße

Daniel

David_pb

Community-Fossil

Beiträge: 3 886

Beruf: 3D Graphics Programmer

  • Private Nachricht senden

7

10.09.2007, 12:02

Zitat von »"Co1m"«

wow... ich versuche jetzt mal nicht beleidigt zu sein... :cry:
Also, ich bin Noop. Ich habe mich mit dem Buch C++ für Spieleprogrammierer bis Kapitel 8 Durchgekämpft, was soweit auch ganz gut funktioniert hat.
Die 3 Files Logfile.cpp Logfile.hpp Singleton.hpp sind aus dem Buch von Heiko Kalista.


Nichts für ungut! Wollts ja nur wissen! :p

Zitat von »"Co1m"«


Zitat

o Wieso nutzt du nicht weiterhin die (konformen) Methoden fopen, vsprintf?

Weil ich dann einige Warnings bekomme das diese Veraltet sind. Ich wollte ein sauberes File. Mit Hilfe von "kaid" habe ich bzw. er diese so umgeschrieben (wie oben im Zweiten Post beschrieben) damit die Warnings nicht mehr kommen.


Die kommen nur bei Microsoftcompilern. Microsoft hat sich hier nämlich Gedanken über die Sicherheit gemacht und deshalb potentiell gefährliche Funktionen als "veraltet" markiert und durch sichere Equivalente ersetzt. Leider sind diese "secure" Funktionen nicht portabel (soll heißen, sie funktionieren nur auf Microsoftcompilern und nicht auf anderen C++ Compilern). Um die Warnungen auszuschalten kann man ganz einfach ein:

C-/C++-Quelltext

 
1

#define _CRT_SECURE_NO_DEPRECATE 1


vor der Verwendung entsprechender Funktionen.

Zitat von »"Co1m"«


Zitat


o Wieso hältst du dich nicht an die "constcorrectness"?

Weil ich nicht weiß was das bedeutet?! Wie gesagt C++ Beginner...


Dann solltest du dich darüber Informieren. Google bietet genug Informationsmaterial! :)

Zitat von »"Co1m"«


Auf die restlichen Fragen kann ich nur so Antworten das ich dieses Logfile so übernommen habe und es nur Fehlerfrei bügeln wollte. Ich selbst habe zu wenig erfahrung um dir zu sagen warum Heiko Kalista es so gemacht hat.
Deshalb ja dieser Thread.


Naja, auf jedenfall solltest du dich ganz schnell um das Memoryleak Problem kümmern. Niemand will das der Speicher unnötig zugeschaufelt wird und mit Datenmüll voll läuft! Steht das wirklich so im Buch? Das wär ja nahezu ein Skandal! ;)

o Desweiteren kann die Klasse zwar ein Singleton sein, ist aber nicht logisch eigentlich. Weil ja durchaus mehr Logfiles verwendet werden können.

o C++ garantiert das ein delete auf einen 0 Zeiger sicher ist. Also brauchst du vor einem delete nie zu testen ob ein Zeiger 0 ist.

o Singletons sollten keine Zeiger zurückgeben sondern Referenzen. Wenn Zeiger zurückgegeben werden ist die Gefahr sehr hoch das irgendwo versucht wird den Speicher auf den gezeigt wird freizugeben.

o Die Freigabe des Singletons ist mit der Methode Del nicht wirklich optimal gelöst, wie ich finde. Für sowas gibts Destruktoren.

o Bei CreateLogfile solltest du einfach prüfen ob die Datei schon offen ist. Wenn ja einfach schließen, sonst hast du evtl viele "geöffnete" Dateien die du nichtmehr geschlossen bekommst.

o Warum die die Datei bei CreateLogfile erst öffnest, dann schließt und dann wieder öffnest ist mir immer noch schleierhaft.

Zitat von »"Co1m"«


Zitat


o Wieso verwendest du nicht den Debugger um zu sehen wo die etwas behauptet wird was nicht stimmt?


Debugger kommt erst in Kapitel 8.8 dran :-D, Logfile ist 8.6
Habe es versucht, aber auch hier fehlt mir das wissen.


Achso...

Zitat von »"Co1m"«


Vielleicht sollte ich doch bei Java bleiben, was?


Bloß nicht!
@D13_Dreinig

Co1m

Frischling

  • »Co1m« ist der Autor dieses Themas

Beiträge: 19

Wohnort: Häusern

Beruf: Informatikkaufmann

  • Private Nachricht senden

8

10.09.2007, 12:17

Also, um das nochmal klar zu stellen:
Die Files sind 1:1 aus seinem Buch bzw. von der CD kopiert.
Die einzigen Änderungen die ich gemacht habe war fopen sowie vssprint.
Somit ist die LogFile-Klasse deiner Meinung nach "schlecht" gecodded...
OK, dann rufe ich hier zum einfachen Logfile Codding auf.
Eine einfache Aufgabe, oder? Eine Klasse die sich in jedes Projekt einbinden lässt mit ein paar einfachen Möglichkeiten ein Logfile zu erstellen (halt wie das oben, nur Bugfrei, Optimiert...

Ja, das mit Java ist halt so ne Sache...
Ich werde mal versuchen deine Ratschläge umzusetzen. Mal schauen ob ich es hinbekomme eine Eigene Logfile Klasse zu schreiben...

Grüße

Daniel

David_pb

Community-Fossil

Beiträge: 3 886

Beruf: 3D Graphics Programmer

  • Private Nachricht senden

9

10.09.2007, 15:23

Hier, ganz simpel:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

#include <cstdio>
#include <cassert>
#include <cstdarg>

class LogFile
{
public:
    LogFile() : handle( 0 )
    {}

    explicit LogFile( const char* fileName ) : handle( 0 )
    {
        Open( fileName );
    }

    ~LogFile() 
    {
        Close();
    }

    bool Open( const char* fileName )
    {
        Close();

        handle = fopen( fileName, "w" );

        if ( handle )
        {
            // do not buffer any data

            setvbuf( handle, 0, _IONBF, 0 );
    
            // write some headerinfos

            Write( "Created on [...]\n" );
        }

        return ( handle != 0 );
    }

    void Close()
    {
        if ( handle )
        {
            fclose( handle );
            handle = 0;
        }
    }

    void Write( const char* text, ... )
    {
        assert( handle );

        char buffer[ 2048 ];
        va_list argptr;

        va_start( argptr, text );
        vsprintf( buffer, text, argptr );
        va_end( argptr );

        fprintf( handle, buffer );
    }

private:
    FILE* handle;
};
@D13_Dreinig

DasBlub

Alter Hase

Beiträge: 802

Wohnort: Schweiz

Beruf: Programmierer

  • Private Nachricht senden

10

10.09.2007, 19:12

Re: Kompletter Code

@Co1m:

ich hab den fehler in deinem auskommentierten teil gefunden:

original:

Zitat


A_START.cpp:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include <iostream>
#include "Logfile.hpp"

using namespace std;

// Hauptprogramm

//

int main ()
{
    [...]
    /*Liste ausgeben von Int Variablen HIER FEHLER, DESHALB AUSKOMMENTIERT
    Log_File->TextoutF("Inhalt von test lautet: i%", test);
    Log_File->TextoutF(RED, true, "Inhalt von test lautet: i%", test);
    Log_File->TextoutF(BLUE, true, "Inhalt von test lautet: i%", test);
    Log_File->TextoutF(GREEN, true, "Inhalt von test lautet: i%", test);
    Log_File->TextoutF(PURPLE, true, "Inhalt von test lautet: i%", test);
    */
    [...]
    // Logfile schließen

    Log_File->Del ();

    return 0;
}



richtig:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8

    [...]
    //Liste ausgeben von Int Variablen HIER FEHLER, DESHALB AUSKOMMENTIERT

    Log_File->TextoutF("Inhalt von test lautet: %i", test);
    Log_File->TextoutF(RED, true, "Inhalt von test lautet: %i", test);
    Log_File->TextoutF(BLUE, true, "Inhalt von test lautet: %i", test);
    Log_File->TextoutF(GREEN, true, "Inhalt von test lautet: %i", test);
    Log_File->TextoutF(PURPLE, true, "Inhalt von test lautet: %i", test);
    [...]


du hattest i% statt %i geschrieben.

Werbeanzeige