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!

Speicherverletzung bei Zerstörung einer Instanz mit "delete"

Werbeanzeige

DonL1978

Frischling

  • »DonL1978« ist der Autor dieses Themas

Beiträge: 4

Wohnort: Köln

Beruf: Rechtsanwalt

  • Private Nachricht senden

1

03.11.2013, 16:36

Speicherverletzung bei Zerstörung einer Instanz mit "delete"

Hallo zusammen!

Nun muß ich hier auch mal einen Rat suchen... Ich bin grade dabei, ein Framework zu schreiben. Die Hauptklasse "EVE" ist ein Singleton (ja, ich weiß ;) für meine Zwecke aber nützlich) und hält Objekte verschiedener Komponenten für Grafik, Physik usw.
Ein Objekt macht mir allerdings große Schwierigkeiten... das Objekt der Klasse "CSettings". Hier mal die Deklaration...

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

#ifndef _CSETTINGS_H_
#define _CSETTINGS_H_

//Standard
#include <string>
#include <fstream>

//Allgemein
#include "defines.hpp"
#include "enums.hpp"

//namespace engine ----------------------------------------------------------------------------------------------------
namespace engine
{
//---------------------------------------------------------------------------------------------------------------------
//CSettings
//---------------------------------------------------------------------------------------------------------------------
class CSettings
{
    public:
        //-------------------------------------------------------------------------------------------------------------
        //Konstruktor
        //-------------------------------------------------------------------------------------------------------------
        CSettings();

        //-------------------------------------------------------------------------------------------------------------
        //Destruktor
        //-------------------------------------------------------------------------------------------------------------
        ~CSettings();
    
        //-------------------------------------------------------------------------------------------------------------
        //Methoden
        //-------------------------------------------------------------------------------------------------------------
        
        //Settings aus Datei laden
        EExitCode   loadFromFile(const std::string& stFileName);

        //Settings in Datei schreiben
        EExitCode   writeToFile(const std::string& stFileName);
        
        //-------------------------------------------------------------------------------------------------------------
        //Interface
        //------------------------------------------------------------------------------------------------------------- 
        inline int            getScreenWidth(){return m_screenWidth;}
        inline void         setScreenWidth(const int screenWidth){m_screenWidth = screenWidth;}
        inline int            getScreenHeight(){return m_screenHeight;}
        inline void         setScreenHeight(const int screenHeight){m_screenHeight = screenHeight;}
        inline int            getScreenDepth(){return m_screenDepth;}
        inline void         setScreenDepth(const int screenDepth){m_screenDepth = screenDepth;}
        inline std::string   getTitle(){return m_stTitle;}
        inline void         setTitle(const std::string stTitle){m_stTitle = stTitle;}   
        inline bool         getVSync(){return m_bVSync;}
        inline void         setVSync(const bool bVSync){m_bVSync = bVSync;}
        inline bool         getParticleEffects(){return m_bParticleEffects;}
        inline void         setParticleEffects(const bool bParticleEffects){m_bParticleEffects = bParticleEffects;}
        inline ESetting     getParticleEffectsQuality(){return m_particleEffectsQuality;}
        inline void         setParticleEffectsQuality(const ESetting particleEffectsQuality){m_particleEffectsQuality = particleEffectsQuality;}
        inline bool         getSound(){return m_bSound;}
        inline void         setSound(const bool bSound){m_bSound = bSound;}
        inline ESetting   getSoundQuality(){return m_soundQuality;}
        inline void         setSoundQuality(const ESetting soundQuality){m_soundQuality = soundQuality;}
        inline int            getSoundVolume(){return m_soundVolume;}
        inline void         setSoundVolume(const int soundVolume){m_soundVolume = soundVolume;}
        inline bool         getMusic(){return m_bMusic;}
        inline void         setMusic(const bool bMusic){m_bMusic = bMusic;}
        inline ESetting   getMusicQuality(){return m_musicQuality;}
        inline void         setMusicQuality(const ESetting musicQuality){m_musicQuality = musicQuality;}
        inline int          getMusicVolume(){return m_musicVolume;}
        inline void         setMusicVolume(const int musicVolume){m_musicVolume = musicVolume;}
    
