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!

verkettete liste ...

Werbeanzeige

Beliah

Treue Seele

Beiträge: 115

Wohnort: Söhlde - LK Hildesheim

Beruf: FI-Anwendungsentwicklung

  • Private Nachricht senden

21

10.03.2007, 12:50

Zitat von »"$nooc"«

wie sieht es damit aus?
[...]


Erstens fehlt ein "Vorschlag" von big_muff.
Zweitens: Was soll der else Zweig?

€

Zitat von »"$nooc"«


edit*
das hab ich sowieso nie so ganz verstanden wieso ich zuerst deleten muss und dann erst auf null setzen.. nach meiner logisch sollte es ja nicht gehn etwas auf null zu setzen, was es nicht mehr gibt.. ^^
aber naja.. wenns nicht anders geht +g+


Das Objekt auf den der Zeiger zeigt existiert nich mehr, aber der Zeiger selber existiert noch.
Debuggers don't remove bugs, they only show them in slow motion.

Google Suche ohne Werbung und Cookies: Scroogle

Derzeitige(s) Freizeitprojekt(e)

$nooc

Alter Hase

  • »$nooc« ist der Autor dieses Themas

Beiträge: 873

Wohnort: Österreich / Kärnten

Beruf: Schüler

  • Private Nachricht senden

22

10.03.2007, 12:51

vielleicht sollte ich so fragen:

ist ein zeiger der NULL ist ein freigegebener pointer?
oder ist der else zeig unnötig? ^^
Am Anfang der Weisheit steht die eigene Erkenntnis, dass man selbst nichts weiß! - Sokrates

big_muff

Alter Hase

Beiträge: 460

Wohnort: Schweiz

Beruf: Informatikstudent (4. Semester)

  • Private Nachricht senden

23

10.03.2007, 12:52

Zitat von »"$nooc"«

das hab ich sowieso nie so ganz verstanden wieso ich zuerst deleten muss und dann erst auf null setzen.. nach meiner logisch sollte es ja nicht gehn etwas auf null zu setzen, was es nicht mehr gibt.. ^^
aber naja.. wenns nicht anders geht +g+

Du solltest dir dringend noch mal das Kaptitel über Zeiger in deinem C++-Buch anschauen. Deine DeleteList()-Funktion ist auch nochmal voller Fehler im Umgang mit Zeigern. Du hast da noch ein tiefes Verständnisproblem. Das hat so keinen Sinn dir das zu erklären.
Nur Idioten halten Ordnung, ein Genie beherrscht das Chaos.[size=7]

[/size]HardFate - Ein Start, Ein Ziel, Viele Wege[size=7]

[/size]Ein Mitglied der VEGeiCoUndGraSonMaWiGeS Bewegung.

$nooc

Alter Hase

  • »$nooc« ist der Autor dieses Themas

Beiträge: 873

Wohnort: Österreich / Kärnten

Beruf: Schüler

  • Private Nachricht senden

24

10.03.2007, 13:02

naja gut ich fass mal zusammen was ich von pointern weiß, oder glaube zu wissen .. ^^

pointer sind variablen (naja.. kann man variablen dazu sagen?) die auf einen speicherbereich zeigen.
einen pointer definiere ich wie folgt

C-/C++-Quelltext

 
1

int *ptr = NULL; // so mach ich es zumindest ^^


was ich eben vergessen habe ist, dass man mit "new" neuen speicher reserviert, und wenn ich einen pointer mit "new" instanziere, zeigt dieser auf den speicherbereich. ich kann einen pointer sagen auf welchen speicherbereich er zeigen soll.. dazu wäre es angebracht "keinen" zusätzlichen speicher für den pointer zu reservieren (eben das was ich da dauernd falsch gemacht habe), da der speicher ansonst reserviert bleibt, und ich den zugriff darauf verliere.
um einen pointer wo anders hinzeigen zu lassen, also auf ein bestimmtes objekt oder so schreibt man

C-/C++-Quelltext

 
1
2
3
4

Element MeinElement;
Element *ptrElement;

ptrElement = &MeinElement;
Am Anfang der Weisheit steht die eigene Erkenntnis, dass man selbst nichts weiß! - Sokrates

big_muff

Alter Hase

Beiträge: 460

Wohnort: Schweiz

Beruf: Informatikstudent (4. Semester)

  • Private Nachricht senden

25

10.03.2007, 13:06

