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!

Liste in Liste - Wo liegt der Fehler?

  • 1
  • 2

Werbeanzeige

Firefly

Alter Hase

  • »Firefly« ist der Autor dieses Themas

Beiträge: 484

Wohnort: Irgendwoundnirgendwo

  • Private Nachricht senden

11

20.12.2007, 21:01

so, also Problem gelöst. Für alle dies interessiert, es lag an memcpy.

David_pb

Community-Fossil

Beiträge: 3 886

Beruf: 3D Graphics Programmer

  • Private Nachricht senden

12

20.12.2007, 22:51

Zitat von »"Firefly"«

so, also Problem gelöst. Für alle dies interessiert, es lag an memcpy.


Wurde ja bereits erwähnt, dass das irgendwie suboptimal ist!
@D13_Dreinig

Firefly

Alter Hase

  • »Firefly« ist der Autor dieses Themas

Beiträge: 484

Wohnort: Irgendwoundnirgendwo

  • Private Nachricht senden

13

21.12.2007, 17:24

So...nochmal dieses verflixte Problem....es schien zwar dass das problem tatsächlich durch das memcpy gelöst war aber tatsächlich stürzt das programm wenn die destruktoren aufgerufen werden ab. Um das Problem zu reduzieren habe ich die anderen programmbestandteile ausgelassen und ein testprogramm geschrieben.(hierbei benutze ich auch nur eine einfache liste) Hat jemand eine Idee woran das liegt(bei den STL Klassen tritt das Problem jedenfalls nicht auf...)?

Hier nun erstmal der Quellcode...

main.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

//Testprogramm für Listen---


#include <iostream>
#include "CSimpleList.h"

//struct tests

struct a
{
    CSimpleList<int> Ints;
};
struct b
{
    CSimpleList<a> As;
};
//Main

int main()
{
    //Testprogramm

    a A;
    b B;
    
    A.Ints.insert_front(1);
    B.As.insert_front(A);

    std::cin.get();

    return 0;
    //bishierher funktioniert alles nur jetzt folgt der absturz...

}


CSimpleList.h

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

//***************************************************************************************//

//*** Datei: CSimpleList.h  , Stand 21.12.2007  *****************************************//

//***************************************************************************************//

#ifndef CSIMPLELIST_HEADER_
#define CSIMPLELIST_HEADER_
//***************************************************************************************//

template <typename Type> struct SSimpleNode
{
    Type Data;
    SSimpleNode *pNext;
};
//***************************************************************************************//

template <typename Type> class CSimpleList
{
private:
    unsigned int        m_uiNumNodes;   //Anzahl Einträge

    SSimpleNode<Type>   *m_pHead;       //Head

public:
    CSimpleList(void);
    CSimpleList(const CSimpleList<Type>& c);
    ~CSimpleList(void);
    //operatoren

    CSimpleList<Type>& operator = (const CSimpleList<Type>& x);
    //Funktionen

    void insert_front(Type Data);
    void insert_back(Type Data);
    void remove_front(void);
    void remove_back(void);
    void clear(void);
    bool empty(void){return (m_pHead == NULL);}
    int     size(void){return m_uiNumNodes;}
};
//***************************************************************************************//

template<typename Type> CSimpleList<Type>::CSimpleList(void)
{
    m_uiNumNodes    = 0;
    m_pHead         = NULL;
}
//***************************************************************************************//

template<typename Type> CSimpleList<Type>::CSimpleList(const CSimpleList<Type>& c)
{
    //Destruktor aufrufen

    if(this)clear();

    //übertragen

    m_uiNumNodes    = c.m_uiNumNodes;
    m_pHead         = c.m_pHead;
}
//***************************************************************************************//

template<typename Type> CSimpleList<Type>::~CSimpleList()
{
    //wenn m_pHead gültig Clear ausführen

    if(m_pHead)clear();
    //auf 0 setzen

    m_uiNumNodes    = 0;
}
//***************************************************************************************//

template<typename Type> CSimpleList<Type>& CSimpleList<Type>::operator = (const CSimpleList<Type>& x)
{
    //löschen

    clear();

    //übertragen

    m_uiNumNodes = x.m_uiNumNodes;
    m_pHead = x.m_pHead;

    //zurückgeben

    return *this;
}
//***************************************************************************************//

template<typename Type> void CSimpleList<Type>::clear(void)
{
    //Liste durchgehen und eintrag löschen solange er existiert

    while(m_pHead)remove_front();
}
//***************************************************************************************//

template<typename Type> void CSimpleList<Type>::insert_front(Type Data)
{
    //neues Element erzeugen

    SSimpleNode<Type> *pNewNode = new SSimpleNode<Type>;
    
    //Werte zuweisen

    pNewNode->Data = Data;
    pNewNode->pNext = m_pHead;
    
    //neuen Anfang festlegen

    m_pHead = pNewNode;

    //Zähler erhöhen

    m_uiNumNodes++;
}
//***************************************************************************************//

template<typename Type> void CSimpleList<Type>::insert_back(Type Data)
{
    //neues Element erzeugen

    SSimpleNode<Type> *pNewNode = new SSimpleNode<Type>;

    //Werte zuweisen

    pNewNode->Data  = Data;
    pNewNode->pNext = NULL;

    //1. Element der Liste

    if(m_pHead == NULL)
    {
        m_pHead = pNewNode;
    }
    //ansonsten...

    else
    {
        //Liste durchgehen und Ende (->pNext = NULL;

        SSimpleNode<Type> *node = m_pHead;
        //Schleife

        while(node->pNext != NULL)
        {
            node = node->pNext;
        }
        //übertragen

        node->pNext = pNewNode;
    }
    //Zähler erhöhen

    m_uiNumNodes++;
}
//***************************************************************************************//