    private:
        //-------------------------------------------------------------------------------------------------------------
        //Elemente
        //-------------------------------------------------------------------------------------------------------------
        int             m_screenWidth;              //Fensterbreite
        int             m_screenHeight;             //Fensterhöhe
        int             m_screenDepth;              //Farbtiefe
        std::string     m_stTitle;                       //Fenstertitel
        bool              m_bFullscreen;                  //Vollbild
        bool            m_bVSync;                      //VSync
        bool              m_bParticleEffects;           //Partikeleffekte
        ESetting        m_particleEffectsQuality;   //Qualität der Partikeleffekte
        bool            m_bSound;                      //Sound
        ESetting        m_soundQuality;             //Qualität des Sounds
        int             m_soundVolume;              //Lautstärke des Sounds
        bool              m_bMusic;                     //Musik
        ESetting        m_musicQuality;             //Qualität der Musik
        int             m_musicVolume;              //Lautstärke der Musik
};//CSettings ---------------------------------------------------------------------------------------------------------
}//namespace engine ---------------------------------------------------------------------------------------------------
#endif


Und die Definition...

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

#include "CSettings.hpp"

//namespace engine ----------------------------------------------------------------------------------------------------
namespace engine
{
//---------------------------------------------------------------------------------------------------------------------
//Konstruktor
//---------------------------------------------------------------------------------------------------------------------
CSettings::CSettings()
{
    m_screenWidth               = 0;
    m_screenHeight              = 0;
    m_screenDepth               = 0;
    m_stTitle                   = "";
    m_bFullscreen               = false;
    m_bVSync                    = false;
    m_bParticleEffects          = false;
    m_particleEffectsQuality    = SETTING_NONE;
    m_bSound                    = false;
    m_soundQuality              = SETTING_NONE;
    m_soundVolume               = 0;
    m_bMusic                    = false;
    m_musicQuality              = SETTING_NONE;
    m_musicVolume               = 0;
}//Konstruktor --------------------------------------------------------------------------------------------------------

//---------------------------------------------------------------------------------------------------------------------
//Destruktor
//---------------------------------------------------------------------------------------------------------------------
CSettings::~CSettings()
{
}//Destruktor ---------------------------------------------------------------------------------------------------------

//---------------------------------------------------------------------------------------------------------------------
//Funktion  :   loadFromFile
//Aufgabe   :   Settings aus Datei laden
//Rückgabe :   ExitCode
//---------------------------------------------------------------------------------------------------------------------
EExitCode CSettings::loadFromFile(const std::string& stFileName)
{
    std::ifstream input(stFileName, std::ios::binary);

    if(input == NULL)
    {
        return(RESULT_ERROR);
    }
    else
    {
        input.read((char*) this, sizeof(CSettings));
        
        input.close();

        return(RESULT_OK);
    }
    return(RESULT_OK);
}//loadFromFile -------------------------------------------------------------------------------------------------------

//---------------------------------------------------------------------------------------------------------------------
//Funktion  :   writeToFile
//Aufgabe   :   Settings in Datei schreiben
//Rückgabe :   ExitCode
//---------------------------------------------------------------------------------------------------------------------
EExitCode CSettings::writeToFile(const std::string& stFileName)
{
    std::ofstream output(stFileName, std::ios::binary);

    if(output == NULL)
    {
        return(RESULT_ERROR);
    }
    else
    {
        output.write((char*) this, sizeof(CSettings));
        output.close();
        return(RESULT_OK);
    }
    return(RESULT_OK);
}//writeToFile --------------------------------------------------------------------------------------------------------
}//namespace engine ---------------------------------------------------------------------------------------------------


Die Hauptklasse hält als Member einen Zeiger

C-/C++-Quelltext

 
1

CSettings* m_pSettings


nullt diesen im Konstruktor

C-/C++-Quelltext

 
1

m_pSettings = NULL


und erstellt in ihrer Initialisierungsfunktion zunächst eine Instanz auf dem Heap und lädt die Werte aus einer Datei:

C-/C++-Quelltext

 
1
2
3
4
5
6
7