Wenn du mit diesem Wissen deinen Code noch mal überarbeitest dann sollte es wohl fast keine Fehler mehr drin haben.
Ausserdem: Mit delete gibt man das Objekt frei auf das der Zeiger zeigt, nicht den Zeiger selbst, der existiert bis zum Ende seines Gültigkeitsbereiches...

Ach ja, wenn das dann mal klappt solltest du ein Template aus deiner verketteten Liste machen, nur mit ints bringt das ganze nicht viel...
Nur Idioten halten Ordnung, ein Genie beherrscht das Chaos.[size=7]

[/size]HardFate - Ein Start, Ein Ziel, Viele Wege[size=7]

[/size]Ein Mitglied der VEGeiCoUndGraSonMaWiGeS Bewegung.

$nooc

Alter Hase

  • »$nooc« ist der Autor dieses Themas

Beiträge: 873

Wohnort: Österreich / Kärnten

Beruf: Schüler

  • Private Nachricht senden

26

10.03.2007, 14:00

also ich poste jetzt einfach mal den code nochmal..
ich glaube das funktioniert jetzt mit dem löschen
.. ich hab nach dem löschen der elemente keinen zugriff mehr :)

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

// #########################################################

// File:        CChainedList.cpp

// Writer:      Snooc

// Description: Class CChainedList

// #########################################################

// I N C L U D E S #########################################

#include "CChainedList.hpp"

// P R O T E C T E D #######################################

    // F U N C T I O N S ###################################

ChainedList::ChainedList()
{
    m_pPtrToFirstElement    = NULL; // First

    m_pPtrToLastElement     = NULL; // Last

    // m_ElementCounter = 0;

} // Constructor()


unsigned long ChainedList::Add(int Value)
{
        // If there is no element at all:

    if (m_pPtrToFirstElement == NULL)
    {
        Element *pAddElement = NULL;
        pAddElement = new Element;
        
        pAddElement->m_ListNr           = 0;
        pAddElement->m_Value            = Value;
        pAddElement->m_pPrevElement = NULL;
        pAddElement->m_pNextElement = NULL;

        m_pPtrToFirstElement = pAddElement;
        m_pPtrToLastElement = m_pPtrToFirstElement;

        return 0;
    }

    Element *pCurElement = NULL;

    Element *pAddElement = NULL;
    pAddElement = new Element;

    pCurElement = m_pPtrToFirstElement;

    while(pCurElement != NULL)
    {
        if((pCurElement->m_pNextElement) == NULL)
        {
            pAddElement->m_ListNr = pCurElement->m_ListNr + 1;
            pAddElement->m_Value = Value;

                // Chain the elements ..

            pAddElement->m_pNextElement = NULL;
            pAddElement->m_pPrevElement = pCurElement;

            pCurElement->m_pNextElement = pAddElement;
            m_pPtrToLastElement = pAddElement;
        
            return 0;
        } // while(pCurElement != NULL)


        pCurElement = pCurElement->m_pNextElement;
    }

    return 0;
} // Add()


unsigned long ChainedList::Remove(void)
{
    return 0;
} // Remove()


unsigned long ChainedList::ShowList(void)
{
    Element *pCurElement = NULL;

    if((pCurElement = m_pPtrToFirstElement) == NULL)
    { 
        cout << "There are no elements .." << endl;
        PTR_DELETE(pCurElement);
        return 0; 
    }

    while(pCurElement != NULL)
    {
        cout << "Element Nr. " << pCurElement->m_ListNr << endl;
        cout << "Wert: "<< pCurElement->m_Value << endl << endl;

        pCurElement = pCurElement->m_pNextElement;
    } // while(pCurElement != NULL)


    delete pCurElement;

    cout << "First element ListNr: " << m_pPtrToFirstElement->m_ListNr << endl;
    cout << "First element Value: " << m_pPtrToFirstElement->m_Value << endl << endl;

    cout << "Last element ListNr: " << m_pPtrToLastElement->m_ListNr << endl;
    cout << "Last element Value: " << m_pPtrToLastElement->m_Value << endl << endl;

    return 0;
} // ShowList()


unsigned long ChainedList::DeleteList(void)
{
    cout << "Deleting all elements .." << endl; 

    Element *pDeleteMe = NULL;
    pDeleteMe = m_pPtrToFirstElement;

    Element *pDummy = NULL;
    
    while(pDeleteMe != NULL)
    { 
        pDummy = pDeleteMe->m_pNextElement;
        if(pDummy != NULL)
        {
            pDummy->m_pPrevElement = NULL;
            PTR_DELETE(pDeleteMe);

            pDeleteMe = pDummy;
        }
        else
        { 
            PTR_DELETE(pDeleteMe); 
            m_pPtrToFirstElement    = NULL; // First

            m_pPtrToLastElement     = NULL; // Last

        }
    } // while(pDeleteMe != NULL)


    return 0;
} // DeleteList()



EDIT:

eine frage hätte ich noch.. man kann ja operatoren überladen.. jetzt weiß ich nicht.. kann man den * operator so überladen, dass er einen pointer immer mit NULL initialisiert?
Am Anfang der Weisheit steht die eigene Erkenntnis, dass man selbst nichts weiß! - Sokrates

big_muff

Alter Hase

Beiträge: 460

Wohnort: Schweiz

Beruf: Informatikstudent (4. Semester)

  • Private Nachricht senden

27

10.03.2007, 14:36

1. Wieso sind deine Rückgabewerte unsigned long. Das ist unnötig.
2.

C-/C++-Quelltext

 
1
2

Element *pAddElement = NULL; 
pAddElement = new Element;
Wieso schreibst du nicht einfach

C-/C++-Quelltext

 
1

Element *pAddElement = new Element;
Ist ein bisschen schneller und meiner Meinung nach auch schöner anzusehen aber das ist Ansichtssache. Du machst das an vielen Stellen so.
3. In der Add()-Funktion verwendest du immer noch nicht das letzte Element sondern gehst durch alle durch. Das kann unter Umständen viel langsamer sein...
4. In der ShowList()-Funktion: Wieso löschtst du den Nullzeiger am Anfang? Und wieso löschst du den Nullzeiger nach der while-Schleife?
5. In der DeleteList()-Funktion:

C-/C++-Quelltext

 
1

pDummy->m_pPrevElement = NULL;
Wieso machst du dir die Umstände etwas mit PrevElement zu machen wenn du danach sowieso das ganze Element löschst?
Die Schleife zum Löschen kannst du auch ohne das if-else-Zeugs machen indem du das erst und das letzte Element erst nach der Schleife auf NULL setzt...

Zitat von »"$nooc"«

eine frage hätte ich noch.. man kann ja operatoren überladen.. jetzt weiß ich nicht.. kann man den * operator so überladen, dass er einen pointer immer mit NULL initialisiert?
Du musst deine Pointer nicht mit NULL initialisieren wenn du nachher sowieso was anderes zuweist. Siehe dazu auch 2.
Nur Idioten halten Ordnung, ein Genie beherrscht das Chaos.[size=7]

[/size]HardFate - Ein Start, Ein Ziel, Viele Wege[size=7]

[/size]Ein Mitglied der VEGeiCoUndGraSonMaWiGeS Bewegung.

$nooc

Alter Hase

  • »$nooc« ist der Autor dieses Themas

Beiträge: 873

Wohnort: Österreich / Kärnten

Beruf: Schüler

  • Private Nachricht senden

28

11.03.2007, 14:24

aaalso ich hab den code jetzt überarbeitet..
wäre nett wenn sich den vllt. nochmal jemand ansieht :)


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
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256

// #########################################################

// File:        CChainedList.cpp

// Writer:      Snooc

// Description: Class CChainedList

// #########################################################

// I N C L U D E S #########################################

#include "CChainedList.hpp"

// P R O T E C T E D #######################################

    // F U N C T I O N S ###################################

ChainedList::ChainedList()
{
    m_pPtrToFirstElement    = NULL; // First

    m_pPtrToLastElement     = NULL; // Last

    // m_ElementCounter = 0;

} // Constructor()


unsigned long ChainedList::Add(void)
{
        // If there is no element at all:

    if (m_pPtrToFirstElement == NULL)
    {
        Element *pAddElement = new Element;
        
        pAddElement->m_Value        = 0;
        pAddElement->m_pPrevElement = NULL;
        pAddElement->m_pNextElement = NULL;

        m_pPtrToFirstElement    = pAddElement;
        m_pPtrToLastElement     = m_pPtrToFirstElement;
        
            // Sort the list

        SortList();

        return ADDING_SUCCEEDED;
    }

    Element *pAddElement = NULL;
    pAddElement = new Element;

    pAddElement->m_ID           = m_pPtrToLastElement->m_ID + 1;
    pAddElement->m_Value        = pAddElement->m_ID;
    pAddElement->m_pPrevElement = m_pPtrToLastElement;
    pAddElement->m_pNextElement = NULL;

    m_pPtrToLastElement->m_pNextElement = pAddElement;
    m_pPtrToLastElement                 = pAddElement;

    return ADDING_SUCCEEDED;
} // Add()


unsigned long ChainedList::Add(unsigned long PositionID)
{
    if(m_pPtrToFirstElement == NULL)
    {
        Add();
        return ELEMENT_WAS_THE_FIRST_IN_LIST;
    }

    if(PositionID > m_pPtrToLastElement->m_ID)
    {
        Add();
        return POSITIONID_OUT_OF_RANGE;
    }

    Element *pDummy = NULL;

    unsigned long x;
    if(PositionID >= (x = m_pPtrToLastElement->m_ID / 2))
    {
        pDummy = m_pPtrToLastElement;

        while(pDummy->m_ID != PositionID)
        { pDummy = pDummy->m_pPrevElement; } // while(pDummy->m_ID != PositionID)


        Element *pAddElement = new Element;
        pAddElement->m_Value = 999;

        pDummy->m_pPrevElement->m_pNextElement  = pAddElement;
        pAddElement->m_pPrevElement             = pDummy->m_pPrevElement;
        pDummy->m_pPrevElement                  = pAddElement;
        pAddElement->m_pNextElement             = pDummy;

            // Sort the list

        SortList();

        return ADDING_SUCCEEDED;
    }
    else
    {
        pDummy = m_pPtrToFirstElement; 

        while(pDummy->m_ID != PositionID)
        { pDummy = pDummy->m_pNextElement; } // while(pDummy->m_ID != PositionID)


        Element *pAddElement = NULL;

        if(pDummy->m_ID == 0)
        {
            pAddElement = new Element;
            pAddElement->m_Value        = 999;
            pAddElement->m_pNextElement = pDummy;
            pDummy->m_pPrevElement      = pAddElement;
            m_pPtrToFirstElement        = pAddElement;

                // Sort the list

            SortList();

            return ADDING_SUCCEEDED;
        }

        pAddElement = new Element;
        pAddElement->m_Value = 999;

        pDummy->m_pPrevElement->m_pNextElement  = pAddElement;
        pAddElement->m_pPrevElement             = pDummy->m_pPrevElement;
        pDummy->m_pPrevElement                  = pAddElement;
        pAddElement->m_pNextElement             = pDummy;

            // Sort the list

        SortList();

        return ADDING_SUCCEEDED;
    }

    return ADDING_SUCCEEDED;
} // Add()


unsigned long ChainedList::Remove(void)
{
    Element *pDummy = m_pPtrToLastElement;

    pDummy = pDummy->m_pPrevElement;
    pDummy->m_pNextElement  = NULL;

    PTR_DELETE(m_pPtrToLastElement);
    m_pPtrToLastElement = pDummy;

    return REMOVING_SUCCEEDED;
} // Remove()


unsigned long ChainedList::Remove(unsigned long ElementID)
{
    if(ElementID > m_pPtrToLastElement->m_ID)
    { return ELEMENTID_OUT_OF_RANGE; }

    Element *pDummy = m_pPtrToFirstElement;

    while(pDummy->m_ID != ElementID)
    { pDummy = pDummy->m_pNextElement; }

    if(ElementID == 0)
    {
        m_pPtrToFirstElement->m_pNextElement->m_pPrevElement = NULL;
        m_pPtrToFirstElement = m_pPtrToFirstElement->m_pNextElement;

            // Sort the list

        SortList();

        return REMOVING_SUCCEEDED;
    }

        // Chain the elements correctly

    pDummy->m_pPrevElement->m_pNextElement = pDummy->m_pNextElement;
    pDummy->m_pNextElement->m_pPrevElement = pDummy->m_pPrevElement;

    PTR_DELETE(pDummy);

        // Sort the list

    SortList();

    return REMOVING_SUCCEEDED;
} // Remove()


unsigned long ChainedList::SortList(void)
{
    Element *pDummy = m_pPtrToFirstElement;
    unsigned long ID = 0;

    while(pDummy != NULL)
    {
        pDummy->m_ID = ID;
        ID++;

        pDummy = pDummy->m_pNextElement;
    }

    return SORTATION_SUCCEEDED;
} // SortList()


unsigned long ChainedList::ShowList(unsigned long StartFrom)
{
    Element *pCurElement = NULL;

    switch(StartFrom)
    {
    case FROM_FIRST:
        {
            if((pCurElement = m_pPtrToFirstElement) == NULL)
            { return THERE_ARE_NO_ELEMENTS; }

            while(pCurElement != NULL)
            {
                cout << "Element Nr. " << pCurElement->m_ID << endl;
                cout << "Wert: "<< pCurElement->m_Value << endl << endl;

                pCurElement = pCurElement->m_pNextElement;
            } // while(pCurElement != NULL)


            break;
        }
    case FROM_LAST:
        {
            if((pCurElement = m_pPtrToLastElement) == NULL)
            { return THERE_ARE_NO_ELEMENTS; }

            while(pCurElement != NULL)
            {
                cout << "Element Nr. " << pCurElement->m_ID << endl;
                cout << "Wert: " << pCurElement->m_Value << endl << endl;

                pCurElement = pCurElement->m_pPrevElement;
            } // while(pCurElement != NULL)


            break;
        }
    default: 
        return SHOWLIST_FAILED;
        break;
    } // switch(StartFrom)

    

    return SHOWLIST_SUCCEEDED;
} // ShowList()


unsigned long ChainedList::DeleteList(void)
{
    if(m_pPtrToFirstElement == NULL)
    { return THERE_IS_NO_LIST; }

    Element *pDeleteMe = m_pPtrToFirstElement;
    Element *pDummy = NULL;
    
    while(pDeleteMe != NULL)
    { 
        pDummy = pDeleteMe->m_pNextElement;
        PTR_DELETE(pDeleteMe);

        pDeleteMe = pDummy;
    } // while(pDeleteMe != NULL)

 
    m_pPtrToFirstElement    = NULL; // First

    m_pPtrToLastElement     = NULL; // Last


    return DELETION_SUCCEEDED;
} // DeleteList()
Am Anfang der Weisheit steht die eigene Erkenntnis, dass man selbst nichts weiß! - Sokrates

David_pb

Community-Fossil

Beiträge: 3 886

Beruf: 3D Graphics Programmer

  • Private Nachricht senden

29

11.03.2007, 15:05

Hi!

Was mir spontan einfällt:

:arrow: Initialisierungsliste nutzen
:arrow: Du könntest ein Sentinelitem verwenden, das verbrät zwar etwas mehr Speicher aber du sparst dir diverse Abfragen
:arrow: Eine Funktion braucht keinen Rückgabewert wenn er sowiso immer ADDING_SUCCEEDED ist (z.B. Add()).
:arrow: Ich weiß nicht was hinter PTR_DELETE steckt, aber ein einfaches delete tuts auch!
:arrow: Die Funktionen welche mit irgendwelches Element/PositionIDs arbeiten sind nicht gerade effizient. Man sollte eher Listeneinträge übergeben. Eine verlinkte Liste arbeitet nunmal nicht mit Indice.
:arrow: Destruktor wär sinnvoll
@D13_Dreinig

big_muff

Alter Hase

Beiträge: 460

Wohnort: Schweiz

Beruf: Informatikstudent (4. Semester)

  • Private Nachricht senden

30

11.03.2007, 15:12

Ich habs jetzt nur kurz überflogen:
1. SortList() ist als Name ein bisschen verwirrend
2. Ich weiss nicht wie du darauf kommst aber hör mal damit auf jeder Funktion einen Rückgabewert zu geben. Die Add()- oder die SortList()-Funktion können nicht fehlschlagen also kannst du dort den Rückgebewert doch weglassen. Genau so wenig interessiert es jemanden ob die Liste leer wahr wenn er DeleteList() aufruft. Dort kannst du dir den Rückgabewert doch sparen.
3. Der Sinn der Remove()-Funktion ohne Parameter bleibt mir verborgen...
4. Jetzt kann man ja nicht mal mehr irgendeinen Wert in der Liste speichern?
Nur Idioten halten Ordnung, ein Genie beherrscht das Chaos.[size=7]

[/size]HardFate - Ein Start, Ein Ziel, Viele Wege[size=7]

[/size]Ein Mitglied der VEGeiCoUndGraSonMaWiGeS Bewegung.

Werbeanzeige