fprintf - Zugriffsverletzung

  • C++/CLI

Es gibt 13 Antworten in diesem Thema. Der letzte Beitrag () ist von Elanda.

    fprintf - Zugriffsverletzung

    Hallo zusammen,

    ich bin gerade dabei eine Logfile Klasse zu schreiben, die mir Meldungen im html Format ausgibt.

    Die Datei wird erstellt, und die ersten Daten werden in die Datei geschrieben. Wenn ich dann weiteres in die Datei schreiben will bekomme ich folgende Meldung :

    Quellcode

    1. ​Ausnahme ausgelöst bei 0x774760C5 (ntdll.dll) in HTML Logfile 8.6.1.exe: 0xC0000005: Zugriffsverletzung beim Schreiben an Position 0x01010125.


    Wenn ich in Einzelschritten dem Programm Ablauf folge passiert der Fehler nach fopen_s(&m_LogFile, LogName, "a"); in der Funktion void CLogfile::Textout nach dem Erstellen der Überschrift, Email ect.

    Logfile Klasse
    Spoiler anzeigen
    ​CLogfile.cpp
    Spoiler anzeigen

    C-Quellcode

    1. #include "CLogfile.h"
    3. CLogfile::CLogfile() {
    4. m_LogFile = nullptr;
    5. }
    7. CLogfile::~CLogfile() {
    8. //Destruktor
    9. //Logfile Ende schreiben und Datei schließen
    10. Textout("<br><br>End of logfile</font></body></html>");
    11. fclose(m_LogFile);
    12. }
    14. void CLogfile::Textout(const char* Text) {
    15. fprintf(m_LogFile, Text);
    16. fflush(m_LogFile);
    17. }
    19. void CLogfile::CreateLogfile(const char* LogName) {
    20. //Logfile leeren und Kopf schreiben
    21. fopen_s(&m_LogFile, LogName, "w");
    22. Textout("<html><head><title>Logfile</title></head>");
    23. Textout("<bod><font face='courier new'>");
    24. WriteTopic("Logfile", 3);
    26. #ifdef _DEBUG
    27. Textout("BUILD: DEBUG <br>");
    28. #else
    29. Textout("BUILD: RELEASE<br>");
    30. #endif // _DEBUG
    32. Textout("<a href='mailto:hiermaileinfuegen@gmail.com?subject=Logfile'>");
    33. Textout("Send E-Mail to me</a><br><br>");
    34. //Logfile schließen und mit append wieder öffnen
    35. fclose(m_LogFile);
    36. fopen_s(&m_LogFile, LogName, "a");
    37. }
    39. void CLogfile::WriteTopic(const char* Topic, int size) {
    40. //Überschrift schreiben und flushen
    41. Textout("<table cellspacing='0' cellpadding='0' width = '100%%' ");
    42. Textout("bgcolor='#DFDFE5'>\n<tr>\n<td>\n<font face='arial' ");
    43. fTextout("size='+%i'>\n", size);
    44. Textout(Topic);
    45. Textout("</font>\n</td>\n</tr>\n</table>\n<br>");
    46. fflush(m_LogFile);
    47. }
    49. void CLogfile::Textout(int color, const char* Text) {
    50. Textout(color, false, Text);
    51. }
    53. void CLogfile::Textout(int color, bool List, const char* Text) {
    54. //Listentag schreiben
    55. if (List == true) {
    56. Textout("<li>");
    57. }
    58. //Farbtag schreiben
    59. switch (color)
    60. {
    61. case BLACK:
    62. Textout("<font color=black>"); break;
    63. case RED:
    64. Textout("<font color=red>"); break;
    65. case GREEN:
    66. Textout("<font color=green>"); break;
    67. case BLUE:
    68. Textout("<font color=blue>"); break;
    69. case PURPLE:
    70. Textout("font color=purple>"); break;
    71. };
    73. Textout(Text);
    74. Textout("</font>");
    76. if (List == false) {
    77. Textout("<br>");
    78. }
    79. else {
    80. Textout("</li>");
    81. }
    82. }
    84. void CLogfile::fTextout(const char *Text, ...) {
    85. CHAR buffer[MAX_BUFFER];
    86. va_list pArgList;
    87. va_start(pArgList, Text);
    88. vsprintf_s (buffer, Text, pArgList);
    89. va_end(pArgList);
    90. Textout(buffer);
    91. }
    93. void CLogfile::fTextout(int Color, const char *Text, ...) {
    94. CHAR buffer[MAX_BUFFER];
    95. va_list pArgList;
    96. va_start(pArgList, Text);
    97. vsprintf_s(buffer, Text, pArgList);
    98. va_end(pArgList);
    100. Textout(Color, buffer);
    101. }
    103. void CLogfile::fTextout(int color, bool List, const char* Text, ...) {
    104. CHAR buffer[MAX_BUFFER];
    105. va_list pArgList;
    106. va_start(pArgList, Text);
    107. vsprintf_s(buffer, Text, pArgList);
    108. va_end(pArgList);
    109. Textout(color, List, buffer);
    110. }
    112. void CLogfile::FunctionResult(const char* Name, bool Result) {
    113. if (L_OK == Result) {
    114. Textout("<table width='100%%' cellSpacing='1' cellPadding='5'");
    115. Textout(" border='0' bgcolor='#C0C0C0C0'><tr><td bgcolor=");
    116. fTextout("'#FFFFFF' width='35%%'>%s</TD>", Name);
    117. Textout("'green'>OK</FONT></TD><td bgcolor='#FFFFFF' ");
    118. Textout("width='35%%'>-/-</TD></tr></table>");
    119. }
    120. else {
    121. Textout("<table width='100%%' cellSpacing='1' cellPadding='5'");
    122. Textout(" border='0' bgcolor='#C0C0C0C0'><tr><td bgcolor=");
    123. fTextout("'#FFFFFF' width='35%%'>%s</TD>", Name);
    124. Textout("'red'>ERROR</FONT></TD><td bgcolor='#FFFFFF' ");
    125. Textout("width='35%%'>-/-</TD></tr></table>");
    126. }
    127. }

    CLogfile.h
    Spoiler anzeigen
    ​

    C-Quellcode

    1. ​#pragma once
    2. #ifndef __CLOGFILE
    3. #define __CLOGFILE
    5. #include <Windows.h>
    6. #include <stdio.h>
    7. #include "Singleton.h"
    9. constexpr auto MAX_BUFFER = 1024;
    10. constexpr auto L_FAIL = false;
    11. constexpr auto L_OK = true;
    12. #define g_pLogFile CLogfile::Get()
    14. enum FONTCOLORS {
    15. BLACK,
    16. RED,
    17. GREEN,
    18. BLUE,
    19. PURPLE
    20. };
    22. class CLogfile : public Singleton<CLogfile>
    23. {
    24. public:
    25. CLogfile();
    26. ~CLogfile();
    28. void CreateLogfile(const char *LogName);
    29. void WriteTopic(const char *topic, int size);
    30. void Textout(const char *Text);
    31. void Textout(int Color, const char *Text);
    32. void Textout(int color, bool List, const char *Text);
    33. void fTextout(const char *Text, ...);
    34. void fTextout(int color, const char *Text,...);
    35. void fTextout(int color, bool List, const char* Text, ...);
    36. void FunctionResult(const char* Name, bool Result);
    38. private:
    39. FILE* m_LogFile;
    40. };
    42. #endif // !__CLOGFILE



    Singleton Klasse
    Spoiler anzeigen
    ​

    C-Quellcode

    1. #pragma once
    3. #ifndef SINGLETON
    4. #define SINGLETON
    5. template <class T>
    6. class Singleton
    7. {
    8. protected:
    9. static T* m_pSignleton;
    11. public:
    12. virtual ~Singleton() {};
    14. inline static T* Get() {
    15. if (!m_pSignleton) {
    16. m_pSignleton = new T;
    17. return (m_pSignleton);
    18. }
    19. }
    21. static void Del() {
    22. if (m_pSignleton) {
    23. delete (m_pSignleton);
    24. m_pSignleton = nullptr;
    25. }
    26. }
    27. };
    29. // Die Statische Variabel erzeugen
    30. template<class T>
    31. T* Singleton<T>::m_pSignleton = nullptr;
    32. #endif
    34. ​


    C-Quellcode

    1. int main()
    2. {
    3. g_pLogFile->CreateLogfile("Logfilke.html"); // <- Erstellt die Datei, und die ersten Daten wie überschrift, Email, Debug ect.
    4. g_pLogFile->Textout("Hi"); //<- nope
    5. }


    Der letzte Abschnitt bei der Logfile Klasse die, die Datei erstellt endet mit :

    C-Quellcode

    1. ​fclose(m_LogFile);
    2. fopen_s(&m_LogFile, LogName, "a");


    Der Stream sollte geschlossen werden und im Append Modus wieder geöfnnet werden. Beim erneuten schreiben passiert es.

    Hoffe ihr könnt mir weiter helfen. lg
    Bilder

    • Screenshot_2.png

      16,52 kB, 491×235, 77 mal angesehen

    Farliam schrieb:

    Zugriffsverletzung beim Schreiben an Position 0x01010125
    Ist das reproduzierbar?
    Ist das Laufwerk voll?
    Kann es sein, dass es für die Datei eine Größenbeschränkung gibt?
    ====
    Warum C++?
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Nach erneutem starten von Visual Studio ist die Adresse anders : 0x774760C5
    Aber beim Debuggen immer die selbe Adresse.

    Das Laufwerk hat Platz ohne Ende.
    Größenbeschränkung? Die Datei wird geschlossen und im Append Modus wieder geöffnet. Alle Daten die danach folgen, sollten an das Ende der Datei angehängt werden.
    Warum? Weil es mir Spaß macht, mal etwas neues kennen zu lernen :)

    Welches Studio verwendest Du?
    Das würde ich gern mal nachvollziehen.
    Kannst Du das bereinigte Projekt anhängen?
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    @Farliam bereinigen heißt, dass (fast) alle Dateien, die das Studio selbst erstellen kann, gelöscht werden, um das ZIP schmal zu halten:

    Ich hoffe, dass es das bei CLI auch gibt.
    Ich hab das 17er Studio, mal sehen.
    =====
    Fehler im Code:

    C-Quellcode

    1. inline static T* Get()
    2. {
    3. if (!m_pSignleton)
    4. {
    5. m_pSignleton = new T;
    6. }
    7. return (m_pSignleton); // dies aus dem If-Block rausgeholt
    8. }
    =====
    Was muss ich tun, um den Fehler zu reproduzieren?
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „RodFromGermany“ ()

    RodFromGermany schrieb:

    return (m_pSignleton); // dies aus dem If-Block rausgeholt


    Schande über mich :D Ich war so fixiert auf die Logfile Klasse, dass ich der Basisklasse gar keine Beachtung geschenkt habe. Deswegen hat es auch beim ersten mal funktioniert, als der Singelton noch 0 war. Nach dem initialisieren bei der 2ten Abfrage kam bei GET nichts mehr zurück. Wie bist du darauf gekommen?

    Einfach durch´s optische nachschauen, oder über den Debugger und Einzelschritten?

    Nochmal vielen dank.

    Farliam schrieb:

    Wie bist du darauf gekommen?[/quote='Studio']

    Studio schrieb:

    Quellcode

    1. 1>c:\temp\_müll\htmllogfile\html logfile 8.6.1\singleton.h(21): warning C4715: "Singleton<CLogfile>::Get": Nicht alle Codepfade geben einen Wert zurück.
    War es das?
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Schmeiß mal den ganzen C-Müll da raus. Ich bin mir nicht sicher ob ein singleton als Design sinnvoll ist. Man erreicht nämlich mit einem globalen std::ofstream Objekt das gleiche. Ich hab dir trotzdem mal ein einfaches Beispiel gemacht:
    Spoiler anzeigen

    C-Quellcode

    1. class logfile
    2. {
    3. public:
    4. logfile(const logfile&) = delete;
    5. static logfile& get()
    6. {
    7. if (instance.get() == nullptr)
    8. instance = std::unique_ptr<logfile>(new logfile());
    9. return *instance.get();
    10. }
    11. void open(const std::string& filename) { textfile = std::ofstream(filename); }
    12. void close() { textfile.close(); }
    14. template <typename t>
    15. std::ostream& operator<<(const t& t_)
    16. {
    17. return textfile << t_;
    18. }
    19. private:
    20. static std::unique_ptr<logfile> instance;
    21. std::ofstream textfile;
    22. logfile() {}
    23. };
    24. std::unique_ptr<logfile> logfile::instance = std::unique_ptr<logfile>();
    26. int main()
    27. {
    28. logfile::get().open(R"(Pfad entfernt^^)");
    29. logfile::get() << "Hallo " << 45327 << "Welt!" << std::endl;
    30. }

    Wenn du dazu Fragen hast, einfach fragen.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Gonger96“ ()

    Gonger96 schrieb:

    Schmeiß mal den ganzen C-Müll da raus. Ich bin mir nicht sicher ob ein singleton als Design sinnvoll ist. Man erreicht nämlich mit einem globalen std::ofstream Objekt das gleiche. Ich hab dir trotzdem mal ein einfaches Beispiel gemacht:


    Muss gestehen ich bin erst seit 1 Woche dabei. Und lerne, wie wir schon aus meinem anderen Post gemerkt haben, scheinbar von einem inhaltlich Uralt Buch.

    Gonger96 schrieb:

    C-Quellcode

    1. template <typename t>
    2. std::ostream& operator<<(const t& t_)
    3. {
    4. return textfile << t_;
    5. }


    Werden dort die << überladen und als Template deklariert?

    Wie kann ich außerdem alten C von neuen C++ Code unterscheiden?

    Ich hab 3 Bücher zur Auswahl, die ich eigentlich nacheinander durchgehen wollte :

    Spoiler anzeigen


    Spoiler anzeigen


    Spoiler anzeigen


    @Gonger96 Welches würdest du mir empfehlen, mit dem ich weitermachen sollte?

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Farliam“ ()

    Jo der << Operator wird überladen und dient als Wrapper für den ofstream operator <<. Es ist ein Template damit alle Typen unterstützt werden, die ofstream unterstützt.

    Alles was in irgendwelchen Windows Headern ist, ist kein Standard C++ bzw. gehört nicht zur Standardbibliothek. Ansonsten enden C-Std Header immer auf .h während C++ Standard Header keine Endung haben. Hier ist übrigens eine gute Doku.

    1.Kein muss, aber ein Tipp.
    Im Falle eines Singleton geht es noch viel einfacher und du ersparst dir auch den heap-speicher.

    Sieht dann ungefähr so aus:

    C-Quellcode

    1. static Logfile& get()
    2. {
    3. static Logfile log;
    4. return log;
    5. }


    Sieht nebenbei auch viel schöner aus und liest sich auch besser.

    2. Bei dem << operator overload empfehle ich dir das hier zu machen.

    C-Quellcode

    1. template<class T>
    2. std::ostream& operator<<(T value)
    3. {
    4. return textfile << value;
    5. }


    Die const reference kannst du dir sparen, da der größte Typ der von std::ostream akzeptiert wird sowieso nur 64 bit groß ist. (Zumindest auf Windows, und es ist sowieso warscheinlichicher Datentypen zu übergeben die kleiner sind.)
    Während mit einer Referenz (wenn die Funktion nicht sowieso inlined wird) immer 64 bit übergeben werden.
    ----------------------------------------------------------------------------------------------------------------------

    Hier könnte meine Signatur stehen, aber die ist mir abfußen gekommen.

    ----------------------------------------------------------------------------------------------------------------------

Facebook
Telefonspende