EExitCode CEve::init()
{
    if(m_bInitialized != true)
    {
        //Settings erstellen und laden
        m_pSettings = new CSettings();
        m_pSettings->loadFromFile("settings.dat");


Soweit so kein Problem...

Versuche ich jedoch beim Aufräumen, "delete" auf m_pSettings aufzurufen, gibt es eine Speicherverletzung.
Mache ich das Ganze, ohne bei der Initialisierung der Hauptklasse

C-/C++-Quelltext

 
1

m_pSettings->loadFromFile("settings.dat");


aufzurufen, gibt es dieses Problem nicht ?(

Vermutlich ist es ein dummer Anfängerfehler... aber ich kann ihn einfach nicht finden. Habt Ihr vielleicht eine Idee, auf welchem Holzweg ich unterwegs bin?

Vielen Dank!

BlueCobold

Community-Fossil

Beiträge: 10 738

Beruf: Teamleiter Mobile Applikationen & Senior Software Engineer

  • Private Nachricht senden

2

03.11.2013, 17:04

Kleiner Nebenhinweis: Das ganze "inline" kannst Du Dir schenken. Das macht der Compiler oder lässt es bleiben, unabhängig von Deiner Angabe.

Dein Problem ist übrigens das hier:

input.read((char*) this, sizeof(CSettings));

PS:
Seit wann können Streams == NULL sein?
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]

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »BlueCobold« (03.11.2013, 17:11)

patrick246

Treue Seele

Beiträge: 328

Wohnort: nahe Heilbronn/BW

Beruf: TG Profil Informatik-Schüler

  • Private Nachricht senden

3

03.11.2013, 17:13

Noch ein paar kleine Nebenhinweise:
Die gesamten Zuweisungen im Konstruktor sollten eigentlich in der Konstruktorliste stehen, das ist sauberer.

Dann sehe ich trotzdem keinen Grund, warum du hier den Speicher manuell verwalten willst. Mach den Zeiger weg und dafür eine ganz normale Membervariable hin. In deiner init-Methode kannst du dann immer noch m_settings->loadFromFile(...); aufrufen.

Oder du machst es gleich ganz sauber und lässt init-Methoden ganz weg und legst den Code in den Konstruktor. Der ist eigentlich dafür gedacht, das Objekt zu initialisieren.

wluc-16

Treue Seele

Beiträge: 212

Wohnort: in der Nähe von Bielefeld :D

Beruf: Schüler

  • Private Nachricht senden

4

03.11.2013, 17:24

Erstmal zwei dumme Fragen:
Gibt es die Datei "settings.dat" und ist sie im richtigen Ordner?
Wenn ja, hast du sie auf Fehler geprüft bzw. hast du den EExitCode-Rückgabewert gecheckt?

DonL1978

Frischling

  • »DonL1978« ist der Autor dieses Themas

Beiträge: 4

Wohnort: Köln

Beruf: Rechtsanwalt

  • Private Nachricht senden

5

03.11.2013, 17:36

Hey, das geht ja schnell...

@BlueCobold

Zitat

Kleiner Nebenhinweis: Das ganze "inline" kannst Du Dir schenken. Das
macht der Compiler oder lässt es bleiben, unabhängig von Deiner Angabe.
Echt? Ist es nicht eher so, daß der Compiler nur bei der Angabe "inline" entscheidet, ob das ne gute Idee ist oder nicht, aber ohne Angabe "inline" gar nicht auf die Idee kommt, Inline zu verwenden?

Zitat


Dein Problem ist übrigens das hier:



input.read((char*) this, sizeof(CSettings));
Das ist mir schon klar, wie man an meinem ersten Post sieht... wird die Zeile nicht aufgerufen, gibt es auch kein Problem. Irgendwelche Voschläge?

@Patrick246
Guter Einwand! Hielt es bislang für sauberer, erst im Konstruktor alles "zu nullen" und damit auf gültige Werte zu setzen und erst in einer "init" die Startwerte zu setzen. Wohl doch ein Irrweg...

@wluc16
Ja, die Datei existiert und liefert auch die richtigen Werte... sagt zumindest mein Freund, der Debugger ;)

Besten Dank für Eure Hilfe!

BlueCobold

Community-Fossil

Beiträge: 10 738

Beruf: Teamleiter Mobile Applikationen & Senior Software Engineer

  • Private Nachricht senden

6

03.11.2013, 17:56

Zitat von »DonL1978«

Echt?
Echt.

Zitat von »DonL1978«

Ist es nicht eher so, daß der Compiler nur bei der Angabe "inline" entscheidet, ob das ne gute Idee ist oder nicht, aber ohne Angabe "inline" gar nicht auf die Idee kommt, Inline zu verwenden?
Nein. Das war mal. Vor langer Zeit. Irgendwann.

Zitat von »DonL1978«

Das ist mir schon klar, wie man an meinem ersten Post sieht... wird die Zeile nicht aufgerufen, gibt es auch kein Problem. Irgendwelche Voschläge?
Klar, lies alle Member einzeln und schreib sie einzeln. Alignment/Packing macht sonst noch ganze andere wilde Dinge, die bei einem anderen Compiler plötzlich dazu führen, dass Deine Files nicht mehr gelesen werden können.
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]

