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!

Logfile - buffer ('TCHAR [1024]' in 'char*')

Werbeanzeige

$nooc

Alter Hase

  • »$nooc« ist der Autor dieses Themas

Beiträge: 873

Wohnort: Österreich / Kärnten

Beruf: Schüler

  • Private Nachricht senden

1

05.05.2006, 08:36

Logfile - buffer ('TCHAR [1024]' in 'char*')

hallo leute.. also..

ich hab mir zum anfang das buch "C++ für Spieleprogrammierer" zugelegt!

ich befinde mich nun im 8ten kapitel, wo es darum geht eine Logfile klasse zu schreiben!

nun hab ich folgendes problem...

wenn ich das programm compiliere tretet folgender fehler auf:

Zitat


Fehler 3 error C2664: 'vsprintf': Konvertierung des Parameters 1 von 'TCHAR [1024]' in 'char *' nicht möglich c:\dokumente und einstellungen\$ilentsnooc\eigene dateien\ms visual c++\c++\c++ für spieleprogrammierer\kapitel 2\logfile\logfile\clogfile.cpp 113



wenn ich jedoch das programm von der CD auf meine festplatte kopiere und es dann ausführe, dann funktioniert alles einwandfrei!

code meines progs:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10

//...


//String aus den Argumenten erstellen

    va_start (pArgList, Text);
    vsprintf (buffer, Text, pArgList);
    va_end (pArgList);

    //Erzeugten String schreiben

    Textout (buffer);
//...


code des programms auf der CD:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9

//...

// String aus den Argumenten erstellen

    va_start (pArgList, Text);
    vsprintf (buffer, Text, pArgList);
    va_end (pArgList);

    // Erzeugten String schreiben

    Textout (buffer);
//...


wie man sehen kann.. kein unterschied..

warum bekomme ich einen konvertierungsfehler?? :rolleyes:
Am Anfang der Weisheit steht die eigene Erkenntnis, dass man selbst nichts weiß! - Sokrates

$nooc

Alter Hase

  • »$nooc« ist der Autor dieses Themas

Beiträge: 873

Wohnort: Österreich / Kärnten

Beruf: Schüler

  • Private Nachricht senden

2

05.05.2006, 09:45

da es unerwünscht ist doppelte beiträge zu posten hab ich zuerst nachgesehn ob jem. vllt. das selbe problem hatte..

habs leider zuspät gefunden..

HIER hatte jemand dasselbe problem.. da wird gesagt man soll

fopen_s(&m_Logfile, LogName, "w");

anstatt
fopen(..); verwenden

nun.. jetzt habe ich das versucht..

C-/C++-Quelltext

 
1
2
3
4
5

//...

//Logfile leeren und Kopf schreiben

    m_Logfile = fopen_s(&m_Logfile, LogName, "w");
    Textout("<html><head><title>Logfile</title></head>");
//...


aber jetzt bekomme ich den fehler:

Zitat


Fehler 1 error C2440: '=': 'errno_t' kann nicht in 'FILE *' konvertiert werden c:\dokumente und einstellungen\$ilentsnooc\eigene dateien\ms visual c++\c++\c++ für spieleprogrammierer\kapitel 2\logfile\logfile\clogfile.cpp 22

Am Anfang der Weisheit steht die eigene Erkenntnis, dass man selbst nichts weiß! - Sokrates

grek40

Alter Hase

Beiträge: 1 491

Wohnort: Dresden

  • Private Nachricht senden

3

05.05.2006, 13:33

Ich vermute, dass in den Projekteinstellungen bei dir UNICODE und auf der CD ANSI Zeichen eingestellt sind. Kann aber auch andere Gründe haben

X-treme

Frischling

Beiträge: 5

Wohnort: Niederösterreich

  • Private Nachricht senden

4

05.05.2006, 14:55

Da du einen Zeiger auf den FILE*-Zeiger übergibst und dieser von der Funktion gefüllt wird, kannst du dir das "m_Logfile = " sparen.

Also:

fopen_s(&m_Logfile, LogName, "w");

Die Funktion liefert außerdem keinen Zeiger auf die FILE-Struktur zurück, sondern, wenn ein Fehler beim Öffnen der Datei aufgetreten ist, Informationen über diesen.

Anonymous

unregistriert

5

05.05.2006, 18:36

Unicode usen rocks. Sucht im Forum nach Unicode und ihr bekommt eure Antwort.

$nooc

Alter Hase

  • »$nooc« ist der Autor dieses Themas

Beiträge: 873

Wohnort: Österreich / Kärnten

Beruf: Schüler

  • Private Nachricht senden

6

06.05.2006, 12:44

Zitat von »"X-treme"«

Da du einen Zeiger auf den FILE*-Zeiger übergibst und dieser von der Funktion gefüllt wird, kannst du dir das "m_Logfile = " sparen.


also sollte es mit

C-/C++-Quelltext

 
1

fopen_s(&m_Logfile, LogName, "w");

funktionieren? also .. ich hab jetzt den laptop nicht da und kanns nicht ausprobieren... aber denkst du dass es nicht geht weil ich "m_Logfile = " schreibe?

Zitat von »"grek40"«


Ich vermute, dass in den Projekteinstellungen bei dir UNICODE und auf der CD ANSI Zeichen eingestellt sind. Kann aber auch andere Gründe haben

hm.. wo kann ich das umstellen? ^^
Am Anfang der Weisheit steht die eigene Erkenntnis, dass man selbst nichts weiß! - Sokrates

Anonymous

unregistriert

7

06.05.2006, 13:22

$nooc
Man stellt sowas nicht um, sondern man benutzt es ;)

X-treme

Frischling

Beiträge: 5

Wohnort: Niederösterreich

  • Private Nachricht senden

8

06.05.2006, 16:53

Zitat von »"$nooc"«

Zitat

Fehler 1 error C2440: '=': 'errno_t' kann nicht in 'FILE *' konvertiert werden c:\dokumente und einstellungen\$ilentsnooc\eigene dateien\ms visual c++\c++\c++ für spieleprogrammierer\kapitel 2\logfile\logfile\clogfile.cpp 22

Dieser Fehler tritt auf, weil die Funktion "fopen_s" einen Rückgabewert vom Typ "errno_t" und nicht, wie bei "fopen", vom Typ "FILE*" liefert.

Zitat von »"$nooc"«

Zitat

Fehler 3 error C2664: 'vsprintf': Konvertierung des Parameters 1 von 'TCHAR [1024]' in 'char *' nicht möglich c:\dokumente und einstellungen\$ilentsnooc\eigene dateien\ms visual c++\c++\c++ für spieleprogrammierer\kapitel 2\logfile\logfile\clogfile.cpp 113

Versuchs mal mit der Funktion wvsprintf
Visit http://www.xt-dev.at.tf

$nooc

Alter Hase

  • »$nooc« ist der Autor dieses Themas

Beiträge: 873

Wohnort: Österreich / Kärnten

Beruf: Schüler

  • Private Nachricht senden

9

07.05.2006, 15:32

...
...
..
.

edit No 10000!

also.. hab wieder lösungen zu meinen problemen gefunden!
das ganze geht mir mitlerweile schon etwas aufm a**** weil ich mir nämlich als anfänger etwas schwer tue.. naja. aber das ist nunmal so am anfang aller dinge bei denen man sich etwas schwer tut!


nix da hat mir freundlicherweise einiges klargemacht.. habe mich an seine anweisungen gehalten und es tatsächlich geschafft meine logfile.cpp so zu schreiben, dass mein compiler keine fehler mehr ausspuckt:

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

#ifndef __CLOGFILE
#define __CLOGFILE

//includes

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

//defines

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

#define L_FAIL false                //Funktion erfolgreich

#define L_OK true                   //Funktion ist fehlgeschlagen

#define g_pLogfile CLogfile::Get()  //Makro zur einfachen verwendung


//Farben für den Text 

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

//Klassendeklaration

class CLogfile : public TSingleton<CLogfile>
{
public:
    //Memberfunktionen (Deklarationen bzw. Prototypen)

    CLogfile                ();
        ~CLogfile           ();
    void CreateLogfile      (const char *LogName);
    void WriteTopic         (const char *Topic, int Size);
    void Textout            (const wchar_t *Text);
    void Textout            (const char *Text);
    void Textout            (int Color, const wchar_t *Text);
    void Textout            (int Color, bool List, const wchar_t *Text);
    void fTextout           (const wchar_t *Text, ...);
    void fTextout           (const char *Text, ...);
    void fTextout           (int Color, const wchar_t *Text, ...);
    void fTextout           (int Color, bool List, const wchar_t *Text, ...);
    void FunctionResult     (const wchar_t *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
178
179

//includes

#include "logfile.hpp"

//Konstruktor

CLogfile::CLogfile() 
{
}

//Destruktor

CLogfile::~CLogfile()
{
    //Logfile-End schreiben und Datei schließen

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

//Create Logfile

//... erstellen der Logfile

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:snooc@gmx.at?subject=Logfile'>");
    Textout("E-Mail</a><br><br>");

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

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

//WriteTopic

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><font face='arial' ");
    fTextout("size='+%i'>\n", Size);
    Textout(Topic);
    Textout("</font>\n</td>\n<tr>\n</table>\n<br>");
    fflush(m_Logfile);
}

//'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

//Textout

void CLogfile::Textout (const wchar_t *Text)
{
    fwprintf(m_Logfile, Text);
    fflush(m_Logfile);
}

void CLogfile::Textout (const char *Text)
{
    fprintf(m_Logfile, Text);
    fflush(m_Logfile);
}

void CLogfile::Textout (int Color, const wchar_t *Text)
{
    Textout (Color, false, Text);
}

void CLogfile::Textout (int Color, bool List, const wchar_t *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>");
    
}

//'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

//fTextout

void CLogfile::fTextout (const wchar_t *Text, ...)
{
    wchar_t buffer[MAX_BUFFER]; //char-Buffer

    va_list pArgList;           //Liste der übergebenen Argumente


    //vsprintf(

    //String aus den Argumenten erstellen

    va_start (pArgList, Text);
    wvsprintf (buffer, Text, pArgList);
    va_end (pArgList);
    
    //Erzeugten String schreiben

    Textout (buffer);
}

void CLogfile::fTextout (int Color, const wchar_t *Text, ...)
{
    wchar_t buffer[MAX_BUFFER]; //char-Buffer

    va_list pArgList;           //Liste der übergebenen Argumete


    //String aus den Argumenten erstellen

    va_start (pArgList, Text);
    wvsprintf (buffer, Text, pArgList);
    va_end (pArgList);

    //Erzeugten String schreiben

    Textout (Color, buffer);
}


void CLogfile::fTextout (int Color, bool List, const wchar_t *Text, ...)
{
    wchar_t buffer[MAX_BUFFER]; //char-Buffer

    va_list pArgList;           //Liste der übergebenen Argumete


    //String aus den Argumenten erstellen

    va_start (pArgList, Text);
    wvsprintf (buffer, Text, pArgList);
    va_end (pArgList);

    //Erzeugten String schreiben

    Textout (Color, List, buffer);
}

//'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

//FunctionResult

void CLogfile::FunctionResult (const wchar_t *Name, bool Result)
{
    if (L_OK == Result)
    {
        Textout("<table width='100%%' cellSpacing='1' cellPadding='5'");
        Textout(" border='0' bgcolor='#C0C0C0'><tr><td bgcolor=");
        fTextout("'#FFFFFF' width='35%%'>%s</TD>", Name);
        Textout("<td bgcolor='#FFFFFF' width='30%%'><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=");
        fTextout("'#FFFFFF' width='35%%'>%s</TD>", Name);
        Textout("<td bgcolor='#FFFFFF' width='30%%'><font color =");
        Textout("'red'>ERROR</FONT></TD><td bgcolor='#FFFFFF' ");
        Textout("width='35%%'>-/-</TD></tr></table>");
    }

}


.... das ist für mich schon ne ganze menge source.. aber ich denke ich verstehe worum es geht.. es fehlt mir halt noch an routine!

...
ohne an etwas böses zu denken starte ich die main.cpp die den aufruf der logfile bewirkt und mir ein paar zeilen in ein html dokument schreiben soll!

was passiert dann wohl? .. na was glaubt ihr? :-D


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

// C++ für Spieleprogrammierer

// Listing 8.11

// Anwendung der Logfile-Klasse

//

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

using namespace std;

// Hauptprogramm

//

int main ()
{
    // Variablen

    //

    float Kontrolle = 123.456f; // Variable zum Testen


    // Neues Logfile erstellen

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

    // Überschrift erzeugen

    g_pLogfile->WriteTopic ("Unformatierter Text", 2);

    // Unformatierten Text ausgeben

    g_pLogfile->Textout ("Normaler, schwarzer Text<br>");
    g_pLogfile->Textout (RED, "Farbiger Text");
    g_pLogfile->Textout (BLUE, "Farbiger Text in Liste (1)");
    g_pLogfile->Textout (BLUE, "Farbiger Text in Liste (2)");
    g_pLogfile->Textout (BLUE, "Farbiger Text in Liste (3)");

    // Überschrift erzeugen

    g_pLogfile->WriteTopic ("Formatierter Text", 2);

    // Formatierten Text ausgeben

    g_pLogfile->fTextout ("Kontrollvariable: %f<br>", Kontrolle);
    g_pLogfile->fTextout (RED, "Kontrollvariable: %f", Kontrolle);
    g_pLogfile->fTextout (GREEN, true, "Liste Kontrolle: %f",
                          Kontrolle);
    g_pLogfile->fTextout (GREEN, true, "Liste Kontrolle: %f",
                          Kontrolle*2.0f);
    g_pLogfile->fTextout (GREEN, true, "Liste Kontrolle: %f",
                          Kontrolle*4.0f);

    // Eine erfolgreiche und eine fehlgeschlagene Funktion

    g_pLogfile->FunctionResult ("Funktion_Eins", L_OK);
    g_pLogfile->FunctionResult ("Funktion_Zwei", L_FAIL);

    // Logfile schließen

    g_pLogfile->Del ();

    return 0;
}


ohne viele worte:
ich muss die funktion fTextout 2 weitere male überladen ....

zB

C-/C++-Quelltext

 
1

void fTextout (int Color, const char *Text, ...);


damit ich in der main.cpp sowas machen kann:

C-/C++-Quelltext

 
1

g__pLogfile->Textout (BLUE, "Farbiger Text in Liste (1)");


wenn ich jedoch fTextout wie oben gezeigt überlade.. meckert wieder wvsprintf() herum .. weil die erwartet ja eine const wchar_t variable .. folgilch muss ich dann ja wieder vsprintf verwenden wo mir dann wieder gesagt wird dass die funktin veraltet ist.. :roll:

ich wetter für einige von euch ist das lachhaft dass ich da so einen radau mache ^^ aber.. naja.. ich bin eben anfänger und für solch einen ist das halt recht schwer!
jetzt nichts gegen das buch von heiko kalista (ich finde es wirklich klasse) aber kann man einem anfänger sowas zumuten?

ich hab noch eine frage an euch..

wenn ich jetzt fTextout 2 weiter male überlade.. würdet ihr mich dann als den könig des überladens definieren (im negativen sinne) oder würdet ihr sagen: ja .. keine schlechte idee!
was ich jetzt eigentlich hören will ist: ist es ratsam diese funktion so oft zu überladen? da kann ich doch gleich templates verwenden nicht oder?

:opa:
Am Anfang der Weisheit steht die eigene Erkenntnis, dass man selbst nichts weiß! - Sokrates

Caphalor

Frischling

Beiträge: 5

  • Private Nachricht senden

10

11.06.2006, 22:48

Hi erstmal, ich bin neu hier und ein totaler Anfänger. Ich versuche auch gerade, mit der Visual C++ Express Edition diese "nützliche Logfile-Klasse" zu compilieren und habe meine Probleme. Ich habe mich jetzt ziemlich genau an das gehalten, was nooc gepostet hat, aber nicht einmal das will compiliert werden.... (Habs sogar mit copy and paste versucht!)

Es sind eigentlich 2 Fehler, einmal in der Funktion WriteTopic und in der Funktion FunctionResult. Es liegt dort am Aufruf von fTextout, denn kommentiere ich diese Funktionsaufrufe aus, compiliert er. Aber ein bisschen Code sagt mehr als tausend Worte denke ich:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11

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><font face='arial' ");
    fTextout("size='+%i'>\n", Size); /*Hier bringt er den Fehler: 1>LogFile_Code.obj : error LNK2019: unresolved external symbol "public: void __cdecl CLogfile::fTextout(char const *,...)" (?fTextout@CLogfile@@QAAXPBDZZ) referenced in function "public: void __thiscall CLogfile::WriteTopic(char const *,int)" (?WriteTopic@CLogfile@@QAEXPBDH@Z)*/

    Textout(Topic);
    Textout("</font>\n</td>\n<tr>\n</table>\n<br>");
    fflush(m_Logfile);
}

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

void CLogfile::FunctionResult (const wchar_t *Name, bool Result)
{
    if (L_OK == Result)
    {
        Textout("<table width='100%%' cellSpacing='1' cellPadding='5'");
        Textout(" border='0' bgcolor='#C0C0C0'><tr><td bgcolor=");
        fTextout("'#FFFFFF' width='35%%'>%s</TD>", Name); /*Hier bringt er den Fehler: 1>LogFile_Code.obj : error LNK2019: unresolved external symbol "public: void __cdecl CLogfile::fTextout(char const *,...)" (?fTextout@CLogfile@@QAAXPBDZZ) referenced in function "public: void __thiscall CLogfile::FunctionResult(wchar_t const *,bool)" (?FunctionResult@CLogfile@@QAEXPB_W_N@Z)*/

        Textout("<td bgcolor='#FFFFFF' width='30%%'><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=");
        fTextout("'#FFFFFF' width='35%%'>%s</TD>", Name);
        Textout("<td bgcolor='#FFFFFF' width='30%%'><font color =");
        Textout("'red'>ERROR</FONT></TD><td bgcolor='#FFFFFF' ");
        Textout("width='35%%'>-/-</TD></tr></table>");
    }

}


Mein Code ist zu 100% der von Nooc, und meine main-funktion ist leer...



PPS@Nooc: Unterbrecht mich, wenn ich Unsinn erzähle, aber Templates bringen doch nichts bei verschieden vielen Parametern, sondern nur bei verschieden Parametern - und Rückgabetypen. Deshalb bräuchtest du schon einige Templates, und ich weiß nicht, ob sich das wirklich lohnen würde. ^^


EDIT: Problem hat sich glaube ich erledigt, ein wenig googlen hat die Lösung gebracht.
fTextout(L"'#FFFFFF' width='35%%'>%s</TD>", Name);
Das ist die Lösung, mit dem L teilt man den Compiler anscheinend mit, dass jetzt ein Unicode-String folgt.

Zusätzlich musste ich wvsprintf durch vswprintf ersetzen, da sonst die variablen nicht richtig ins Logfile geschrieben wurden. Ich poste einfach nochmal den (hoffentlich) richtigen Code:

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
178
179
180

//includes

#include "logfile.hpp"

//Konstruktor

CLogfile::CLogfile()
{
}

//Destruktor

CLogfile::~CLogfile()
{
    //Logfile-End schreiben und Datei schließen

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

//Create Logfile

//... erstellen der Logfile

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:snooc@gmx.at?subject=Logfile'>");
    Textout("E-Mail</a><br><br>");

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

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

//WriteTopic

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

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

//'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

//Textout

void CLogfile::Textout (const wchar_t *Text)
{
    fwprintf(m_Logfile, Text);
    fflush(m_Logfile);
}

void CLogfile::Textout (const char *Text)
{
    fprintf(m_Logfile, Text);
    fflush(m_Logfile);
}

void CLogfile::Textout (int Color, const wchar_t *Text)
{
    Textout (Color, false, Text);
}

void CLogfile::Textout (int Color, bool List, const wchar_t *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>");
   
}

//'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

//fTextout

void CLogfile::fTextout (const wchar_t *Text, ...)
{
    wchar_t buffer[MAX_BUFFER];    //char-Buffer

    va_list pArgList;            //Liste der übergebenen Argumente


    //vsprintf(

    //String aus den Argumenten erstellen

    va_start (pArgList, Text);
    vswprintf (buffer, Text, pArgList);
    va_end (pArgList);
   
    //Erzeugten String schreiben

    Textout (buffer);
}


void CLogfile::fTextout (int Color, const wchar_t *Text, ...)
{
    wchar_t buffer[MAX_BUFFER];    //char-Buffer

    va_list pArgList;            //Liste der übergebenen Argumete


    //String aus den Argumenten erstellen

    va_start (pArgList, Text);
    vswprintf (buffer, Text, pArgList);
    va_end (pArgList);

    //Erzeugten String schreiben

    Textout (Color, buffer);
}


void CLogfile::fTextout (int Color, bool List, const wchar_t *Text, ...)
{
    wchar_t buffer[MAX_BUFFER];    //char-Buffer

    va_list pArgList;            //Liste der übergebenen Argumete


    //String aus den Argumenten erstellen

    va_start (pArgList, Text);
    vswprintf (buffer, Text, pArgList);
    va_end (pArgList);

    //Erzeugten String schreiben

    Textout (Color, List, buffer);
}

//'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

//FunctionResult

void CLogfile::FunctionResult (const wchar_t *Name, bool Result)
{
    if (L_OK == Result)
    {
        Textout("<table width='100%%' cellSpacing='1' cellPadding='5'");
        Textout(" border='0' bgcolor='#C0C0C0'><tr><td bgcolor=");
        fTextout(L"'#FFFFFF' width='35%%'>%s</TD>", Name);
        Textout("<td bgcolor='#FFFFFF' width='30%%'><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=");
        fTextout(L"'#FFFFFF' width='35%%'>%s</TD>", Name);
        Textout("<td bgcolor='#FFFFFF' width='30%%'><font color =");
        Textout("'red'>ERROR</FONT></TD><td bgcolor='#FFFFFF' ");
        Textout("width='35%%'>-/-</TD></tr></table>");
    }

}


Jetzt kann man mit

C-/C++-Quelltext

 
1

g_pLogfile->fTextout (L"Kontrollvariable: %f<br>", Kontrolle);

beispielsweise etwas ins Logfile schreiben.

Werbeanzeige

Zur Zeit ist neben dir 1 Benutzer in diesem Thema unterwegs:

1 Besucher