Выполняя операцию удаления в следующем коде, я не могу получить правильные значения, возвращаемые в следующем коде.

Question

Невозможно напечатать правильные значения удаленных элементов из очереди. DeQueue() используется для удаления элементов. Я использовал метод реализации динамического кругового массива для QUEUE, т. Е. Удвоение памяти при заполнении QUEUE. Первый элемент, возвращенный в процессе удаления, является правильным, но после этого, если удаление выполняется снова, тогда возвращаются случайные значения.

#include <iostream> 
#include <cstdlib> 
#include <math.h> 

using namespace std; 

struct DynArrayQueue{ 
    int front, rear; 
    int capacity; 
    int* array; 
}; 

void ResizeQueue(struct DynArrayQueue* Q); 

struct DynArrayQueue* CreateDynQueue(){ 

    struct DynArrayQueue* Q = (struct DynArrayQueue*)malloc(sizeof(struct DynArrayQueue)); 

    if(!Q) 
    { 
     cout << "Memory Error in allocation!\n"; 
     return NULL; 
    } 

    Q->capacity = 1; 
    Q->front = Q->rear = -1; 
    Q->array = (int*)malloc(Q->capacity * sizeof(int)); 

    if(!Q->array) 
    { 
     cout << "Memory error in creating queue!\n"; 
     return NULL; 
    } 

    return Q; 
} 

int IsEmptyQueue(struct DynArrayQueue* Q){ 
    if(Q->front == -1){ 
     cout << "Queue is empty!\n"; 
     return 1; 
    } 
    else{ 
     cout << "Queue not empty\n"; 
     return 0; 
    } 
} 

int IsFullQueue(struct DynArrayQueue* Q){ 
    if((((Q->rear)+1)%Q->capacity) == Q->front) 
    { 
     cout << "Queue is full!\n"; 
     return 1; 
    }else{ 
     cout << "Queue not full!\n"; 
     return 0; 
    } 
} 

void QueueSize(struct DynArrayQueue* Q){ 
    int s; 
    s = (Q->capacity - Q->front + Q->rear + 1) % Q->capacity; 
    cout << "Size of the queue is " << s; 
    cout << "\n\n"; 
} 

void EnQueue(struct DynArrayQueue* Q){ 
    int data; 
    cout << "Enter the data to be inserted:\n"; 
    cin >> data; 
    if(IsFullQueue(Q)) 
     { 
      ResizeQueue(Q); 
     } 
    Q->rear = (Q->rear + 1)%Q->capacity; 
    Q->array[Q->rear] = data; 
    if(Q->front == -1) 
    { 
     Q->front = Q->rear; 
    } 
} 

void ResizeQueue(struct DynArrayQueue* Q){ 
    int size = Q->capacity; 
    Q->capacity = Q->capacity * 2; 
    Q->array = (int*)realloc(Q->array, Q->capacity); 
    if(!Q->array) 
      cout << "Memory error!\n"; 
    if(Q->front > Q->rear) 
    { 
     for(int i = 0; i < Q->front; i++) 
     { 
      Q->array[i+size] = Q->array[i]; 
     } 
     Q->rear = Q->rear + size; 
    } 
} 

void DeQueue(struct DynArrayQueue* Q){ **this function does not work properly** 
    int data = 0; 
    if(IsEmptyQueue(Q)) 
    { 
     cout << "Queue Underflow!\n"; 
     cout << "No element to delete!\n"; 
    } 
    else{ 
     data = Q->array[Q->front]; 
     if(Q->front == Q->rear) 
     { 
      Q->front = Q->rear = -1; 
     } 
     else 
     { 
      Q->front = ((Q->front) + 1) % Q->capacity; 
     } 
    } 
    cout << "Element deleted is " << data; 
    cout << "\n"; 
} 

void DeleteQueue(struct DynArrayQueue* Q){ 
    if(Q){ 
     if(Q->array) 
     { 
      free(Q->array); 
     } 
     free(Q); 
    } 
} 

int main() 
{ 
    int choice; 
    struct DynArrayQueue* Q1; 
    while(1) 
    { 
     cout << "1. Press to create a Queue:\n"; 
     cout << "2. Enter an element in the queue:\n"; 
     cout << "3. Delete an element from the queue:\n"; 
     cout << "4. Press to know the Queue size:\n"; 
     cout << "5. Press to know if Queue is full:\n"; 
     cout << "6. Press to know if Queue is empty:\n"; 
     cout << "7. Press enter to exit:\n"; 
     cout << "Enter your choice:\n"; 
     cin >> choice; 
     switch(choice) 
     { 
     case 1: 
      Q1 = CreateDynQueue(); 
      break; 
     case 2: 
      EnQueue(Q1); 
      break; 
     case 3: 
      DeQueue(Q1); 
      break; 
     case 4: 
      QueueSize(Q1); 
      break; 
     case 5: 
      IsFullQueue(Q1); 
      break; 
     case 6: 
      IsEmptyQueue(Q1); 
      break; 
     case 7: 
      exit(0); 
      break; 
     default: 
      cout << "Wrong choice entered!\n"; 
      break; 
     } 
    } 
    DeleteQueue(Q1); 
} 

Answer 1

Проблема не в DeleteQueue, он находится в ResizeQueue. Когда вы вызываете realloc, вы передаете новое количество элементов, но не факторизуете размер элементов (например, когда вы первоначально выделяете пространство). Это должно быть

Q->array = (int*)realloc(Q->array, Q->capacity * sizeof(int)); 

Answer 2

Проблема в ResizeQueue().

Заявление

Q->array = (int*)realloc(Q->array, Q->capacity); 

не выделяет нужного размера. Последующие операции (до следующего DeleteQueue()), то с радостью предположим, что массив длиннее, чем он есть, и пишите мимо конца.

Кроме того, если realloc() не работает, он возвращает NULL и не выпускает старую память. Результатом этого назначения является утечка памяти (поскольку старое значение Q->array потеряно для вашей программы).

Что вы на самом деле нужно сделать (как минимум) является

int *temp = (int*)realloc(Q->array, Q->capacity * sizeof(int)); 
if (!temp) 
    cout << "Memory error!\n"; 
else 
    Q->array = temp; 

Даже то, что не является достаточным, поскольку последующий код использует Q->array и предполагает изменение размеров удалось. Если произошел сбой, результатом является неопределенное поведение. Я оставлю эту проблему должным образом в качестве учебного упражнения.

Кроме того, на C++ рассмотрите использование стандартных контейнеров (например, std::vector<int>), которые могут изменяться самостоятельно, чтобы вы могли избежать глупости, например, выделяя неправильные объемы памяти.