DonL1978

Frischling

  • »DonL1978« ist der Autor dieses Themas

Beiträge: 4

Wohnort: Köln

Beruf: Rechtsanwalt

  • Private Nachricht senden

7

04.11.2013, 20:12

Hallo zusammen und erstmal vielen Dank für Eure Hinweise!

Inzwischen habe ich den Fehler ausgemacht.

Die Instanz in einem Stück in die Datei schreiben oder aus ihr lesen zu wollen, mag an sich keine gute Idee sein, war aber nicht das Problem. Ich Honk war blöd genug, zu versuchen, einfach ein std::string als Member der Klasse in ein Binary schreiben und wieder aus ihr lesen zu wollen :whistling: Daß das zu lustigen Fehlern führen würde, hätte mir auffallen können, habe es aber schlicht übersehen...

Zitat

Alignment/Packing macht sonst noch ganze andere wilde Dinge
Zum Beispiel? Also verabschiede ich mich besser mal davon, Instanzen "am Stück" in Dateien zu schreiben und zu lesen!? Mhm...

Zitat

Nein. Das war mal. Vor langer Zeit. Irgendwann.
Ich werde eben langsam alt ;) Danke für den Hinweis!

Schönen Abend!

DonL1978

Frischling

  • »DonL1978« ist der Autor dieses Themas

Beiträge: 4

Wohnort: Köln

Beruf: Rechtsanwalt

  • Private Nachricht senden

8

08.11.2013, 22:18

Gelöst

Hallo zusammen!

Nur der Vollständigkeit halber für diejenigen, mit ähnlichen Problemen... Wie gesagt, ein std::string einfach so in eine Datei schreiben zu wollen, ist eine noch schlechtere Idee, als die Instanz einer Klasse an einem Stück ;)

Zunächst die Deklaration der Settings-Klasse:

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

//---------------------------------------------------------------------------------------------------------------------
//CSettings
//---------------------------------------------------------------------------------------------------------------------
class CSettings
{
    public:
        //-----------------------------------------------------------------------------------------------------
        //Konstruktoren
        //-----------------------------------------------------------------------------------------------------
        CSettings();
        
        CSettings(const int             screenWidth,
                  const int                 screenHeight,
                  const int                 screenDepth,
                  const std::string&    stTitle,
                  const bool            bFullscreen,
                  const bool            bVSync,
                  const bool            bParticleEffects,
                  const ESetting        particleEffectsQuality,
                  const bool            bSound,
                  const ESetting        soundQuality,
                  const int             soundVolume,
                  const bool            bMusic,
                  const ESetting        musicQuality,
                  const int             musicVolume);

        //-----------------------------------------------------------------------------------------------------
        //Destruktor
        //-----------------------------------------------------------------------------------------------------
        ~CSettings();
    
        //-----------------------------------------------------------------------------------------------------
        //Methoden
        //-----------------------------------------------------------------------------------------------------
        
        //Settings aus Datei laden
        EExitCode   loadFromFile(const std::string& stFileName);

        //Settings in Datei schreiben
        EExitCode   writeToFile(const std::string& stFileName);
        
        //-----------------------------------------------------------------------------------------------------
        //Interface
        //-----------------------------------------------------------------------------------------------------
    
    private:
        //-----------------------------------------------------------------------------------------------------
        //Elemente
        //-----------------------------------------------------------------------------------------------------
        int             m_screenWidth;              //Fensterbreite
        int             m_screenHeight;             //Fensterhöhe
        int             m_screenDepth;              //Farbtiefe
        std:: string    m_stTitle;                  //Fenstertitel
        bool            m_bFullscreen;              //Vollbild
        bool            m_bVSync;                   //VSync
        bool            m_bParticleEffects;         //Partikeleffekte
        ESetting        m_particleEffectsQuality;   //Qualität der Partikeleffekte
        bool            m_bSound;                   //Sound
        ESetting        m_soundQuality;             //Qualität des Sounds
        int             m_soundVolume;              //Lautstärke des Sounds
        bool            m_bMusic;                   //Musik
        ESetting        m_musicQuality;             //Qualität der Musik
        int             m_musicVolume;              //Lautstärke der Musik
};//CSettings ---------------------------------------------------------------------------------------------------------


Und die Definition:

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

//---------------------------------------------------------------------------------------------------------------------
//Konstruktor
//---------------------------------------------------------------------------------------------------------------------
CSettings::CSettings()
    : m_screenWidth(0)
    , m_screenHeight(0)
    , m_screenDepth(0)
    , m_stTitle("")
    , m_bFullscreen(false)
    , m_bVSync(false)
    , m_bParticleEffects(false)
    , m_particleEffectsQuality(SETTING_NONE)
    , m_bSound(false)
    , m_soundQuality(SETTING_NONE)
    , m_soundVolume(0)
    , m_bMusic(false)
    , m_musicQuality(SETTING_NONE)
    , m_musicVolume(0)
{
}//Konstruktor --------------------------------------------------------------------------------------------------------

//---------------------------------------------------------------------------------------------------------------------
//Konstruktor
//---------------------------------------------------------------------------------------------------------------------
CSettings::CSettings(const int          screenWidth,
                     const int          screenHeight,
                     const int          screenDepth,
                     const std::string& stTitle,
                     const bool         bFullscreen,
                     const bool         bVSync,
                     const bool         bParticleEffects,
                     const ESetting     particleEffectsQuality,
                     const bool         bSound,
                     const ESetting     soundQuality,
                     const int          soundVolume,
                     const bool         bMusic,
                     const ESetting     musicQuality,
                     const int          musicVolume)
    : m_screenWidth(screenWidth)
    , m_screenHeight(screenHeight)
    , m_screenDepth(32)
    , m_stTitle(stTitle)
    , m_bFullscreen(bFullscreen)
    , m_bVSync(bVSync)
    , m_bParticleEffects(bParticleEffects)
    , m_particleEffectsQuality(particleEffectsQuality)
    , m_bSound(bSound)
    , m_soundQuality(soundQuality)
    , m_soundVolume(soundVolume)
    , m_bMusic(bMusic)
    , m_musicQuality(musicQuality)
    , m_musicVolume(musicVolume)
{
}//Konstruktor --------------------------------------------------------------------------------------------------------

//---------------------------------------------------------------------------------------------------------------------
//Destruktor
//---------------------------------------------------------------------------------------------------------------------
CSettings::~CSettings()
{
}//Destruktor ---------------------------------------------------------------------------------------------------------

//---------------------------------------------------------------------------------------------------------------------
//Funktion  :   loadFromFile
//Aufgabe   :   Settings aus Datei laden
//Rückgabe :   ExitCode
//---------------------------------------------------------------------------------------------------------------------
EExitCode CSettings::loadFromFile(const std::string& stFileName)
{
    std::ifstream input(stFileName, std::ios::binary);

    if(!input.good())
    {
        input.clear();

        return(RESULT_ERROR);
    }
    else
    {
        input.read((char*) &m_screenWidth,              sizeof(m_screenWidth));
        input.read((char*) &m_screenHeight,             sizeof(m_screenHeight));
        input.read((char*) &m_screenDepth,              sizeof(m_screenDepth));
        int size = 0;
        input.read((char*) &size,                       sizeof(size));
        m_stTitle.resize(size);
        input.read((char*) (m_stTitle.c_str()),         size);
        input.read((char*) &m_bFullscreen,              sizeof(m_bFullscreen));
        input.read((char*) &m_bVSync,                   sizeof(m_bVSync));
        input.read((char*) &m_bParticleEffects,         sizeof(m_bParticleEffects));
        input.read((char*) &m_particleEffectsQuality,   sizeof(m_particleEffectsQuality));
        input.read((char*) &m_bSound,                   sizeof(m_bSound));
        input.read((char*) &m_soundQuality,             sizeof(m_soundQuality));
        input.read((char*) &m_soundVolume,              sizeof(m_soundVolume));
        input.read((char*) &m_bMusic,                   sizeof(m_bMusic));
        input.read((char*) &m_musicQuality,             sizeof(m_musicQuality));
        input.read((char*) &m_musicVolume,              sizeof(m_musicVolume));
        
        input.close();

        return(RESULT_OK);
    }
}//loadFromFile -------------------------------------------------------------------------------------------------------

//---------------------------------------------------------------------------------------------------------------------
//Funktion  :   writeToFile
//Aufgabe   :   Settings in Datei schreiben
//Rückgabe :   ExitCode
//---------------------------------------------------------------------------------------------------------------------
EExitCode CSettings::writeToFile(const std::string& stFileName)
{
    std::ofstream output(stFileName, std::ios::binary);

    if(!output.good())
    {
        output.clear();

        return(RESULT_ERROR);
    }
    else
    {
        output.write((char*) &m_screenWidth,                sizeof(m_screenWidth));
        output.write((char*) &m_screenHeight,               sizeof(m_screenHeight));
        output.write((char*) &m_screenDepth,                sizeof(m_screenDepth));
        int size = m_stTitle.length();
        output.write((char*) &size,                         sizeof(size));
        output.write(m_stTitle.c_str(),                     size);
        output.write((char*) &m_bFullscreen,                sizeof(m_bFullscreen));
        output.write((char*) &m_bVSync,                     sizeof(m_bVSync));
        output.write((char*) &m_bParticleEffects,           sizeof(m_bParticleEffects));
        output.write((char*) &m_particleEffectsQuality,     sizeof(m_particleEffectsQuality));
        output.write((char*) &m_bSound,                     sizeof(m_bSound));
        output.write((char*) &m_soundQuality,               sizeof(m_soundQuality));
        output.write((char*) &m_soundVolume,                sizeof(m_soundVolume));
        output.write((char*) &m_bMusic,                     sizeof(m_bMusic));
        output.write((char*) &m_musicQuality,               sizeof(m_musicQuality));
        output.write((char*) &m_musicVolume,                sizeof(m_musicVolume));
        
        output.close();

        return(RESULT_OK);
    }
}//writeToFile --------------------------------------------------------------------------------------------------------


Die Klasse wird nun direkt in der Hauptklasse auf dem Stack und nicht mehr per new auf dem Heap instanziiert. So funktioniert alles einwandfrei. :thumbsup:

Und an alle Cracks... kritische Anmerkungen zu dem Code oben sind gerne gelesen!

Viele Grüße und Danke!

Jonathan_Klein

Community-Fossil

Beiträge: 3 820

  • Private Nachricht senden

9

08.11.2013, 23:16

Eine Kleinigkeit: Du übergibst in einem Konstruktor einen Tiefenwert, benutzt den aber nicht, sondern setzt ihn konstant auf 32.

Eine zweite Sache: http://en.cppreference.com/w/cpp/string/basic_string/c_str
"Returns a pointer to a null-terminated character array with data equivalent to those stored in the string."
"Writing to the character array accessed through c_str() is undefined behavior. "

Das was du tust funktioniert nur zufällig. Theoretisch könnte das Programm genau so gut abstürzen, sobald es mit einem anderen Compiler oder einer anderen Implementierung der Standardbibliothek kompiliert wird. Das saubere Verhalten wäre, die String-Größe auszulesen, einen Buffer mit der entsprechenden Größe anzulegen, diesen zu füllen, und dem String dann den Bufferinhalt zuzuweisen.
Lieber dumm fragen, als dumm bleiben!

Steef

Alter Hase

Beiträge: 492

  • Private Nachricht senden

10

09.11.2013, 00:08

Zitat von »Jonathan_Klein«

Das was du tust funktioniert nur zufällig. Theoretisch könnte das Programm genau so gut abstürzen, sobald es mit einem anderen Compiler oder einer anderen Implementierung der Standardbibliothek kompiliert wird. Das saubere Verhalten wäre, die String-Größe auszulesen, einen Buffer mit der entsprechenden Größe anzulegen, diesen zu füllen, und dem String dann den Bufferinhalt zuzuweisen.

Ergänzend:
Verwende C++-Casts, dann fallen solche Fehler auch auf.
c_str gibt nicht ohne Grund einen const char* zurück.
"Theory is when you know something, but it doesn’t work. Practice is when something works, but you don’t know why. Programmers combine theory and practice: Nothing works and they don’t know why." - Anon

Werbeanzeige

Ähnliche Themen