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!

Massives Problem mit <vector> und pointern :-((((

Werbeanzeige

alexm

Frischling

  • »alexm« ist der Autor dieses Themas

Beiträge: 71

Wohnort: Wien

  • Private Nachricht senden

1

02.07.2006, 23:38

Massives Problem mit <vector> und pointern :-((((

hallo!

ich habe folgenden Aufbau:

cImage ... Klasse, welche jeweils eine Textur aufnimmt

cListenmanager ... Klasse, welche unter anderem solche cImage Objekte
als vector<Cimage*> verwaltet

cRenderer ... greift dann auf dem cListenmanager seinen vector<Cimage*>
zu, um die Texturen auf ein Sprite zu rendern.

Das Rendern funktioniert ja auch soweit. Jedoch bockts das Programm beim beenden fürchterlich auf und ich bin etwas ratlos :( :(

hier mal meine Codeausschnitte:

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

class cImage
{

public:

    UINT                ID;
    std::string         Filename;
    LPDIRECT3DTEXTURE9  pTexture;
    
    cImage( const UINT _id, const std::string & _filename ) // Standardkonstruktor

    : ID(_id),
      Filename(_filename),
      pTexture(NULL)
    {}
    cImage( const cImage & objToCopy );                 // Kopierkonstruktor

    cImage & operator = ( const cImage & objToCopy );   // Zuweisungskonstruktor

    ~cImage();                                          // Destruktor - gibt TEXTUR frei


    void    ReleaseTexture();
    HRESULT LoadTexture();

};

// Kopierkonstruktor

inline cImage::cImage( const cImage & objToCopy )
{
    *this = objToCopy; // verwendet Zuweisungskonstruktor

}

// Zuweisungskonstruktor

inline cImage & cImage::operator = ( const cImage & objToCopy )
{
    ID          = objToCopy.ID;
    Filename    = objToCopy.Filename;
    pTexture    = objToCopy.pTexture;
    return *this;
}

// Destruktor

inline cImage::~cImage()
{
    /*
    if( pTexture )
    {
        MessageBoxA(0,"pTexture->Release()","cImage.h",MB_OK);
        pTexture->Release();
        pTexture = NULL;
    }
    */
}

inline void cImage::ReleaseTexture()
{
    if( pTexture )
    {
        MessageBoxA(0,"pTexture->Release()","cImage.h",MB_OK);
        pTexture->Release();
        pTexture = NULL;
    }
}


//LPDIRECT3DTEXTURE9 Textur laden

inline HRESULT cImage::LoadTexture()
{
    return (
    D3DXCreateTextureFromFileA( cDX_Interface::GetInstance()->GetD3DDevice(),
                                Filename.c_str(),
                                &pTexture
                                )
            );
}

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

class cListenmanager
{

private:

    static cListenmanager* m_ptrInstance;

    cListenmanager(){}                          // Konstruktor

                
    cListenmanager( const cListenmanager& );    // Kopierkonstruktor private, KEIN kopieren mehr möglich




public:

    static  cListenmanager* CreateInstance();
    static  cListenmanager* GetInstance();
    HRESULT                 Destroy();

    ~cListenmanager(){ Destroy(); }


//private:

public: // nach testen wieder private deklarieren


    std::vector<cImage*>    m_vImage;
    std::vector<cAnim*>     m_vAnim;
    std::vector<cClip>  m_vClip;
    std::vector<cBlob>  m_vBlob;
    UINT                m_blobListIterator;


    void _deletePointers();



public:

    BOOL PushImageToList( const UINT & refID, const std::string & refFileName );
    BOOL PushAnimToList(    const UINT & refID,
                            const UINT & ref_ImageID,       
                            const LONG & ref_X_ReferPoint,  
                            const LONG & ref_Y_ReferPoint,  
                            const LONG & ref_CropWidth,     
                            const LONG & ref_CropHeight,        
                            const LONG & ref_NumFramesInCol,    
                            const LONG & ref_NumFramesInRow 
                            );
    void ReleaseTextures();
    UINT GetMovieLength(){ return 10; } // !!!! testwert - später wird die länge aus den daten errechnet !!!!

};

inline BOOL cListenmanager::PushImageToList( const UINT & refID, const std::string & refFileName )
{
    // Wenn bereits Elemente vorhanden sind, diese nach bereits

    // vergebenen ID-Nummern durchsuchen

    //

    if( m_vImage.size() != 0 )
    {
        for ( INT i = 0; i < static_cast<INT>( m_vImage.size() ); i++ )
        {
            if( m_vImage[i]->ID == refID )
                return FALSE;
        }
    }
    
    cImage * pImageObj = new cImage( refID, refFileName );
    m_vImage.push_back( pImageObj );
    return TRUE;

}

inline BOOL cListenmanager::PushAnimToList( const UINT & refID,
                                            const UINT & ref_ImageID,       
                                            const LONG & ref_X_ReferPoint,  
                                            const LONG & ref_Y_ReferPoint,  
                                            const LONG & ref_CropWidth,     
                                            const LONG & ref_CropHeight,        
                                            const LONG & ref_NumFramesInCol,    
                                            const LONG & ref_NumFramesInRow 
                                            )
{
    MessageBoxA(0,"PushAnimToList()","cListenmanager.h",MB_OK);
    // Wenn bereits Elemente vorhanden sind, diese nach bereits

    // vergebenen ID-Nummern durchsuchen

    //

    if( m_vAnim.size() != 0 )
    {
        for ( INT i = 0; i < static_cast<INT>( m_vAnim.size() ); i++ )
        {
            if( m_vAnim[i]->ID == refID )
                return FALSE;
        }
    }


    // Kontrolle ob Referenzierte Textur in Liste m_vImage vorhanden

    //

    BOOL ref_ImageIDFound;
    INT  i = 0;

    if( m_vImage.size() != 0 )
    {
        while( i < static_cast<INT>( m_vImage.size() ) ) 
        {
            if( m_vImage[i]->ID == ref_ImageID )
            {
                ref_ImageIDFound = TRUE;
                break;
            }
            i++;
        } 
        // FEHLER - ref_ImageID nicht in Liste

        return FALSE;
    }
    else
    {
        // FEHLER - Kein Image in Liste eingetragen

        return FALSE;
    }


    // ANIM Objekt in Liste eintragen

    //

    cAnim * pAnimObj = new cAnim( refID,
                                  ref_ImageID,      
                                  ref_X_ReferPoint, 
                                  ref_Y_ReferPoint, 
                                  ref_CropWidth,        
                                  ref_CropHeight,   
                                  ref_NumFramesInCol,
                                  ref_NumFramesInRow    
                                  );

    m_vAnim.push_back( pAnimObj );
    MessageBoxA(0,"anim objekterzeugt","cListenmanager.h",MB_OK);
    return TRUE;

}


//-----------------------------------------------------------------------------

// Name: _deletePointers()

// Desc: Texturen der cImage Objekte freigeben

//-----------------------------------------------------------------------------

inline void cListenmanager::ReleaseTextures()
{
    //////////////////////////////////////////////////////////////////////////

    // H I E R  G I B T S  D A N N  D E N  A B S T U R Z

    //////////////////////////////////////////////////////////////////////////

/*
    for ( INT i = 0; i < static_cast<INT>( m_vImage.size() ); i++ )
    {
        MessageBoxA(0,"lösche cImage TEXTUR","cListenmanager.h",MB_OK);
        m_vImage[i]->ReleaseTexture();
    }
*/
    //////////////////////////////////////////////////////////////////////////

    // AUCH FOLGENDE VARIANTE FUNKTIONIERT NICHT ...


    m_vImage[0]->ReleaseTexture();
    m_vImage[1]->ReleaseTexture();

}


//-----------------------------------------------------------------------------

// Name: _deletePointers()

// Desc: Angeforderten Speicher sämtlicher Listenelemente freigeben

//-----------------------------------------------------------------------------

inline void cListenmanager::_deletePointers()
{
    /*
    for ( INT i = 0; i < static_cast<INT>( m_vImage.size() ); i++ )
    {
        MessageBoxA(0,"lösche cImage Pointer","cListenmanager.h",MB_OK);
        delete m_vImage[i];
        m_vImage[i] = NULL;
    }
    */

    for ( INT i = 0; i < static_cast<INT>( m_vAnim.size() ); i++ )
    {
        MessageBoxA(0,"lösche cAnim Pointer","cListenmanager.h",MB_OK);
        delete m_vAnim[i];
        m_vAnim[i] = NULL;
    }
}

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

// cListenmanager.cpp


// .....

//-----------------------------------------------------------------------------

// Name: Destroy()

// Desc: Angeforderten Speicher sauber löschen

//-----------------------------------------------------------------------------

HRESULT cListenmanager::Destroy()
{
    // Speicherbereich mit 0 auffüllen

    // Pointer löschen

    // Point-to Adresse löschen

    if (m_ptrInstance)
    {
        
        _deletePointers(); // Vektor-Inhalte löschen


        SecureZeroMemory(&m_ptrInstance,sizeof(m_ptrInstance));
        delete m_ptrInstance;
        m_ptrInstance = NULL;
        return S_OK;
    }
    // Keine Objektinstanz zum löschen vorhanden

    // RETURN: Invalid_Pointer

    return E_POINTER;
}

// .....


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

class cRenderer
{
private:

    static cRenderer* m_ptrInstance;

    cRenderer()                     // Konstruktor

    {
        // Render-Device Handle holen

        cDX_Interface* TEMP_DX_INTERFACE = cDX_Interface::GetInstance();

        m_D3D_DEVICE = TEMP_DX_INTERFACE->GetD3DDevice();

        // TIMEMANAGER Handle holen

        m_TIMEMANAGER = cTimeManager::GetInstance();

        // cImage Testobjekt ///////////////////////////////////////////////////

        //

        // Pointer auf Image Objekt in Vektor

        pImageObj =  cListenmanager::GetInstance()->m_vImage[0];

        //

        ////////////////////////////////////////////////////////////////////////


        _initSpriteEnviroment();
        _initD3D_Font();

        m_currentTimeSec    = 0;
        m_currentTimeMSec   = 0;
        m_lastCallTimeMSec  = 1;
        m_lastAnimUpdateT   = 0;


        // m_FrameRatesVec mit Nullen initialisieren

        for ( INT i=0; i<=299; i++ )
        {
            this->m_FrameRatesVec.push_back( 0 );
        }
        m_FrameRatesCountr = 0;


    }


    cRenderer( const cRenderer& );  // Kopierkonstruktor private, KEIN kopieren mehr möglich


public:

    static  cRenderer*  CreateInstance();
    static  cRenderer*  GetInstance();
    HRESULT                 Destroy();

    ~cRenderer()
    {
        Destroy(); 
    }

private:

    LPDIRECT3DDEVICE9   m_D3D_DEVICE;       // Render Device


    LPD3DXSPRITE        m_SPRITE;           // ein D3D-Sprite Objekt als Ziel für Renderings

    D3DXMATRIX          m_MATRIX;           // ein D3D-Matrix Objekt

    LPDIRECT3DTEXTURE9  m_TEXTURE;          // später mehrere hiervon als vector ....

    D3DXVECTOR3         m_screen_xyzPos;    // x,y,(z) für Textur

    RECT                m_cropFromBitmap;   // Texturausschnitt-Rechteck - später mehrere hiervon als vector ....


    char                m_screenText[1024]; // Puffer für Textausgabe

    cTimeManager*       m_TIMEMANAGER;      // Handle vom TIMEMANAGER - wird nur für DEBUG-Textausgaben benötigt


    INT                 m_currentTimeSec;   // Lokale Movie-Zeit in Sekunden

    INT                 m_currentTimeMSec;  // Lokale Movie-Zeit in Millisekunden

    LONG                m_lastCallTimeMSec; // Letzter Zeitpunkt an dem die Render()-Methode aufgerufen wurde


    UINT                m_lastAnimUpdateT;  // Letzter Zeitpunkt an dem ein Anim-Frame upgedated wurde


    std::vector<UINT>   m_FrameRatesVec;    // Speichert 300 Frame-Raten-Werte - Dient zur Auswertung für das Logfile

    UINT                m_FrameRatesCountr; // Zähler zur Überwacheng der vFrameRates Einträge;




    void _initSpriteEnviroment();           // D3DSPRITE Initialisierungen 



public:

    void RenderFrame();                     // Renderfunktion


    // testpointer auf EIN cImageObjekt

    // (später zugriff über vector)

    //

    cImage * pImageObj;

};

inline void cRenderer::_initSpriteEnviroment()
{
    //////////////////////////////////////////////////////////////////////////

    // Sprite-objekte und Textur-Objekte erzeugen

    // werden erst beim Rendern zusammengeführt

    //////////////////////////////////////////////////////////////////////////


    // :::::::: EIN SPRITE-Objekt erzeugen :::::::: 

    D3DXCreateSprite(m_D3D_DEVICE, &m_SPRITE);

    // :::::::: EIN TEXTURE-Objekt erzeugen :::::::: 

    pImageObj->LoadTexture();

    m_TEXTURE = pImageObj->pTexture;

    // :::::::: Initialisierungen für SPRITE+TEXTUR zum Rendern:::::::: 

    //

    // matrix-objekt erzeugen

    //D3DXMATRIX matrix;


    // x,y,z-screen-koordinaten

    m_screen_xyzPos.x = 0.0f;
    m_screen_xyzPos.y = 200.0f;
    m_screen_xyzPos.z = 0.0f;

    // Texturausschnitt-Rechteck, 64x64

    //RECT  cropFromBitmap;

    m_cropFromBitmap.left       = 0;
    m_cropFromBitmap.top        = 64;
    m_cropFromBitmap.right      = 64;
    m_cropFromBitmap.bottom     = 128;
}

inline void cRenderer::RenderFrame()
{

    /* 
    ....
    .... diverses für animationshandling
    ....
    */

    // :::::::: RENDER - START :::::::: 

    //

    m_D3D_DEVICE->Clear(0,NULL,D3DCLEAR_TARGET,D3DCOLOR_XRGB(0,0,0),1.0f,0);
    m_D3D_DEVICE->BeginScene();

    m_SPRITE->Begin(D3DXSPRITE_ALPHABLEND);

    D3DXMatrixIdentity(&m_MATRIX);  // Identitätsmatrix zuweisen (scale=1,rotation=1,translation=1)

    m_SPRITE->SetTransform(&m_MATRIX);  // matrix dem sprite zuweisen


    m_SPRITE->Draw(
        m_TEXTURE,          // textur

        &m_cropFromBitmap,  // ausschnitt von der geladenen textur

        NULL,               // center

        &m_screen_xyzPos,       // screen-position

        0xFFFFFFFF          // color-overlay

        //0x8025A735 

        );

    m_SPRITE->End();

    m_D3D_DEVICE->EndScene();
    m_D3D_DEVICE->Present(NULL,NULL,NULL,NULL);
    //

    // :::::::: RENDER - ENDE :::::::: 



}

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

HRESULT cRenderer::Destroy()
{

    _frameRateInfoToLogfile();


    // Speicherbereich mit 0 auffüllen

    // Pointer löschen

    // Point-to Adresse löschen

    if (m_ptrInstance)
    {
        // FONT freigeben

        _destroyD3D_Font();
        // TEXTUREN und SPRITE Objekte freigeben

        //


        cListenmanager::GetInstance()->ReleaseTextures();
        m_TEXTURE->

        //m_TEXTURE->Release();


        m_SPRITE->Release();

        // RENDERER Instanz freigeben

        SecureZeroMemory(&m_ptrInstance,sizeof(m_ptrInstance));
        delete m_ptrInstance;
        m_ptrInstance = NULL;
        return S_OK;
    }
    // Keine Objektinstanz zum löschen vorhanden

    // RETURN: Invalid_Pointer

    return E_POINTER;
}



Sorry, ich weiss, es ist verrückt so viel Code zu posten aber da ich nicht
weiss, woran der Absturz liegt hab ich mir gedacht, dass das
wahrscheinlich nötig ist.

Ist es überhaupt angebracht und sinnvoll, im Vector nur pointer zu
speichern?

Ich hoffe, es kann mir da jemand helfen. Wäre wirklich super!!!
Dankeschön ...

koschka

Community-Fossil

Beiträge: 2 862

Wohnort: Dresden

Beruf: Student

  • Private Nachricht senden

2

02.07.2006, 23:43

Debugges mal durch und sag mal was rauskommt und wo

alexm

Frischling

  • »alexm« ist der Autor dieses Themas

Beiträge: 71

Wohnort: Wien

  • Private Nachricht senden

3

02.07.2006, 23:50

Zitat


Unhandled exception at 0x00406081 in 2dcse.exe: 0xC0000005: Access violation reading location 0x00000004.


CallStack:

Zitat


> 2dcse.exe!cListenmanager::ReleaseTextures() Line 184 C++
2dcse.exe!cRenderer::Destroy() Line 80 C++
2dcse.exe!WinMain(HINSTANCE__ * hInstance=0x00400000, HINSTANCE__ * hPrevInstance=0x00000000, char * lpCmdLine=0x00151f28, int nCmdShow=1) Line 203 C++
2dcse.exe!__tmainCRTStartup() Line 315 + 0x1c bytes C

koschka

Community-Fossil

Beiträge: 2 862

Wohnort: Dresden

Beruf: Student

  • Private Nachricht senden

4

02.07.2006, 23:52

naja haste doch nen Ansatzpunkt, jetzt setzte ein paar Haltepunkte (auf Leiste zwischen Projektmappe und Code klicken, so das roter Punkt erscheint und schaust dir das in ruhe an den Stellen an.

alexm

Frischling

  • »alexm« ist der Autor dieses Themas

Beiträge: 71

Wohnort: Wien

  • Private Nachricht senden

5

02.07.2006, 23:53

das hab ich bereits die letzten 4 stunden gemacht ...
und meine verzweiflung brachte mich eben dazu das hier zu posten :(

alexm

Frischling

  • »alexm« ist der Autor dieses Themas

Beiträge: 71

Wohnort: Wien

  • Private Nachricht senden

6

02.07.2006, 23:55

greif ich vielleicht irgendwie falsch auf den vektor bzw.
die objekte die hinter den pointern stehen zu?

ich check das nimmer *wäääähhh* :)

Beliah

Treue Seele

Beiträge: 115

Wohnort: Söhlde - LK Hildesheim

Beruf: FI-Anwendungsentwicklung

  • Private Nachricht senden

7

03.07.2006, 10:12

Ich kenn mich mit dem DirectX zeugs nicht aus, kann also nicht sagen ob da irgendwas falsch ist, aber diese Methode auf einen std::vector zuzugreifen sollte eigentlich funktionieren.

Kannst ja mal versuche mit einem std::vector<typname>::Iterator zu arbeiten aber das sollte eigentlich genauso sein.
Debuggers don't remove bugs, they only show them in slow motion.

Google Suche ohne Werbung und Cookies: Scroogle

Derzeitige(s) Freizeitprojekt(e)

alexm

Frischling

  • »alexm« ist der Autor dieses Themas

Beiträge: 71

Wohnort: Wien

  • Private Nachricht senden

8

03.07.2006, 11:05

schade ...
ja das mit iterator hab ich auch schon probiert.


ich glaub ja fast, dass die fehlermeldung irreführend ist, und dass da wo ganz
anders in meinem programm der hund vergraben ist.

ich habe mir zwischenzeitlich unabhängig davon ein kleines konsolenprojekt
erstellt wo ich eine ähnliche struktur mit cPerson und cVerwaltung gebaut
habe und genauso mit den elementen und pointern hantiere.
bei dem testprog. läuft alles so wies soll. demnach muss ich wirklich mal
woanders im programm suchen, da ich offenbar bei meiner
new-objekterzeugung & zugriff & löschen nicht wirklich den fehler drinnen
habe.
:(

Firefly

Alter Hase

Beiträge: 484

Wohnort: Irgendwoundnirgendwo

  • Private Nachricht senden

9

03.07.2006, 13:52

was ist jetzt eigentlich dich dein problem?

alexm

Frischling

  • »alexm« ist der Autor dieses Themas

Beiträge: 71

Wohnort: Wien

  • Private Nachricht senden

10

05.07.2006, 16:18

konnte es inziwschen schon lösen :oops:

Werbeanzeige