Erreur avec mon programme

Question

Ok, j'ai le programme de files d'attente sur lequel j'ai travaillé et j'ai finalement compris la plupart de ce programme. Le problème que je suis maintenant est que chaque fois que je saisis des chiffres dans le clavier et que j'y accède, je reçois le même numéro. si j'entre 5 uns quand il va les ajouter ensemble, il dit que la réponse est 37 ce qui n'est pas correct. voici mon code à nouveau:

main.c

#include "queue.h" 

#define loop 5 
int main(){ 
    int i; 
    int* dataPtr; 
    int number; 
    int sum; 
    int average; 
    QUEUE* numbers; 
    numbers = createQueue(); 

    printf("Please enter the 10 numbers you want to know the sum and average of.\n"); 

    for (i = 0; i < loop; i++){ 
     printf("Number %d: ", i+1); 
     scanf("%d", &number); 
     *dataPtr = number; 
     enqueue(numbers, dataPtr); 
    } 
    for (i = 0; i < loop; i++){ 
     number = dequeue(numbers, (void*)&dataPtr); 
     sum += number; 
     enqueue(numbers, dataPtr); 
    } 
    average = sum/loop; 

    printf("\nSum: %d", sum); 
    printf("\nAverage: %d", average); 
    system("Pause"); 
    return 0; 

} 

queue.h

#include <stdio.h> 
#include <stdlib.h> 
#include <stdbool.h> 

//Queue ADT Type Definitions 
     typedef struct node{ 
       void* dataPtr; 
       struct node* next; 
     } QUEUE_NODE; 

     typedef struct{ 
       QUEUE_NODE* front; 
       QUEUE_NODE* rear; 
       int count; 
     } QUEUE; 

//Prototype Declarations  
     QUEUE* createQueue (void); 
     QUEUE* destroyQueue (QUEUE* queue); 

     bool dequeue  (QUEUE* queue, void** itemPtr); 
     bool enqueue  (QUEUE* queue, void* itemPtr); 
     bool queueFront  (QUEUE* queue, void** itemPtr); 
     bool queueRear  (QUEUE* queue, void** itemPtr); 
     int queueCount  (QUEUE* queue); 

     bool emptyQueue  (QUEUE* queue); 
     bool fullQueue  (QUEUE* queue); 
//End of Queue ADT definitions 

queue.c

#include <stdio.h> 
#include <stdlib.h> 
#include "queue.h" 
QUEUE* createQueue (void){ 
     QUEUE* queue; 

     queue = (QUEUE*) malloc (sizeof (queue)); 
     if (queue){ 
      queue->front = NULL; 
      queue->rear = NULL; 
      queue->count = 0; 
     } 
     return queue; 
} 

bool enqueue (QUEUE* queue, void* itemPtr){ 
    QUEUE_NODE* newPtr; 

    if(!(newPtr = (QUEUE_NODE*)malloc(sizeof(QUEUE_NODE)))) 
       return false; 

    newPtr->dataPtr = itemPtr; 
    newPtr->next  = NULL; 

    if (queue->count == 0) 
     queue->front = newPtr; 
    else 
     queue->rear->next = newPtr; 

    (queue->count)++; 
    queue->rear = newPtr; 
    return true; 
} 

bool dequeue (QUEUE* queue, void** itemPtr){ 
    QUEUE_NODE* deleteLoc; 

    if (!queue->count) 
     return false; 

    *itemPtr = queue->front->dataPtr; 
    deleteLoc = queue->front; 
    if(queue->count == 1) 
     queue->rear = queue->front = NULL; 
    else 
     queue->front = queue->front->next; 
    (queue->count)--; 
    free (deleteLoc); 

    return true; 
} 

bool queueFront (QUEUE* queue, void** itemPtr){ 
    if (!queue->count) 
     return false; 
    else{ 
      *itemPtr = queue->front->dataPtr; 
      return true; 
    } 
} 

bool queueRear (QUEUE* queue, void** itemPtr){ 
    if (!queue->count) 
     return true; 
    else{ 
      *itemPtr = queue->rear->dataPtr; 
      return false; 
    } 
} 

bool emptyQueue (QUEUE* queue){ 
    return (queue->count == 0); 
} 

bool fullQueue(QUEUE* queue){ 
    QUEUE_NODE* temp; 

    temp = (QUEUE_NODE*)malloc(sizeof(*(queue->rear))); 
    if (temp){ 
       free (temp); 
       return true; 
       } 
    return false; 
} 

int queueCount(QUEUE* queue){ 
    return queue->count; 
} 

QUEUE * destroyQueue (QUEUE* queue){ 
     QUEUE_NODE* deletePtr; 

     if (queue){ 
       while (queue->front != NULL){ 
         free (queue->front->dataPtr); 
         deletePtr = queue->front; 
         queue->front = queue->front->next; 
         free(deletePtr); 
       } 
       free (queue); 
     } 
     return NULL; 
} 

Je ne doivent pester tellement mais je suis essayer d'apprendre ce genre de choses

Answer 1

OK, il y a quelques problèmes ici.

Tout d'abord, dataPtr n'est jamais initialisé, donc *dataPtr pointe vers un emplacement aléatoire dans la mémoire et vous le définissez sur une valeur entière arbritaire. Ceci invoque un comportement indéfini (donc les démons nasaux sont une possibilité). Deuxièmement, vous devez allouer du nouveau stockage à chaque fois à travers la boucle, sinon vous finirez avec dix références au dernier numéro que vous avez lu.

Answer 2

Vous devez absolument utiliser un débogueur et regarder ce qui se passe lorsque vous parcourez votre programme. ddd est un excellent outil!

Answer 3

Votre fonction dequeue renvoie un booléen (qui, lorsqu'il est converti en un nombre, vaut 0 pour false et 1 pour true), ce qui fait que vous additionnez la mauvaise valeur.