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!

C | While: Wann wird eine Bedingung geprüft?

  • 1
  • 2

Werbeanzeige

Julién

Alter Hase

  • »Julién« ist der Autor dieses Themas

Beiträge: 717

Wohnort: Bayreuth

Beruf: Student | Hilfswissenschaftler in der Robotik

  • Private Nachricht senden

1

13.04.2016, 21:12

C | While: Wann wird eine Bedingung geprüft?

Hi,
ich habe noch mal ein bisschen an dem Warteschlangen-Code vom letzten Bespiel herumgespielt
und setze nun statt auf Rekursion auf Iteration.

Alles funktioniert bis auf eine Funktion "destroyQueue":

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12

void        destroyQueue(cw_Queue_t* pQueue){
    assert(0 != pQueue);

    while(NULL != pQueue->pFrontNode){
        i_Node_t* pTemp = pQueue->pFrontNode->pNextNode;
        free(pQueue->pFrontNode);
        pQueue->pFrontNode = pTemp;
    }

    pQueue->pRearNode = NULL;
    free(pQueue);
}


Dies führt bei mir zur Zeit zu einer Endlosschleife bzw. wenn ich ein 'printf' - innerhalb der Schleife - einfüge, führt mein Programm zu einer Zugriffsverletzung.

Ich habe nun innerhalb der Schleife nochmal einen Bedingung eingebaut:

C-/C++-Quelltext

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

void        destroyQueue(cw_Queue_t* pQueue){
    assert(0 != pQueue);

    while(NULL != pQueue->pFrontNode){

        if(NULL != pQueue->pFrontNode){
            printf("W00T. Something is NULL!\n");
            break;
        }
        
        i_Node_t* pTemp = pQueue->pFrontNode->pNextNode;
        free(pQueue->pFrontNode);
        pQueue->pFrontNode = pTemp;
    }

    pQueue->pRearNode = NULL;
    free(pQueue);
}


Tatsächlich springt das 'if'-Statement an und das Test-Program, funktioniert tadellos. Mich verwundert das, denn
ich bin eigentlich davon ausgegangen, dass die Bedingung zu Beginn geprüft wird,
so dass kein weiteres 'if'-Statement nötig wäre.

Wann wird eine Bedingung einer 'while'-Schleife nun geprüft?

LG Julien
I write my own game engines because if I'm going to live in buggy crappy filth, I want it to me my own - Ron Gilbert

Nimelrian

Alter Hase

Beiträge: 1 216

Beruf: Softwareentwickler (aktuell Web/Node); Freiberuflicher Google Proxy

  • Private Nachricht senden

2

13.04.2016, 21:18

Beim Eintritt in die Schleife. Nutze den Debugger, der dürfte hier helfen.
Ich bin kein UserSideGoogleProxy. Und nein, dieses Forum ist kein UserSideGoogleProxyAbstractFactorySingleton.

Julién

Alter Hase

  • »Julién« ist der Autor dieses Themas

Beiträge: 717

Wohnort: Bayreuth

Beruf: Student | Hilfswissenschaftler in der Robotik

  • Private Nachricht senden

3

13.04.2016, 21:23

Zitat von »Nimelrian«

Beim Eintritt in die Schleife.


Heißt das, dass die Schleife NUR EINMAL die Bedingung prüft?!

Zitat von »Nimelrian«

Nutze den Debugger, der dürfte hier helfen.

Ich muss gerade auf MinGW setzen und kenne mich mit GDB nicht aus. Ich werde noch ein wenig Zeit brauchen,
bis ich mich da eingearbeitet habe.
I write my own game engines because if I'm going to live in buggy crappy filth, I want it to me my own - Ron Gilbert

anti-freak

Alter Hase

Beiträge: 635

  • Private Nachricht senden

4

13.04.2016, 21:23

Zitat von »Julién«


C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9

    while(NULL != pQueue->pFrontNode){

        if(NULL != pQueue->pFrontNode){   // warum sollte die Bedingung nicht zutreffen, wenn sie gleich der while Schleife ist?
            //...
        }
        
        //...
    }
}


Denk am Besten nochmal genau drüber nach :D

Julién

Alter Hase

  • »Julién« ist der Autor dieses Themas

Beiträge: 717

Wohnort: Bayreuth

Beruf: Student | Hilfswissenschaftler in der Robotik

  • Private Nachricht senden

5

13.04.2016, 21:27

Das ist ja die Sache. Sie trifft nicht zu, obwohl die while Schleife zutrifft.
I write my own game engines because if I'm going to live in buggy crappy filth, I want it to me my own - Ron Gilbert

anti-freak

Alter Hase

Beiträge: 635

  • Private Nachricht senden

6

13.04.2016, 21:29

Zitat von »Julién«

Das ist ja die Sache. Sie trifft nicht zu, obwohl die while Schleife zutrifft.

Wenn du sagst, dass dein printf ausgegeben wird, dann wird sie wohl zutreffen. Oder du musst dich mal etwas genauer ausdrücken.
Vom code her sehe ich eine schleife die betreten wird, danach ein if Statement das true ist, dann eine Ausgabe und danach wird die Schleife verlassen.

Julién

Alter Hase

  • »Julién« ist der Autor dieses Themas

Beiträge: 717

Wohnort: Bayreuth

Beruf: Student | Hilfswissenschaftler in der Robotik

  • Private Nachricht senden

7

13.04.2016, 21:33

Oh Sorry, ich habe mich vertippt beim abtippen.

C-/C++-Quelltext

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

void        destroyQueue(cw_Queue_t* pQueue){
    assert(0 != pQueue);

    while(NULL != pQueue->pFrontNode){

        if(NULL == pQueue->pFrontNode)
            break;
        

        i_Node_t* pTemp = pQueue->pFrontNode->pNextNode;
        free(pQueue->pFrontNode);
        pQueue->pFrontNode = pTemp;
    }

    printf("Gotta out of here.\n");

    pQueue->pRearNode = NULL;
    free(pQueue);
}


Mich verwirrt das Programm, zugegebenermaßen.
I write my own game engines because if I'm going to live in buggy crappy filth, I want it to me my own - Ron Gilbert

Julién

Alter Hase

  • »Julién« ist der Autor dieses Themas

Beiträge: 717

Wohnort: Bayreuth

Beruf: Student | Hilfswissenschaftler in der Robotik

  • Private Nachricht senden

8

13.04.2016, 21:48

Ich ziehe langsam in betracht, dass der Fehler in anderen Teilen des Programms liegen kann.
Deshalb poste ich den kompletten Code nochmal.

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

#include <Util/Queue.h>

#include <assert.h>
#include <stdlib.h>

//------------------------------------------------------------------------------
// IMPLEMENTATION DETAILS

typedef struct i_Node{
    void*           pData;
    struct i_Node*  pNextNode;
} i_Node_t;

struct cw_Queue{
    i_Node_t*   pFrontNode;
    i_Node_t*   pRearNode;
};

//------------------------------------------------------------------------------
// PUBLIC IMPLEMENTATION

cw_Queue_t* createQueue(){

    cw_Queue_t* pQueue  = malloc(sizeof(cw_Queue_t));
    pQueue->pFrontNode  = NULL;
    pQueue->pRearNode   = NULL;

    return pQueue;
}

void        destroyQueue(cw_Queue_t* pQueue){
    assert(0 != pQueue);

    while(NULL != pQueue->pFrontNode){

        if(NULL == pQueue->pFrontNode){
            break;
        }

        i_Node_t* pTemp = pQueue->pFrontNode->pNextNode;
        free(pQueue->pFrontNode);
        pQueue->pFrontNode = pTemp;
    }

    pQueue->pRearNode = NULL;
    free(pQueue);
}

void        enqueue(cw_Queue_t* pQueue, void* pData){
    assert(0 != pQueue);

    i_Node_t*   pNode   = malloc(sizeof(i_Node_t));
    pNode->pData        = pData;
    pNode->pNextNode    = NULL;

    if((NULL == pQueue->pFrontNode) && (NULL == pQueue->pRearNode)){
        pQueue->pFrontNode = pQueue->pRearNode = pNode;
        return;
    }

    pQueue->pRearNode->pNextNode    = pNode;
    pQueue->pRearNode               = pNode;
}

void*       dequeue(cw_Queue_t* pQueue){
    assert(0 != pQueue);

    if((NULL == pQueue->pFrontNode) && (NULL == pQueue->pRearNode))
        return 0;

    if(pQueue->pFrontNode == pQueue->pRearNode){
        void*   pData   = pQueue->pFrontNode->pData;

        free(pQueue->pFrontNode);
        pQueue->pFrontNode  = pQueue->pRearNode = NULL;

        return pData;
    }

    i_Node_t*   pTemp   = pQueue->pFrontNode->pNextNode;
    pQueue->pFrontNode  = pQueue->pFrontNode->pNextNode;
    void*       pData   = pTemp->pData;
    free(pTemp);
    return      pData;
}


EDIT:
Die Endlosschleife tritt dennoch bei 'destroyQueue' ein!
I write my own game engines because if I'm going to live in buggy crappy filth, I want it to me my own - Ron Gilbert

Nimelrian

Alter Hase

Beiträge: 1 216

Beruf: Softwareentwickler (aktuell Web/Node); Freiberuflicher Google Proxy

  • Private Nachricht senden

9

13.04.2016, 22:07

Zitat von »Julién«

Ich muss gerade auf MinGW setzen und kenne mich mit GDB nicht aus.

Wieso? Ansonsten benutz Code::Blocks und arbeite da mit dem Debugger. Der setzt auf GDB auf und gibt dir dennoch ein ordentliches UI.
Ich bin kein UserSideGoogleProxy. Und nein, dieses Forum ist kein UserSideGoogleProxyAbstractFactorySingleton.

BlueCobold

Community-Fossil

Beiträge: 10 738

Beruf: Teamleiter Mobile Applikationen & Senior Software Engineer

  • Private Nachricht senden

10

13.04.2016, 22:14

Zeile 36 beim letzten Code kann nie erfüllt werden.
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]

Werbeanzeige

  • 1
  • 2

Ähnliche Themen