C 反向函数总是给我错误

这是一个调用字符和整数堆栈中的数组的函数。它应该反转这些值，但首先我必须弄清楚哪个是字符串，哪个是整数，然后才能切换它们。但我总是出错。这件事有什么可笑的地方吗

void reverse(Stack *S)
// NOTE:  Called w/ user input 'r'   
// PRE:   Stack S is initialized  
// POST:  The first two values of the stack are reversed on the stack 
{
    int valone;
    int valtwo;
    char stringone[50];
    char stringtwo[50];

    if (S->size < 1)
    {
        printf("Error: There are less than 2 values on the stack \n");
    }  
    else
    { 
        valone = (float)topInt(S);
        strcpy(stringone, topString(S));
        pop(S);
        valtwo = (float)topInt(S);
        strcpy(stringone, topString(S));
        pop(S);

        if(stringone[0] == '\n')
        {
            pushInt(S, valone);
        }
        else if(valone == '\n')
        {
            pushString(S, stringone);
        }
        else if(stringtwo[0] == '\n')
        {
            pushInt(S, valtwo);
        }
        else if(valtwo == '\n')
        {
            pushString(S, stringtwo);
        }
    }
}

void reverse（堆栈*S）
//注意：调用w/用户输入'r'
//前置：堆栈S已初始化
//POST：堆栈的前两个值在堆栈上反转
{
瓦隆酒店；
int-valtwo；
char-stringone[50]；
两个[50]；
如果（S->尺寸<1）
{
printf（“错误：堆栈上的值少于2个\n”）；
}  
其他的
{ 
瓦隆=（浮点数）topInt（S）；
strcpy（串一、上串）；
流行音乐(S);；
valtwo=（浮点）topInt（S）；
strcpy（串一、上串）；
流行音乐(S);；
如果（stringone[0]='\n'）
{
普辛特(S,瓦隆),；
}
else if（valone=='\n'）
{
推进管柱（S、stringone）；
}
else if（stringtwo[0]='\n'）
{
普辛特(S,valtwo),；
}
else if（valtwo=='\n'）
{
推进管柱（S、2号管柱）；
}
}
}

您正在从堆栈中弹出两个值，但只将一个值推回到堆栈上。您需要将

的else if

s中的一个更改为

if

    if(stringone[0] == '\n')
    {
        pushInt(S, valone);
    }
    else if(valone == '\n')
    {
        pushString(S, stringone);
    }

    if(stringtwo[0] == '\n')
    {
        pushInt(S, valtwo);
    }
    else if(valtwo == '\n')
    {
        pushString(S, stringtwo);
    }

我不知道这是否能解决你的问题。你犯了什么错误？请把它寄出去

另外，为什么在这里使用

\n

作为一些特殊值？如果

valone

或

valtwo

最终等于

\n

的整数值，您将遇到奇怪的问题

如果我是你，我会把方法改成

void reverse(Stack **S)
{
    Stack* newS = allocateEmptyStack();

    while (!isEmpty(*S))
    {
        StackItem* item = top(*S);
        pop(*S);
        push(newS, item);
    }

    freeStack(*S);
    *S = newS;

 }

一些可能的定义

typedef enum ItemType
{
    STACK_STRING,
    STACK_INT,
    STACK_FLOAT
} ItemType;

typedef struct StackItem
{
    ItemType type;
    void* data;
    StackItem* next;
} StackItem;

typedef struct Stack
{
    StackItem* top;
} Stack;

Stack* allocateEmptyStack()
{
    Stack* S = malloc(sizeof(Stack));

    S->top = NULL;

    return S;
}

int isEmpty(Stack* S)
{
    if (S->top == NULL)
        return 1;

    return 0;
}

void freeStack(Stack* S)
{
    while (!isEmpty(S))
    {
        StackItem* item = top(S);
        pop(S);
        freeStackItem(item);
    }

    free(S);
}

StackItem* top(Stack* S)
{
    return S->top;
}

void pop(Stack* S)
{
    StackItem* topItem = top(S);

    if (topItem != NULL)
    {
        s->top = topItem->next;
    }
}

void push(Stack* S, StackItem* item)
{
    item->next = top(S);

     s->top = item;
}

StackItem* allocateStackItem(ItemType type, int dataSize)
{
    StackItem* item = malloc(sizeof(StackItem));

    item->data = malloc(dataSize);
    item->type = type;
    item->next = NULL;

    return item;
} 

void freeStackItem(StackItem* item)
{
    if (item->data != NULL)
        free(item->data);

    free(item);
}

初始化

堆栈的示例

Stack* S = allocateEmptyStack();

StackItem* item = allocateStackItem(STACK_INT, sizeof(int));
int* int_ptr = (int*)(item->data);
*int_ptr = 1234;

push(S, item);

const char* str = "this is a string";

item = allocateStackItem(STACK_STRING, strlen(str) + 1);
char* char_ptr = (char*)(item->data);
strcpy(char_ptr, str);

push(S, item);

没有更多细节很难理解，但看起来你在做两次pop和一次push。你至少需要讲出你的第二个故事。
不要太苛刻，但这段代码相当于完全不连贯。
我无法想象valone=（float）topInt（S）是什么；是打算做的，因为
valone是一个int。您似乎也在为两者分配一个整数标识
以及堆栈顶部元素的字符串标识。你弹出两个项目
离开堆栈，最多推一个。您可以复制到固定长度的缓冲区
不检查要复制的字符串的大小，最后，如果
在堆栈上推送字符串，就是推送局部变量地址
当函数退出时，这将无效。
您会遇到什么类型的错误？类型堆栈的定义在哪里？为什么使用cast-to-float将该值存储在int中？为什么有时你推字符串，有时推整数？你的代码很混乱…我没有注意到任何正确的地方。对堆栈上太少项目的测试似乎也不正确。哦，天哪……同意了。这段代码没有什么意义。这就是为什么我最终编写了一个示例堆栈接口。这是一个缓慢的工作日…OP显然是一个新手，所以为他编码不会教他钓鱼。我坚持用非正式的语言指出问题和解决方案，这样他们就会从学习思考和编写代码中受益。