Why can't I remove a person from an array? - c

Question

I've been sitting with this code for three days. The problem is that I have reached the rock bottom and I don't know how I will solve this without any help from you guys. I have a struct with arrays of type char name, surname, persnbr.
struct pers
{
char name[7];
char last_name[10];
char id_nbr[12];
};
I have solved the problem with adding name surname and persnbr in the arrays but now I don't know how to remove them.
This is the queueEn function
void queueEn(person p1){
strcpy(queue[last].name, p1.name);
strcpy(queue[last].last_name, p1.last_name);
strcpy(queue[last].id_nbr, p1.id_nbr);
}
and the queueAdd function
void queueAdd(person person1)
{
if(last<MAX_SIZE_QUEUE){
printf("Name: ");
scanf("%s", person1.name);
printf("Last name: ");
scanf("%s", person1.sur_name);
printf("Id-number: ");
scanf("%s", person1.id_nbr);
last++;
}else {
printf("Queue is full\n");
}
queueEn(person1);
}
This code works excellent.
Now I have the functions queueDe and queueRemove
This is what I've done so far:
void queueDe(person *personPoint){
first = (first + 1)% MAX_SIZE_QUEUE;
*personPoint = queue[first];
strcpy(personPoint->name, queue[first].name);
strcpy(personPoint->last_name, queue[first].last_name);
strcpy(personPoint->id_nbr, queue[first].id_nbr);
}
The thing is that I have to copy the information from array so I assumed that's how you do it. The information will be shown to the user(the person who is the last on the queue(FIFO-structure))
Here is the function remove_from_queue
void queueRemove(person personRem){
if(first < MAX_SIZE_QUEUE){
printf("Name: %s", personRem.name);
printf("Last Name: %s", personRem.last_name);
printf("Id-Number: %s", personRem.id_nbr);
first++;
}else{
printf("Queue is empty");
}
queueDe(&personRem);
}
The variables first and last are equivalent with the end of array and the beginning of array. To delete the last person in the array I have to delete the person on first. Both of the variables are initialized to 0 in the beginning. I've read that I need to initialize the pointer *personPoint to malloc but I don't know how to use it in this specific situation.
When I execute the program and want to delete the person nothing happens.
I'm thankful for an answer.

Answer 1

A circular queue is a reasonable data structure, but you need a clear grasp of your queue 'empty' and queue 'full' conditions. First we will define a circular queue struct, which holds first, last and queue[] array elements,
typedef struct circular_array_queue_s
{
person* queue[MAX_SIZE_QUEUE];
int first;
int last;
} CirQueue;
CirQueue cirq;
Now we can define functions to report whether the queue is empty, full, and to report the count of the number of elements,
int queueEmpty()
{
if( cirq.first == cirq.last ) //queue empty
{
printf("Queue is empty");
return 1;
}
return 0;
}
int queueFull()
{
if( ((cirq.last+1%MAX_SIZE_QUEUE)) == cirq.first ) //queue full
{
printf("Queue is full\n");
return 1;
}
return 0;
}
int queueCount()
{
int count=0;
if( cirq.first<=cirq.last )
count=(cirq.last-cirq.first);
else //if ( cirq.first>cirq.last )
count=(cirq.last+MAX_SIZE_QUEUE)-cirq.first;
return count;
}
The queue operations for enqueue and dequeue are simplified, as you enqueue at the queue last position, and dequeue from the queue first position. Since you have a circular queue, moving the first and last indices is done by incrementing by one, and wrapping at the end (using modulus MAX_SIZE_QUEUE),
person*
queueEn(person* p)
{
//err
if( queueFull() ) { return NULL; } //queue full, fail
cirq.queue[cirq.last] = p;
cirq.last = (cirq.last+1)%MAX_SIZE_QUEUE; //one
return p;
}
person*
queueDe()
{
person* p;
//err
if( queueEmpty() ) { return NULL; } //queue empty, fail
p = cirq.queue[cirq.first];
cirq.queue[cirq.first] = NULL;
cirq.first = (cirq.first+1)%MAX_SIZE_QUEUE;
return p;
}
Walking (iterating) over the entire can be done using a function similar to,
person*
queueIterate()
{
person* p;
int iter;
if( queueEmpty() ) { return NULL; } //queue empty, skip
for( iter=cirq.first; iter!=cirq.last; iter=(++iter)%MAX_SIZE_QUEUE )
{
personPrint(p = cirq.queue[iter]);
}
return p;
}
Adding elements to the queue requires that you create elements to add (malloc), and properly dispose of elements when you remove them (free),
void queueAdd(person person1)
{
if( queueFull() ) { return; } //queue full, cannot add
personRead(&person1);
person* p;
queueEn(personCopy(p=personNew(),&person1));
}
person*
queueRemove(person* personRem)
{
person* p;
if(p = queueDe())
{
if(personRem) {
personCopy(personRem,p); personDel(p);
}
//if you don't give a personRem, you must free person p removed from queue
else
personRem=p;
}
return personRem;
}
You want to test these queue functions,
int
main()
{
person per;
person* perp;
int done=0;
while(!done)
{
queueAdd(per);
if( queueFull() ) done=1;
if( queueCount() >= 3 ) done=1; //just do three
}
queueIterate();
while(!queueEmpty())
{
personPrint(perp=queueRemove(&per));
}
}
Please understand that C strings are null-terminated, so declaring your char[] using an N+1 idiom will clearly communicate the available string size,
typedef struct person_s
{
char name[9+1]; //size to N+1, makes clear the space, "Alexander"(9)
char last_name[10+1]; //room for null-terminator
char id_nbr[12+1]; //you really want to room for null-terminator
} person;
You will find that having functions which encapsulate your member access can make your code more readable, and support a DRY (Dont Repeat Yourself) approach, and hide details which you probably do not want to expose and handle everywhere,
person*
personNew()
{
person* pnew;
if( !(pnew=malloc(sizeof(person))) ) return NULL;
strncpy(pnew->name, ">name", sizeof(pnew->name));
strncpy(pnew->last_name, ">last_name", sizeof(pnew->last_name));
strncpy(pnew->id_nbr, ">id_nbr", sizeof(pnew->id_nbr));
return(pnew);
}
void personDel(person* p)
{
if( !p ) return; //fail, must have valid pointer
free(p);
return;
}
person*
personCopy(person* pd, person* ps)
{
if(!pd || !ps) return;
strncpy(pd->name, ps->name, sizeof(pd->name));
strncpy(pd->last_name, ps->last_name, sizeof(pd->last_name));
strncpy(pd->id_nbr, ps->id_nbr, sizeof(pd->id_nbr));
return(pd);
}
Here are functions to set the member values (often called setters or mutators),
person*
personName(person* p1, char* name)
{
if(!p1 || !name) return p1;
strncpy(p1->name, name, sizeof(p1->name));
return(p1);
}
person*
personLastName(person* p1, char* last_name)
{
if(!p1 || !last_name) return p1;
strncpy(p1->last_name, last_name, sizeof(p1->last_name));
return(p1);
}
person*
personIdNbr(person* p1, char* id_nbr)
{
if(!p1 || !id_nbr) return p1;
strncpy(p1->id_nbr, id_nbr, sizeof(p1->id_nbr));
return(p1);
}
And here are functions to read and print your person struct,
person*
personRead(person* personp) //two
{
if(!personp) return personp;
//you really should allow for more space here
char name[99+1];
char last_name[99+1];
char id_nbr[99+1];
printf("Name: "); scanf("%s", name);
printf("Last name: "); scanf("%s", last_name);
printf("Id-number: "); scanf("%s", id_nbr);
personName(personp,name);
personLastName(personp,last_name);
personIdNbr(personp,id_nbr);
return(personp);
}
void personPrint(person* personp) //five
{
if(!personp) return personp;
printf("Name: %s,", personp->name);
printf("Last Name: %s,", personp->last_name);
printf("Id-Number: %s\n", personp->id_nbr);
}
Note that I used malloc/free and person (pointer to person struct) throughout. You need to learn about pointers if you want to program in C.*