Uppgift i C

#include <stdio.h>
#include "queue.h"

int main(){

do{
show_menu();
run_selection(get_selection());
}while(pause());
return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "queue.h"

/* Pausar och väntar på att användaren skall trycka på enter för att
ge användaren mer förståelse i vad som händer */
int pause(){
int c;
printf("\n Tryck enter för att fortsätta!");
/* Tömmer inmatningsströmmen */
while((c = getchar()) != '\n' && c != EOF);
getchar();
return 1;
}

/* Tömmer skärmen på text (skriver egentligen ut ett antal tomma rader) och skriver ut menyn åt användaren */
void show_menu(){
/*Tömmer skärmen*/
printf("\033[2J");

/*Skriver ut menyn för användaren.*/
printf ("\n**** Meny ****\n");
printf ("1. Lägg till personer i kön\n");
printf ("2. Ta bort personer ur kön\n");
printf ("3. Skriv ut kön\n");
printf ("4. Avsluta\n\n");
}


/* Ber användaren skriva in ett val mellan 1 och 4 och returnerar sedan detta till nästa funktion som anropat get_selection */
int get_selection(){

int val;
printf(" Ange ett alternativ 1-4: ");
scanf("%d", &val);
return val;
}

/* Kör den funktion som användaren valt */
void run_selection(int selection){
printf("\n");
switch (selection){
case 1:
add_to_queue();
break;

case 2:
remove_from_queue();
break;

case 3:
print_queue();
break;

case 4:
exit(0);
break;

default:
printf( "Ogiltigt val! Tryck enter och välj ett alternativ mellan 1-4" );
break;
}
}


/* Lägger till en person i kön */
void add_to_queue(){

int data;
printf("\nSkriv in:");
scanf("%d", data);
enqueue(data);
}


/* Tar bort en person ur kön */
void remove_from_queue(){

int data;
printf("\nTar bort den första");
dequeue(*data);
}


void delete_from_queue(){

int data;
printf("\nVad ska tas bort?");
scanf("%d", data);
delete(*data);

}

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

typedef struct node {
int data;
struct node *next;
} node;

typedef struct {
struct node *first;
struct node *last;
} queue_c;

static queue_c queueref;

//Funktionsprototyper
#include "queue.h"
static int destroy_node(node node_ref);
static node *create_node(int data);

int enqueue(int data)
{
node *new_node, *last_node;
int result = 0;

new_node = create_node(data);
if(new_node != NULL){
if(queueref.first != NULL){
queueref.first = new_node;
queueref.last = new_node;
}
else{
queueref.last->next = new_node;
queueref.last = new_node;
}

result = 1;
}

return result;
}

static node *create_node(int data)
{
node *noderef;
noderef = (node*) malloc(sizeof(node));
noderef->data = data;
noderef->next = NULL;

return noderef;
}

int dequeue(int *data)
{
node *first_node;
int result = 0;

if(queueref.first != NULL){
first_node = queueref.first;
data = (int*) queueref.first->data;

queueref.first = first_node->next;

result = destroy_node(first_node);
}

return result;
}

static int destroy_node(node *node_ref)
{
free(node_ref);
return node_ref == NULL;
}

void print_queue()
{
node *curr_ptr = queueref.first;

if(curr_ptr != NULL){
while(curr_ptr != NULL){
printf("%d -> ", curr_ptr->data);
curr_ptr = curr_ptr->next;
}
}
else{
printf("Kön är tom!");
}
}

int delete(int data)
{
int result = 0;

node *curr_ptr;
node *prev_ptr;
node *temp_ptr;

if(queueref.first == NULL){
printf("Kön är tom!");
}
else if(queueref.first->data == data){
temp_ptr = queueref.first;
queueref.first = queueref.first->next;
result = destroy_node(temp_ptr);
}
else{
prev_ptr = queueref.first;
curr_ptr = queueref.first->next;

while(curr_ptr != NULL){
if(curr_ptr->data == data){
result = 1;
break;
}

prev_ptr = curr_ptr;
curr_ptr = curr_ptr->next;
}

if(result){
temp_ptr = curr_ptr;
prev_ptr->next = temp_ptr->next;
result = destroy_node(temp_ptr);
}
else{
printf("Ingen node innehöll talet: %d", data);
}
}

return result;
}

int enqueue(int data);
int dequeue(int *data);
void print_queue();
int delete(int data);

void show_menu();
int get_selection();
void run_selection(int selection);
void add_to_queue();
void remove_from_queue();
void delete_from_queue();
int pause();

queue.c: In function ‘enqueue’:
queue.c:35:22: warning: unused variable ‘last_node’ [-Wunused-variable]
queue.c: In function ‘dequeue’:
queue.c:76:9: error: incompatible type for argument 1 of ‘destroy_node’
queue.c:30:12: note: expected ‘node’ but argument is of type ‘struct node *’
queue.c: At top level:
queue.c:82:12: error: conflicting types for ‘destroy_node’
queue.c:30:12: note: previous declaration of ‘destroy_node’ was here
queue.c:30:12: warning: ‘destroy_node’ used but never defined [enabled by default]
menu.c: In function ‘add_to_queue’:
menu.c:84:3: warning: format ‘%d’ expects argument of type ‘int *’, but argument 2 has type ‘int’ [-Wformat]
menu.c: In function ‘remove_from_queue’:
menu.c:94:11: error: invalid type argument of unary ‘*’ (have ‘int’)
menu.c: In function ‘delete_from_queue’:
menu.c:102:2: warning: format ‘%d’ expects argument of type ‘int *’, but argument 2 has type ‘int’ [-Wformat]
menu.c:103:9: error: invalid type argument of unary ‘*’ (have ‘int’)

queue.c: In function ‘enqueue’:
queue.c:35:22: warning: unused variable ‘last_node’ [-Wunused-variable]

queue.c: In function ‘dequeue’:
queue.c:76:9: error: incompatible type for argument 1 of ‘destroy_node’
queue.c:30:12: note: expected ‘node’ but argument is of type ‘struct node *’

...samt...

queue.c: At top level:
queue.c:82:12: error: conflicting types for ‘destroy_node’
queue.c:30:12: note: previous declaration of ‘destroy_node’ was here
queue.c:30:12: warning: ‘destroy_node’ used but never defined [enabled by default]

menu.c: In function ‘add_to_queue’:
menu.c:84:3: warning: format ‘%d’ expects argument of type ‘int *’, but argument 2 has type ‘int’ [-Wformat]

menu.c: In function ‘remove_from_queue’:
menu.c:94:11: error: invalid type argument of unary ‘*’ (have ‘int’)

menu.c: In function ‘delete_from_queue’:
menu.c:102:2: warning: format ‘%d’ expects argument of type ‘int *’, but argument 2 has type ‘int’ [-Wformat]

...samt...

menu.c:103:9: error: invalid type argument of unary ‘*’ (have ‘int’)