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!

Kapitel8 mit Dev c++ Fehler mit fopen_s

Werbeanzeige

herzogRed

Frischling

  • »herzogRed« ist der Autor dieses Themas

Beiträge: 15

Wohnort: Leipzig

  • Private Nachricht senden

11

03.06.2015, 22:50

Ich weiss noch nicht so richtig, was ich im code einsetzen soll. Hier mal das komplette listing, damit es übersichtlicher ist.

Das ist das Listing um das Logfile zu testen:

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

// C++ für Spieleprogrammierer
// Listing 8.15
// Anwendung der Logfile-Klasse
//
#include <iostream>
#include <stdio.h>
#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;
}


soll ich damit hier das file erstellen? oder einen direkten pfad angeben?

C-/C++-Quelltext

 
1
2

// Neues Logfile erstellen
    g_pLogfile->CreateLogfile ("Logfile.html");


hier ist das logfile mit der fopen Anweisung:
es kommt zwar kein fehler, aber das prog läuft durch und zeigt kein Ergebnis an. wahrscheinlich weil es nicht in der Datei gespeichert wird.

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
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225

#include "Logfile.hpp"

// Konstruktor
//
// Aufgabe: Bisher noch keine
//
CLogfile::CLogfile ()
{

} // Konstruktor

// Destruktor
//
// Aufgabe: Gibt Ende-Meldung aus und schließt das Logfile
//
CLogfile::~CLogfile ()
{
    // Logfile-Ende schreiben und Datei schließen
    Textout ("<br><br>End of logfile</font></body></html>");
    fclose (m_Logfile);

} // Destruktor

// CreateLogfile
//
// Aufgabe: Logfile erstellen und Kopf schreiben
//
void CLogfile::CreateLogfile (const char *LogName)
{
    // Logfile leeren und Kopf schreiben
    //fopen (&m_Logfile,  LogName, "w");
    
errno_t fopen_s(FILE** pFile, const char *m_Logfile, const char *mode);

FILE * fopen(const char * m_Logfile, const char * mode);
 


    
    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:support@meineURL.de?subject=Logfile'>");
    Textout ("Send E-Mail to me</a><br><br>");

    // Logfile schließen und mit append wieder öffnen
    fclose (m_Logfile);
    //fopen (&m_Logfile, LogName, "a");
    
    
errno_t fopen_s(FILE** pFile, const char *m_Logfile, const char *mode);

FILE * fopen(const char * m_Logfile, const char * mode);
 



} // CreateLogfile

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

} // WriteTopic

// 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 (schwarz)

// Textout
//
// Aufgabe: Text ins Logfile schreiben (farbig)
//
void CLogfile::Textout (int Color, const char *Text)
{
    Textout (Color, false, Text);

} // Textout (farbig)

// 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>");

} // Textout (farbig, liste)

// fTextout
//
// Aufgabe: formatierten Text ins Logfile schreiben (schwarz)
//
void CLogfile::fTextout (const char *Text, ...)
{
    char buffer[MAX_BUFFER];  // char-Buffer
    va_list pArgList;          // Liste der übergebenen Argumente

    // String aus den Argumenten erstellen
    va_start (pArgList, Text);
    sprintf (buffer, Text, pArgList);
    va_end (pArgList);

    // Erzeugten String schreiben
    Textout (buffer);

} // fTextout (schwarz)

// fTextout
//
// Aufgabe: formatierten Text ins Logfile schreiben (farbig)
//
void CLogfile::fTextout (int Color, const char *Text, ...)
{
    char buffer[MAX_BUFFER];  // char-Buffer
    va_list pArgList;          // Liste der übergebenen Argumente

    // String aus den Argumenten erstellen
    va_start (pArgList, Text);
    sprintf (buffer, Text, pArgList);
    va_end (pArgList);

    // Erzeugten String schreiben
    Textout (Color, buffer);

} // fTextout (farbig)

// fTextout
//
// Aufgabe: formatierten Text ins Logfile schreiben (farbig, Liste)
//
void CLogfile::fTextout (int Color, bool List,const char *Text, ...)
{
    char buffer[MAX_BUFFER];  // char-Buffer
    va_list pArgList;          // Liste der übergebenen Argumente

    // String aus den Argumenten erstellen
    va_start (pArgList, Text);
    sprintf (buffer, Text, pArgList);
    va_end (pArgList);

    // Erzeugten String schreiben
    Textout (Color, List, buffer);

} // fTextout (farbig, Liste)

// 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=");
        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>");
    }

} // FunctionResult


hier die hpp Datei:

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 1024             // Maximale Größe für den Buffer
#define L_FAIL false                // Funktion war 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>
{
    // 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 fTextout       (const char *Text, ...);
        void fTextout       (int Color, const char *Text, ...);
        void fTextout       (int Color, bool List, const char *Text, ...);
        void FunctionResult (const char *Name, bool Result);

    // Membervariablen
    private:

        FILE *m_Logfile;

};

#endif



und noch die singleton, damit es komplett ist und man sie ein bild machen kann. ich steig da noch nicht richtig dahinter.

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 1024             // Maximale Größe für den Buffer
#define L_FAIL false                // Funktion war 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>
{
    // 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 fTextout       (const char *Text, ...);
        void fTextout       (int Color, const char *Text, ...);
        void fTextout       (int Color, bool List, const char *Text, ...);
        void FunctionResult (const char *Name, bool Result);

    // Membervariablen
    private:

        FILE *m_Logfile;

};

#endif

herzogRed

Frischling

  • »herzogRed« ist der Autor dieses Themas

Beiträge: 15

