Thread: FIFO Queue

Originally Posted by gajya

@Salem I think I have done

Code:

#include<stdio.h>  
#include<stdlib.h> 
      
struct Queue {
  int data[10];
  int front;
  int back;
};
 
 
void queueInit(struct Queue *q)  // Initialise
{
    (*q).data[0] = 0;
    (*q).front = 0;
    (*q).back = 0;     
} 
 
 
void queueEnqueue(struct Queue *q, int data)  // enqueue a value
{
    (*q).data[0] = data;   // add 1 into queue 
    (*q).front = 0;
    (*q).back = 0;     
}
  
int main() 
{ 


  struct Queue q;
  queueInit(&q); 
  queueEnqueue(&q, 1);  // enqueue a value
  
    
  return 0; 
}

Now I need help in enqueue

Okay, but ...

First, let's talk about notation:

Code:

    (*q).data[0] = data;
 
    q->data[0] = data;

Those two lines ^^ mean exactly the same thing.

In C, the -> operator was created specifically to create a shorthand for (*pointer).member expressions. In much the same way that the ++ and -- operators were created as a shorthand for x = x + 1. They're the same under the hood.

So, first of all, you wrote a completely valid expression, and that statement is totally correct.

But, second of all, the "idiomatic" way to write that is to use the -> operator, and every C programmer (including me) is going to read that, wince, and go "okay, but ..."

Next, let's talk about "meanings." You have a queue of your own data type. How do you know when the queue is empty? How do you know when the queue is not empty? How do you know how many values are in the queue? Also, how do you handle an error? If the queue has 10 values in it and I call enqueue, what will happen? If the queue has no values in it and I call dequeue, what will happen?

(This is not a trick question: these are normal conditions that can be expected to occur. The designer of the library, which in this case is YOU has to make the rules for this. So... what are the rules?)

Now here are some more questions. Given this code:

Code:

    typedef struct Queue Queue;
    
    extern bool    q_is_empty(Queue *);
    extern size_t  q_length(Queue *);
    extern error_t q_enqueue(Queue *, value_t data);

    struct Queue * q = &(struct Queue){ .data = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, .front=0, .back=0 };

    printf("%s\n", q_is_empty(q) ? "empy" : "not empty");   // what does this print?

    printf("%d\n", q_length(q)); // what does this print?

    printf("%d\n", q_enqueue(q, (value_t){0})); // what does this print?

    // what does the q structure look like after that last call to enqueue?

What do the statements print, and what are the new values in the queue structure? (This is all about you making decisions, and understanding how these things are going to be used.)


[/code]

Originally Posted by Salem

> ShowEnqueue(struct Queue &q)

> gajya, Join Date Nov 2019
18 months is a long time to be stuck on the first page of the book.

There was some misunderstanding

Code:

#include<stdio.h>

#define CAPACITY  5
#define  True  1
          
struct Queue {
  int data[CAPACITY];
  int front;
  int back;
  int size;
};
     
     
void queueInit(struct Queue *q)  // Initialise
{
    q->data[0] = 0;
    q->front = 0;
    q->back = 0;     
    q->size = 0;
} 
     
 int queueIsEmpty(struct Queue *q) // is it empty?
 {
     return q->size == 0 ;
 }
     
  int queueIsFull(struct Queue *q)  // is it Full?
 {
     return q->size == CAPACITY; 
 }
void queueEnqueue(struct Queue *q, int data)  // enqueue a value
{
    if (!queueIsFull(q))  // it's not full
    {
         q->data[q->front] = data; // store at the front of the queue
         q->front++; // move to next free slot
         q->size++;  // and count the number added
		 
    }
}


void ShowEnqueue(struct Queue *q)  // print enqueue a value
{
	int i = 0;
	
	for ( i = 0; i < 5; i++)
	{
		
		printf(" %d", *(q->data + i));
		q->data + i;
	}
}
int main ()
{
	 struct Queue q;
     queueInit(&q); 
     queueEnqueue(&q, 11);  // enqueue a value
	 queueEnqueue(&q, 12);  // enqueue a value
	 queueEnqueue(&q, 13);  // enqueue a value
	 queueEnqueue(&q, 14);  // enqueue a value	 
	 queueEnqueue(&q, 15);  // enqueue a value
	 
	 ShowEnqueue( &q);  // print enqueue a value


	return 0;
}

result
11 12 13 14 15

I have spent enough time to solve problem but program doesn't give expected output

Code:

#include<stdio.h> 
#define CAPACITY  5
#define  True  1
           
struct Queue {
  int data[CAPACITY];
  int front;
  int back;
  int size;
};
      
      
void queueInit(struct Queue *q)  // Initialise
{
    q->data[0] = 0;
    q->front = 0;
    q->back = 0;     
    q->size = 0;
} 
      
 int queueIsEmpty(struct Queue *q) // is it empty?
 {
     return q->size == 0 ;
 }
      
  int queueIsFull(struct Queue *q)  // is it Full?
 {
     return q->size == CAPACITY; 
 }
void queueEnqueue(struct Queue *q, int data)  // enqueue a value
{
    if (!queueIsFull(q))  // it's not full
    {
         q->data[q->front] = data; // store at the front of the queue
         q->front++; // move to next free slot
         q->size++;  // and count the number added
          
    }
}


void queueDequeue(struct Queue *q, int data)  // enqueue a value
{
    if (queueIsFull(q))  // it's not full
    {
         q->data[q->back] = data; // store at the back of the queue
         q->back++; // move to next free slot
         q->size++;  // and count the number added
          
    }
}
  
 
void ShowEnqueue(struct Queue *q)  // print enqueue a value
{
    int i = 0;
     
    for ( i = 0; i < 5; i++)
    {
         
        printf(" %d", *(q->data + i));
        q->data + i;
    }
}
int main ()
{
     struct Queue q;
     queueInit(&q); 
     queueEnqueue(&q, 11);  // enqueue a value
     queueEnqueue(&q, 12);  // enqueue a value
     queueEnqueue(&q, 13);  // enqueue a value
     queueEnqueue(&q, 14);  // enqueue a value   
     queueEnqueue(&q, 15);  // enqueue a value
      
     ShowEnqueue( &q);  // print enqueue a value
	 queueDequeue(&q, 16);  // enqueue a value
	 printf("\n");
	 ShowEnqueue( &q);  // print enqueue a value
 
 
    return 0;
}

Program output
11 12 13 14 15
16 12 13 14 15

expected output
11 12 13 14 15
16 15 14 13 12

Why does dequeue care if the quque is full or not?