在 c 中使用通用指针实现堆栈

Question

This is my code for implementing stack using generic pointer, I am not getting the proper output, at the time of display, sometimes I am getting garbage value, there is also a problem while popping the value.

I took void *data as generic pointer and I have to pass int and float values to it, I have used memmove to move the address of local variables of int and float to pass the address to the generic pointer.

I am new with generic pointers and implemented it first time. I just cant find out whats the problem.

If anybody could solve my problem than it would be great help.
Thank you.

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

static int position = 0;


typedef struct generic
{
    void *data;
    struct generic *next;
} generic;


generic *pop(generic *top);


generic *
push (generic *top, void *temp, int size)
{
    generic *nw;
    nw = (generic *) malloc (sizeof (generic));
    nw->data = malloc(size);
    memmove(nw->data, temp, size);
    nw->next = top;
    return nw;
}

generic *
pop (generic *top)
{
    generic *p;
    if (top == NULL)
        printf ("\n Stack is empty");
    else
    {
        p = top->next;
        free(top->data);
        free (top);
        top = p;
        position--;
        return top;
    }
}



void
display (generic *top, int temp[])
{
    int pos = 0;
    for (; top != NULL; top = top->next)
    {
        if (temp[pos] == 1)
            printf ("\n %d", *(int *) top->data);
        else
            printf ("\n %.2f", *(float *) top->data);
        pos++;
    }
}




int
main ()
{
    generic *top = NULL;
    int choice;


    bool exitt = false;
    int temp[5];
    while(1)
    {
        printf ("\n*******Stack using generic pointer*********\n");
        printf ("\n 1.PUSH");
        printf ("\n 2.POP");
        printf ("\n 3.DISPLAY");
        printf ("\n 4.EXIT");
        printf ("\n********************************************\n");

        printf ("\n enter the choice");
        scanf ("%d", &choice);
        switch (choice)
        {
        case 1:
            int choose;
            printf("Enter the choose option\n");
            scanf("%d", &choose);
            if (choose == 1)
            {
                int val;
                printf ("\nenter the value");
                scanf ("%d", &val);
                top = push (top, &val, sizeof(val));
                temp[position++] = 1;
            }
            else
            {
                float val;
                printf ("\nenter the value");
                scanf ("%f", &val);
                top = push (top, &val, sizeof(val));
                temp[position++] = 2;

            }
            break;

        case 2:
            top = pop (top);
            break;

        case 3:
            display (top, temp);
            break;
        default :
            exit(0);
        }
    }
    return 0;
}

Answer 1

This is not a complete answer.

I suggest you use a union , for example:

typedef struct generic
{
    int datatype;
    union {
        int intval;
        float floatval;
    }u;
    struct generic *next;
} generic;

Now you can store the type of the data with the data and do not need to keep track of it outside your data structure.

Answer 2

First of all the function pop has to return something if top == NULL , as kaylum pointed out in the comments.

if (top == NULL) {
    fprintf(stderr, "Error: stack is empty\n");
    return NULL;
}

Note that you also don't need to cast malloc , because it returns void * , which is automatically and safely promoted to any other pointer.

nw = malloc(sizeof(generic)); /* no need to cast malloc */

Your approach

If you want to stick to your approach, I would store the return value of sizeof() in the site_t datatype.

push (generic *top, void *temp, size_t size) { }

And the thing that actually causes your problem is the fact that you iterate over the array temp from 0 to position - 1 while the elements on the stack are in reverse order. This code should work though:

void display (generic *top, int temp[])
{
    for (; top != NULL; top = top->next) {
        position--; // <- the global variable
        if (temp[position] == 1)
            printf("%d\n", *(int *) top->data);
        else
            printf("%.2f\n", *(float *) top->data);
    }
}

Alternative solution

I would store the data in a union instead of a generic void pointer, as briefly described in Paul Ogilvie's answer , because with your approach you have to keep track of the datatype outside, which is generally not a good idea.

C11 and newer

As of C11 the union can be anonymous:

enum datatype {
    DATATYPE_INT,
    DATATYPE_FLOAT,
}

struct generic {
    enum datatype;
    union {
        int int_data;
        float float_data;
    };
    struct generic *next;
};

The data can then be accessed like this:

if (top->datatype == DATATYPE_INT)
    printf("%d\n", top->int_data);
else if (top->datatype == DATATYPE_FLOAT)
    printf("%f\n", top->float_data);

C99 and older

If you are using C99 or older you have to name the union .

enum datatype {
    DATATYPE_INT,
    DATATYPE_FLOAT,
}

struct generic {
    enum datatype;
    union {
        int int_data;
        float float_data;
    } data;
    struct generic *next;
};

The data can then be accessed like this:

if (top->datatype == DATATYPE_INT)
    printf("%d\n", top->data.int_data);
else if (top->datatype == DATATYPE_FLOAT)
    printf("%f\n", top->data.float_data);