Question

我正在尝试使用void指针在C中实现泛型堆栈。这不是什么大事，只是为了娱乐和学习。它按预期使用int和float。但我面临的问题是char *，即字符串。它不是复制字符串的地址而是试图将实际字符串复制到4个字节（因为我的系统指针大小是4个字节）。

如果可能的话，如何告诉C复制字符串的地址而不是实际的字符串，而没有破坏int和float的功能？

到目前为止，我的实施如下，


typedef struct{
        int top;
        void *data;
        int capacity;
        size_t ele_size;
}stack_t;

int stack_init(stack_t *s, int capacity, size_t ele_size)
{
        /*  Initializes the stack with the given capacity
         *  @param s: Pointer to stack_t type variable
         *  @param capacity: capacity of the stack to be created
         *  Returns : Zero if succesful in allocating memory to the stack,
         *              -1 Otherwise
         */
        s->top = -1;
        s->capacity = capacity;
        s->ele_size = ele_size;
        s->data = calloc(s->capacity, s->ele_size);
        if (s-> data != NULL || s->capacity == 0) {
                return 0;
        } else {
                return -1;
        }
}

int stack_push(stack_t *s, void *x)
{
        /*  Pushes an element on to the stack
         *  @param s: Pointer to stack_t type variable
         *  @param x: Value to Push on to the stack
         *  Returns : Zero if stack is not full when stack_push() is called,
         *              -1 Otherwise
         */
        if (stack_len(s) capacity) {
                s->top++;
                memcpy(s->data + s->ele_size * s->top, x, s->ele_size);
                return 0;
        } else {
                return -1;
        }
}

int stack_pop(stack_t *s, void *value)
{
        /*  Value that is popped from the stack is placed in value parameter,
         *  @param s: Pointer to stack_t type variable
         *  @param x: Pointer to a variable to store the value popped from the 
                        stack
         *  Returns:  Zero if stack is not empty when stack_pop() is called,
         *              -1 Otherwise
         */
        if (stack_len(s) > 0) {
                memcpy(value, s->data + s->ele_size * s->top, s->ele_size);
                s->top--;
                return 0;
        } else {
                return -1;
        }
}

要完整实现堆栈，请参阅here

上述堆栈的用法如下：实际上有许多不相关的东西，如使用伪随机数发生器将随机数插入堆栈。



#include"../src/stack.h"

START_TEST(int_push_pop)
{
        stack_t s;
        int n = random() % 60267;
        int *a = calloc(n, sizeof (int));
        ck_assert_int_eq(stack_init(&s, n, sizeof (int)), 0);
        int i;
        for (i = 0; i = 0; i--) {
                int value;
                int x = stack_pop(&s, &value);
                ck_assert_int_eq(x, 0);
                ck_assert_int_eq(value, a[i]);
                x = stack_len(&s);
                ck_assert_int_eq(x, i);
        }
        stack_clear(&s);
        stack_destroy(&s);
}

END_TEST

START_TEST(float_push_pop)
{
/* similar to int_push_pop, so ignored here. */
}

END_TEST


START_TEST(string_push_pop)
{
        stack_t s;

        char *str = "stack overflow";
        stack_push(&s, str);
        char **popval = malloc(sizeof(char *));
        stack_pop(&s, popval);
        printf("%s\n", popval);

        stack_destroy(&s);

}

END_TEST


Suite* stack_suite()
{
        Suite *s = suite_create("Stack");

        TCase *tc_int = tcase_create("int");
        /* Stack int data type Test Case*/

        TCase *tc_float = tcase_create("float");
        /* Stack float data type Test Case*/

        tcase_add_test(tc_int, int_push_pop);
        tcase_add_test(tc_float, float_push_pop);

        suite_add_tcase(s, tc_int);
        suite_add_tcase(s, tc_float);

        return s;
}


int main()
{
        int number_failed;
        Suite *s = stack_suite();
        SRunner *sr = srunner_create(s);
        srunner_run_all(sr, CK_NORMAL);
        number_failed = srunner_ntests_failed(sr);
        srunner_free(sr);

        return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}

Answer 1

由于stack_push()和stack_pop()函数正在使用void*指针，因此您需要将指针传递给需要推送的字符数组（字符串）而不是char数组本身。例如如果您将字符串声明为

char str[] = "hello world";

您必须将该功能称为

stack_push(s,&str);

C中的泛型堆栈使用void指针不适用于字符串

1 个答案: