Abstract Data Types / void * implementation

[cngata]

Here is my code:

myheader.h

#ifndef MYHEADER_H
#define MYHEADER_H
#define EMPTY_TOS -1
#define MIN_STACK_SIZE 5
#define FALSE 0
#define TRUE 1

struct Node;
typedef struct Node *Stack;


void *PopStack(Stack);
void *TopOfStack(Stack);
void PushStack(void *val, Stack); 
int IsEmptyStack(Stack);
int IsFullStack(Stack);

#endif 

myheader.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "myheader.h"

#define EMPTY_TOS -1 
#define MIN_STACK_SIZE 5
#define FALSE 0
#define TRUE 1

struct Node
{
	void *val; 
	struct Node *next;
};

void PushStack(void *x, Stack s)
{
	struct Node *insert;

	insert = (struct Node *) malloc(sizeof(struct Node));
	
	if (insert == NULL)
	       printf("Out of memory space!\n");
	else
	{
		   insert->val = x;
		   insert->next= s->next;
		   s->next = insert;
	}

}

void *PopStack(Stack s)
{
	struct Node *remove;
	void *val;
	
    if (IsEmptyStack(s))
           printf("The stack is empty!\n");
	else
	{
           remove = s->next;
           val=s->next->val;
		   s->next = s->next->next;

		   free(remove);
	}
    return val;
}

void *TopOfStack(Stack s)
{
	if (!IsEmptyStack(s))
		   return s->next->val;
    else
    {
           printf("The stack is empty\n");
           return 0;
    }

}

int IsEmptyStack(Stack s)
{
	return (s->next == NULL);
}


int IsFullStack(Stack s)
{
	return FALSE;
}

project.cpp

#include <stdio.h>
#include <stdlib.h>
#include <graphics.h>
#include <conio.h>
#include "myheader.h"                    of link list stack 
#define TRUE 1
#define FALSE 0
#define RESET 0



int main()
{
    Stack S = NULL; 
     
     int x0, x1, x2, x3, y0, y1, y2, y3;
     int startx, starty; 
     int polygonCounter;
     initwindow(800, 800);
     
     int m = 0;
     setcolor(4);
     
     while(m < 100)
     {
             while(!ismouseclick(WM_MBUTTONDOWN))
             {
                 if(ismouseclick(WM_LBUTTONDOWN))
                 {
                     getmouseclick(WM_LBUTTONDOWN, x0, y0);
                     PushStack(&x0, S);
                     PushStack(&y0, S);
                                                                                 
                         if(polygonCounter == 0)
                         {
                             startx = x0;
                             starty = y0;
                         }
                         polygonCounter++;
                                                                                 
                         while(!ismouseclick(WM_LBUTTONDOWN))
                         {
                             setcolor(4);
                             y0 = PopStack(S);
                             x0 = PopStack(S);                                                                                       
                             x1 = mousex();
                             y1 = mousey();                                                                                      
                             line(x0, y0, x1, y1);                                                                                                                   
                             PushStack(&x0, S);
                             PushStack(&y0, S);
                                                                                                                     
                             if(polygonCounter > 1)
                             {
                                 y3 = PopStack(S);
                                 x3 = PopStack(S);
                                                                                                                                
                                 y2 = PopStack(S);
                                 x2 = PopStack(S);
                                                                                                                                
                                 line(x2, y2, x3, y3);
                                                                                                                                
                                 PushStack(&x2, S);
                                 PushStack(&x2, S);
                                 PushStack(&x3, S);
                                 PushStack(&x3, S);
                             }
                                                                                                                     
                             delay(50);
                             setcolor(0);
                             line(x0, y0, x1, y1);
                                                                                                                     
                             if(ismouseclick(WM_RBUTTONDOWN))
                             {
                                 setcolor(0);
                                 y3 = PopStack(S);
                                 x3 = PopStack(S);
                                 y2 = PopStack(S);
                                 x2 = PopStack(S);                                                                                                                                                 
                                 line(x3, y3, x2, y2);                                                                                                                                                 
                                 PushStack(&x2, S);
                                 PushStack(&y2, S);                                                                                                                                                 
                                 polygonCounter--;                                                                                                                                                 
                                 clearmouseclick(WM_RBUTTONDOWN);
                             }
                             
                             if(ismouseclick(WM_MBUTTONDOWN))
                             {
                                 y0 = PopStack(S);
                                 x0 = PopStack(S);
                                 delay(50);
                                 setcolor(3);
                                 line(x0, y0, startx, starty);
                                 PushStack(&x0, S);
                                 PushStack(&y0, S);
                             }                                                              
                         }
                     }
                 }
                     
                     
                     
                     x0 = RESET;  
                     x1 = RESET;
                     x2 = RESET;
                     x3 = RESET;                                                                                                          
                     y0 = RESET;
                     y1 = RESET;
                     y2 = RESET;
                     y3 = RESET; 
                     startx = RESET;
                     starty = RESET;
                     
                     
                     setcolor(4);
                     
                     clearmouseclick(WM_LBUTTONDOWN);
                     clearmouseclick(WM_RBUTTONDOWN);
                     clearmouseclick(WM_MBUTTONDOWN);
                     m++;
    }
                     
                     system("PAUSE");
                     return 0;
}

The problem is that dev c++ saying that "invalid conversion from void* to int" for all variables which are defined as integers(Ex: x0, y3, startx...).

Could you please help me to solve my problem?

[PiMaster]

PopStack returns void*, yet you have a bunch of integers being assigned its return value.

BTW, format your code with [code] and [ /code] tags, not [output] tags please - it makes it much easier to read.

[Kyon]

You could be able to do a int x = static_cast<int>(void_pointer_here); to force the conversion. It should be doable that way, since both int and void* have a size of 4.

[cngata]

@Kyon,

int x = static_cast<int>(void_pointer_here); did not work when i used it wtih this : PushStack(void *x, Stack s)

[kbw]

I can't see where S is initialised. The ADT functions all assume you can dereference S, but it's always zero.