Wohnort: Leipzig

  • Private Nachricht senden

12

05.06.2015, 16:48

Ist mir leider noch etwas zu hoch, wie ich das file richtig einsetzen muss. Ich werd es wohl zurückstellen müssen, bis ich weiter bin.
Vielleicht kann mir ja noch jemand von den erfahrenen hElfen, das Logfile in Dev c++ zum laufen zu bringen.

Koschi

Alter Hase

Beiträge: 657

  • Private Nachricht senden

13

05.06.2015, 17:13

Vielleicht hilft es dir wenn ich mal ein paar Fragen in den Raum werfe.

1. was sind die 2 Parameter die fopen haben möchte und wofür stehen sie?
2. was ist der Rückgabe Type von fopen?
3. in welchen member der Klasse müsstest du den Zurück gegebenen Wert Speicher um jederzeit wieder drauf zu zugreifen?

Wenn du die Fragen beantworten kannst solltest eigentlich auf die Lösung kommen.
Wer aufhört besser werden zu wollen hört auf gut zu sein!

aktuelles Projekt:Rickety Racquet

herzogRed

Frischling

  • »herzogRed« ist der Autor dieses Themas

Beiträge: 15

Wohnort: Leipzig

  • Private Nachricht senden

14

05.06.2015, 17:56

Ok, danke für den Ansatz, werd mich nochmal dran setzen und es auseinander nehmen. Das Problem ist, wir sollten den Text nur abtippen und noch nicht verstehen. Aber kann ja nicht schaden.

Koschi

Alter Hase

Beiträge: 657

  • Private Nachricht senden

15

05.06.2015, 18:19

Zitat von »herzogRed«

Ok, danke für den Ansatz, werd mich nochmal dran setzen und es auseinander nehmen. Das Problem ist, wir sollten den Text nur abtippen und noch nicht verstehen. Aber kann ja nicht schaden.


Ist im Grunde immer das selbe, bei Funktionen die man nicht kennt, docu lesen und die meisten Hürden kann man selber nehmen.
Wurde schon mal gelinkt, aber zur Erinnerung hier noch mal fopen docu.
Wer aufhört besser werden zu wollen hört auf gut zu sein!

aktuelles Projekt:Rickety Racquet

panicjonny

Frischling

Beiträge: 23

  • Private Nachricht senden

16

11.06.2015, 15:25

Moin,

fopen in einer Klasse? Ich muss an der Stelle anmerken, dass man das lieber sein lässt.

Wenn man C++ programmiert sollte man lieber IO-Streams verwenden. Die sind vor allem Typsicher und man kann deutlich mehr damit machen.


Grüße,


EDIT: Deutsche Sprache, schwere Sprache

BlueCobold

Community-Fossil

Beiträge: 10 738

Beruf: Teamleiter Mobile Applikationen & Senior Software Engineer

  • Private Nachricht senden

17

11.06.2015, 16:25

Der Code des Buchs basiert aber nunmal darauf, da bringt es wenig schlaue Ratschläge zu geben.
Teamleiter von Rickety Racquet (ehemals das "Foren-Projekt") und von Marble Theory

Willkommen auf SPPRO, auch dir wird man zu Unity oder zur Unreal-Engine raten, ganz bestimmt.[/Sarkasmus]

panicjonny

Frischling

Beiträge: 23

  • Private Nachricht senden

18

11.06.2015, 16:40

Zitat von »BlueCobold«

Der Code des Buchs basiert aber nunmal darauf, da bringt es wenig schlaue Ratschläge zu geben.
Ja, Konsequenz heißt auch Holzwege zu Ende zu gehen: :vain: :vain: SCNR

Roflo

Alter Hase

Beiträge: 955

  • Private Nachricht senden

19

11.06.2015, 17:48

Warum soll fopen mit einer Klasse schlecht sein?

panicjonny

Frischling

Beiträge: 23

  • Private Nachricht senden

20

11.06.2015, 19:34

Zitat von »Roflo«

Warum soll fopen mit einer Klasse schlecht sein?
Es geht gar nich um fopen in einer Klasse, sonden um fopen in C++.

Begründet habe ich das ja oben schon. Typsicherheit ist eine der wesentlichen Verbesserungen von C++ gegenüber C. Diesen Vorteil gibt man wieder ab, wenn man C Funktionen benutzt.

als Beispiel:

C-/C++-Quelltext

 
1
2
3
4
5
6

    unsigned int playerLive = 100; // der Spieler kann ja gar nicht weniger als 0 Leben haben.

    //  ... jede Menge Code


    printf ("Leben vom Sieler %d", playerLive);


Zack, hat printf deinen uint als signed interpretiert. Das Beispiel ist natürlich bewusst einfach gehalten, sorgt aber mit ein wenig Pech für viel Spaß bei der Fehlersuche.

C-/C++-Quelltext

 
1
2
3
4
5

    unsigned int playerLive = 100; // der Spieler kann ja gar nicht weniger als 0 Leben haben.

    //  ... jede Menge Code
  
    std::cout << playerLive;


playerLive wird korrekt als uint ausgegeben, da kann man gar nichts falsch machen.

Bemerkung: Der Einfachheit halber hab ich printf statt fprintf und std::cout statt einen filestream genommen. Der Effekt bleibt der gleiche.


Der zweite Vorteil sind die '<<','>>' Operatoren. Wenn die für deine Klasse vernünftig überladen sind, kannst du einfach die Klasse in den Stream stopfen und es geht. Dabei ist es dann auch egal was für ein Stream (iostream, sstream, fstream).

Grüße,

Werbeanzeige

Ähnliche Themen