template<typename Type> void CSimpleList<Type>::remove_front(void)
{
    //testen ob überhaupt ein Element vorhanden ist...

    if(m_pHead == NULL)
    {
        //Fehler....

    }
    //alles ok

    else
    {
        //neuen m_pHead festlegen

        m_pHead = m_pHead->pNext;
    }
    //Zähler herunterzählen

    m_uiNumNodes--;
}
//***************************************************************************************//

template<typename Type> void CSimpleList<Type>::remove_back(void)
{
    //testen ob überhaupt ein Element vorhanden ist...

    if(m_pHead == NULL)
    {
        //Fehler....

    }
    //alles ok

    else
    {
        //nur ein Element vorhanden ?

        if(m_pHead->pNext == NULL)
        {
            delete m_pHead;
            m_pHead = NULL;
        }
        //mehr Elemente vorhanden

        else
        {
            SSimpleNode<Type> *node = m_pHead;
            //Schleife um Liste durchzugehen

            while(node->pNext->pNext != NULL)
            {
                node = node->pNext;
            }
            //löschen

            delete node->pNext;
            node->pNext = NULL;
        }
    }
    //Zähler herunterzählen

    m_uiNumNodes--;
}
//***************************************************************************************//

#endif
//***************************************************************************************//

Firefly

Alter Hase

  • »Firefly« ist der Autor dieses Themas

Beiträge: 484

Wohnort: Irgendwoundnirgendwo

  • Private Nachricht senden

14

21.12.2007, 17:31

Für die Leute die's eventuell auch mal durchkompilieren wollen hier der komplette Arbeitsbereich...
http://www.filehosting.at/files/download…ab88139<br />

Deviloper

Community-Fossil

Beiträge: 2 872

  • Private Nachricht senden

15

21.12.2007, 18:16

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

template<typename Type> void CSimpleList<Type>::remove_front(void)
{
    //testen ob überhaupt ein Element vorhanden ist...

    if(m_pHead == NULL)
    {
        //Fehler....

    }
    //alles ok

    else
    {
        //neuen m_pHead festlegen

        m_pHead = m_pHead->pNext;
    }
    //Zähler herunterzählen

    m_uiNumNodes--;
}
ist sicherlich keine gültige Aufräumarbeit. Musst schon auch nen delete für den alten m_pHead aufrufen und die Daten nicht im Wind stehen lassen :P

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10

template<typename Type> void CSimpleList<Type>::remove_front()
{
    if (m_pHead != NULL)
    {
        SSimpleNode<Type>* pTmp(m_pHead);
        m_pHead = m_pHead->pNext;
        delete pTmp;
    }
    m_uiNumNodes--;
}
oder so wäre eher korrekt.
Devil Entertainment :: Your education is our inspiration
Der Spieleprogrammierer :: Community Magazin
Merlin - A Legend awakes :: You are a dedicated C++ (DirectX) programmer and you have ability to work in a team? Contact us!
Siedler II.5 RttR :: The old settlers-style is comming back!

Also known as (D)Evil

Firefly

Alter Hase

  • »Firefly« ist der Autor dieses Themas

Beiträge: 484

Wohnort: Irgendwoundnirgendwo

  • Private Nachricht senden

16

21.12.2007, 22:44

das Problem ist nur dass diese Lösung eine unbehandelte Ausnahme wirft, da m_pHead->Next ja nicht mehr existiert...

David_pb

Community-Fossil

Beiträge: 3 886

Beruf: 3D Graphics Programmer

  • Private Nachricht senden

17

22.12.2007, 00:04

Ganz abseits alldessen... Das ist nicht was ich unter gescheitem Kopierkonstruktor verstanden habe:

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

template<typename Type> CSimpleList<Type>::CSimpleList(const CSimpleList<Type>& c)
{
    //Destruktor aufrufen

    if(this)clear();

    //übertragen

    m_uiNumNodes    = c.m_uiNumNodes;
    m_pHead            = c.m_pHead;
}

//***************************************************************************************//

template<typename Type> CSimpleList<Type>& CSimpleList<Type>::operator = (const CSimpleList<Type>& x)
{
    //löschen

    clear();

    //übertragen

    m_uiNumNodes = x.m_uiNumNodes;
    m_pHead = x.m_pHead;

    //zurückgeben

    return *this;
}


Das erstellt einge ganz normale flache Kopie.
Achja, was soll dieser Unsinn (im copy c'tor)

C-/C++-Quelltext

 
1

if(this)clear();
@D13_Dreinig

mahe

Frischling

Beiträge: 71

  • Private Nachricht senden

18

22.12.2007, 00:08

Da kommt auch der Fehler her. clear() kann an dieser Stelle nicht richtig funktionieren weil p_mHead nicht definiert ist.

Firefly

Alter Hase

  • »Firefly« ist der Autor dieses Themas

Beiträge: 484

Wohnort: Irgendwoundnirgendwo

  • Private Nachricht senden

19

22.12.2007, 09:41

funktioniert tatsächlich...obwoh ich nirgends den copyc'tor aufrufe...danke für die antwort

mahe

Frischling

Beiträge: 71

  • Private Nachricht senden

20

22.12.2007, 19:40

Doch natürlich rufst Du den auf.

Genau hier wird er aufgerufen:

C-/C++-Quelltext

 
1

B.As.insert_front(A);

Werbeanzeige

  • 1
  • 2