Question

我想在函数中传递一个局部变量，通过它的指针参数（不返回）。

我的赋值使用堆栈数据结构，必须使用的一个条件是Pop（）函数必须有一个指针参数，用于返回堆栈中最顶层的项目。我之前用过这个。我的程序使用数据结构变得更加复杂，我开始得到分段错误，或者在弹出函数框架后没有保存数据。

// Definitions
typedef char * string;
typedef enum { SUCCESS, FAIL } result;
typedef enum { INTEGER, DOUBLE, STRING } item_tag;


// Result Check
static result RESULT;


// Item_Tag
typedef struct {
    item_tag tag;
    union {
        int i;
        double d;
        string s;
    } value;
} item;

// Declarations
int STACK_SIZE = 0;
const int MAX_STACK_SIZE = 1024;       // Maximum stack size
item stack[1024];

// Pop
result Pop(item *ip){
    item poppedItem;
    item * pointerReturn = malloc(sizeof(item));

    // Check stack size is not 0
    if(STACK_SIZE == 0){
        return FAIL;
    }
        // If stack size is only 1, creates a blank stack
    else if(STACK_SIZE == 1){
        item emptyItem;
        // Initialize
        emptyItem.tag = INTEGER;
        emptyItem.value.i = 0;

        // Check top item's tag
        poppedItem = stack[0];
        // Store top item data based on tag
        switch(stack[0].tag){
            case STRING:
                poppedItem.value.s = stack[0].value.s;
            case DOUBLE:
                poppedItem.value.d = stack[0].value.d;
            default:
                poppedItem.value.i = stack[0].value.i;
        }
        poppedItem.tag = stack[0].tag;
        // Allocate memory for parameter, and have it point to poppedItem
        ip = malloc(sizeof(poppedItem));
        *ip = poppedItem;
        // Store empty stack to top of stack
        stack[0] = emptyItem;

        // Decrease stack size
        STACK_SIZE--;

    }
        // Grab top Item from stack
    else{
        // Check top item's tag
        poppedItem = stack[0];
        // Store top item data based on tag
        switch(stack[0].tag){
            case STRING:
                poppedItem.value.s = stack[0].value.s;
            case DOUBLE:
                poppedItem.value.d = stack[0].value.d;
            default:
                poppedItem.value.i = stack[0].value.i;
        }
        poppedItem.tag = stack[0].tag;
        // Allocate memory for parameter, and have it point to poppedItem
        ip = malloc(sizeof(poppedItem));
        *ip = poppedItem;

        // Reshuffle Items in Stack
        for(int idx = 0; idx < STACK_SIZE; idx++){
            stack[idx] = stack[idx + 1];
        }
        STACK_SIZE--;
    }
    return SUCCESS;
}

我对指针的了解很好，还有内存位置/管理。但我无论如何都声称自己是专家。当您使用函数自己的指针参数作为传递数据的方法时，我并不完全知道后台会发生什么。

解决此问题的正确语法是什么？
参数如何传回去？

提前致谢！

编辑* 因为很多人都很困惑。我会发布一些片段。这是一项任务，因此我不能简单地在线发布所有内容，因为这样做不合适。但我认为发布功能本身并让人们分析它是可以的。我知道它有点凌乱，因为我已经编辑了几十次以试图找出解决方案。对困惑感到抱歉。请记住，并非所有代码都存在。只是有问题的功能，以及一些结构。

Answer 1

该函数应该接收一个指向有效对象的指针：

item catcher;
myFunc(&catcher);  // Pass a pointer to catcher

并且该函数应该修改它收到指针的对象：

void myFunc(item *itemPointer)
{
    itemPointer->variable = stuff;
    // or
    *itemPointer = someItem;
}

更新

你过度复杂的事情 - 弹出时应该没有malloc，并且你在整个地方泄漏了记忆。
（你对指针和记忆管理的知识远非＆＃34;好吧＆＃34;。它看起来更像是一个新手的猜测而不是知识。）

它应该是更像这样的东西：

result Pop(item *ip){
    if (STACK_SIZE == 0){
        return FAIL;
    }
    else {
        *ip = stack[0];
        for(int idx = 0; idx < STACK_SIZE; idx++){
            stack[idx] = stack[idx + 1];
        }
        STACK_SIZE--;
    }
    return SUCCESS;
}

但是在阵列的远端推/弹更好：

result Pop(item *ip){
    if (STACK_SIZE == 0){
        return FAIL;
    }
    else {
        *ip = stack[STACK_SIZE-1];
        STACK_SIZE--;
    }
    return SUCCESS;
}

Answer 2

对最初发布的代码的回复：

typedef struct{
    variables
}item;

void myFunc(item *itemPointer){
    item newItem;
    newItem.variable = stuff;
}

int main(){
    item * catcher;
    myFunc(catcher);
    printf("%s\n", catcher.variable);
}

一些问题。

您的程序无法编译。 variable必须有一个类型。

void myFunc(item *itemPointer){
    item newItem;
    newItem.variable = stuff;
}

stuff未定义;未使用item *itemPointer。

item * catcher指针必须指向已分配的内存。它没有初始化。

通过指针传递参数并修改结构的成员，如下所示：

void myFunc(item *itemPointer, const char *string){

    itemPointer->variable = string ;
}

解决方案如：

void myFunc(item *itemPointer)
{
    itemPointer->variable = stuff;
    // or
    *itemPointer = someItem;
}

是可能的，但它假定stuff或someItem是global variable，这不是最好的编程习惯IMO。

通过->而不是.运算符从指针中检索值。

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

typedef struct{
    char * variable;
}item;

void myFunc(item *itemPointer, const char *string){

itemPointer->variable = string ;
}

int main(){
    item * catcher;
    char *new_string = "new string";

    catcher = malloc(sizeof(item));

    myFunc(catcher, new_string);
    printf("%s\n", catcher->variable);
    free(catcher);
    return 0;
}

输出：

new string

将函数的局部变量传递回它的参数

2 个答案: