Question

我使用stackADT结构和一组函数在C中实现了一个堆栈：

#ifndef _stack_h
#define _stack_h

// Macros
#define MaxStackSize 100
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// The type of element that may 
// be stored in the stack
typedef int stackElementT;

// The stackADT represents the abstract type used to store
// the elements that have been pushed
typedef struct stackCDT
{
    // A pointer to an array of elements
    stackElementT* elements;
    // Number of elements on the stack
    int count;
    // Number of elements we can push onto
    // the stack before having to resize
    int size;
}* stackADT;

// This function allocates and returns a new stack, which is
// initially empty... AKA - The Constructor
stackADT NewStack(void)
{
    // The stack to return
    stackADT stack;

    // Instanitate a new stack
    stack = (stackCDT*)(malloc(sizeof(stackCDT)));

    // Start with 0 elements of course
    stack->count = 0;
    // Allocate memory for 50 integers
    stack->elements = (stackElementT*)(malloc(50*sizeof(stackElementT)));
    // Establish the size of the stack
    stack->size = 50;

    return stack;
}


/********* GETTER FUNCTIONS *********/
// Returns the number of elements currently pushed 
// onto the stack
int StackDepth(stackADT stack)
{
    return (stack->count);
}

// This function returns the element a the specified index in
// the stack, where the top is defined as index 0
stackElementT GetStackElement(stackADT stack, int index);

// Function to print contents of stack
void PrintStack(stackADT stack)
{
    int i = 0;
    printf("count = %d\nsize = %d\n",stack->count,stack->size);

    for(i = (stack->count - 1); i >= 0; i--)
    {
        if((i%10 == 0) && (i != 0))
            printf("\n");
        printf("%d\t",*(stack->elements + i));
    }
}


// Functions to determine if stack is empty or full
int StackIsEmpty(stackADT stack)
{
    if(stack->count == 0)
        return 1;
    else
        return 0;
}
int StackIsFull(stackADT stack)
{
    if(stack->count == stack->size)
        return 1;
    else
        return 0;
}


// This function pushes the specified element onto the stack
void Push(stackADT stack, stackElementT element)
{
    // A temporary array that we may use later on
    stackElementT* temp = NULL;
    int oldCount = stack->count;
    int i = 0;

    // If the stack if full we need to do a
    // a transfer, resize, and retransfer, then push
    if(StackIsFull(stack))
    {
        // temp will be the same size as the old stack
        temp = (stackElementT*)(malloc((oldCount)*sizeof(stackElementT)));

        // Now we perform the transfer
        for(i = 0; i < oldCount; i++)
        {
            *(temp + i) = *((stack->elements) + i);
        }

        // Free the old memory
        free(stack->elements);
        stack->elements = NULL;

        // Recreate the stack with a 50% increase in size/capacity
        stack->elements = (stackElementT*)(malloc((3*oldCount/2)*sizeof(stackElementT)));
        // Re-establish the size
        stack->size = 3*oldCount/2;

        // Now we perform the transfer back
        for(i = 0; i < oldCount; i++)
        {
            *((stack->elements) + i) = *(temp + i);
        }

        // Free the temp array and 
        // remove dangling pointer
        free(temp);
        temp = NULL;

        // Now we push the element onto the stack
        *((stack->elements) + oldCount) = element;
        // Increase the count
        stack->count = oldCount + 1;
    }
    // If the stack isn't full
    else
    {
        *((stack->elements) + oldCount) = element;
        stack->count = oldCount + 1;
    }

}

// This function pops the top element from the stack and returns
// that value
stackElementT Pop(stackADT stack);


// This function frees the storage associated with the stack
void FreeStack(stackADT stack)
{
    // Start by freeing the elements on the stack
    // and remove dangling pointers
    free(stack->elements);
    stack->elements = NULL;

    // Finally free the stack
    free(stack);
    stack = NULL;
}

#endif

显然我还没完成（需要一个pop功能）。我关心的是底层函数（FreeStack）。我测试了下面的代码：

#include <stdio.h>
#include <stdlib.h>
#include "Stack.h"
#define _CRTDBG_MAP_ALLOC
#include <crtdbg.h>

int main(void)
{
    stackADT stack;
    int i = 0;

    stack = NewStack();
    PrintStack(stack);

    for(i = 0; i < 60; i++)
    {
        Push(stack,i);
    }

    PrintStack(stack);
    FreeStack(stack);

    _CrtDumpMemoryLeaks();

    return 0;
}

_CrtDumpMemoryLeaks（）函数适用于Visual Studio，它指示是否存在内存泄漏。显然我在调用FreeStack（stackADT堆栈）函数时已经封锁了任何泄漏。但是，堆栈指针仍然保存一个内存地址，这是问题，因为FreeStack函数应该释放堆栈变量指向的内存并将其设置为NULL。这发生在函数内，但是当我在调试期间返回main函数时，我看到内存地址仍然存在。我在这里缺少什么？如果我能释放内存，为什么我不能删除悬空指针？

Answer 1

您通过值将堆栈传递给函数，而不是通过地址传递，修改要接收的函数（stackADT *），您将会很高兴。

澄清：正如Christian评论的那样，函数调用以及堆栈的使用当然也必须改变（因为现在它是指向指针的指针......）

Answer 2

你在pop方法中按值传递stackADT个对象（指针）：

void FreeStack(stackADT stack)

所以stack指的是该指针的本地副本。当您设置指针= NULL时，您只能在FreeStack中修改它。 main方法有自己的指针副本，不指向NULL。

释放C Stack＆amp;删除悬空指针

2 个答案: