_CrtIsValidHeapPointer(pUserData) 错误：Realloc() 指针答案

【问题标题】：_CrtIsValidHeapPointer(pUserData) Error: Realloc() pointer_CrtIsValidHeapPointer(pUserData) 错误：Realloc() 指针
【发布时间】：2013-10-02 16:27:49
【问题描述】：

在 VS2012 (C) 中编译我的代码时收到 _CrtIsValidHeapPointer(pUserData) 消息。

我意识到我试图在指针上使用realloc，所以当我阅读其他帖子时，许多人建议使用memcpy 和const char **。我真的很喜欢这样做，但我就是不知道怎么做。

第一个代码片段：我使用的指针的 Typedef 结构 realloc

int clientcounter = 0; //Global variable since this will be needed in other functions

typedef struct client{
    char name[254];
    int birthday;
    int landline;
    int cellphone;
    int clientnum;
    struct client *next; 
}clientdata;

我的程序读取文件的内容并通过单链表将其存储到这些变量中。

第二段代码：

void loading_file(clientdata curr[])
{
    clientdata *dummy[10000] = {0};
    clientdata *head;
    clientdata *tail;

    head = NULL;
    tail = NULL;

    //.... Asking for roster file

    //.. memory allocation of dummy[clientcounter]

    //.... Storing data to variables

    if (head == NULL)
    {
        head = dummy[clientcounter];
    }
    else
    {
        tail->next=dummy[clientcounter];
    }
    tail = dummy[clientcounter];

    if (head!=NULL)
    {
        dummy[clientcounter-1] = head;
        do {
            printf("\n ::%s:: Name\n",dummy[clientcounter]->name);
            curr[clientcounter] = dummy[clientcounter];
            dummy[clientcounter] = realloc(dummy,sizeof(item*) * clientcounter); //Error appears Here
            dummy[clientcounter] = NULL;
            clientcounter++;
            dummy[clientcounter] = dummy[clientcounter-1]->next;
        }while(dummy[totalitem] != NULL);
    }
    free(dummy[totalitem-1]);
}

有人告诉我，每次clientcounter++ 发生时，我都必须重新分配内存，以免泄漏。我的问题是，我知道导致错误的原因（重新分配指针），但我不知道如何解决。

谁能教我如何修复代码？

【问题讨论】：

您的do{} 循环无效（没有while() 条件。而且我认为这段代码中的虚拟指针数组没有任何原因根本。我们也不知道clientdata 或hero 是什么。据我所知，您不需要该sn-p 中的任何低级逻辑来从a 加载链表文件，你当然不需要realloc()。你想解决什么问题？
@WhozCraig 我很抱歉。已编辑
@WhozCraig 所以即使clientcounter 增加，我也不需要重新分配dummy[clientcounter]？如果我删除realloc，那么我会在dummy[clientcounter] = dummy[clientcounter-1]->next;得到“访问违规读取位置”
我的意思是，如果这一切应该做的是构建一个前向链表，那么指针数组，重新分配，所有的都不是完全需要。所以我问，你想解决什么问题。
@WhozCraig 我的程序在链表部分不起作用。文件中有多个“组”数据（1 组 = 5 个变量，在typedef 中声明），我的程序只打印第一组然后休息。如果我不包括 realloc

标签： c pointers realloc singly-linked-list

【解决方案1】：

如果最终目标是简单地将数据文件加载到链接列表中，则大多数发布的代码都是无关紧要的，根本不需要。以下是将数据文件加载到前向链表中的非常简单实现。

需要什么

一般算法是这样的：

从输入文件中读取一行。
将该行解析为我们的结构成员。
如果所有成员都正确解析，则创建一个新项目并将其添加到列表中。

最后一步是上面代码的核心，我会在代码之后解释它是如何工作的。这个修改后的函数将正在处理的文件名作为唯一的输入参数，并返回一个clientdata项目的链表，其解析你还得写，所以不要以为你'免费获得所有这些：

守则

clientdata* load_file(const char fname[])
{
    FILE *fp = fopen(fname, "r");
    char line[512]; // suitable value

    // pp always holds the *address* of the pointer where the
    //  next node will be added to the list. notice how it first
    //  holds the address of our list-head pointer.
    clientdata *result = NULL;
    clientdata **pp = &result;

    while (fgets(line, sizeof(line), fp))
    {
        clientdata val = {0};

        //
        // TODO: parse line into val-members using things like
        //  sscanf(), strtok(), or others, etc.
        //

        if (parsed-successfully-condition)
        {
            // allocate a new list node, copy over the data
            *pp = malloc(sizeof(**pp));
            if (*pp)
            {
                memcpy(*pp, &val, sizeof(**pp));

                // load pp with the address of the 'next' member for
                //  the node we just allocated and saved. it will be
                //  the link to the next new node if we need one
                pp = &(*pp)->next;
            }
            else
            {   // malloc() failed. not good. no sense in continuing.
                perror("Failed to allocate new node.");
                break;
            }
        }
    }

    // required. this terminates the list.
    *pp = NULL; 
    return result;
}

解释

我们保留两个指针。一个是返回结果指针 (result)，最初为 NULL。另一个是指向指针pp，它最初保存着我们返回结果指针的地址。这是一个特殊的变量。它是一个指向指针的指针，它将始终保存我们在进行新分配时需要设置的 next 指针的地址。一张图讲一千个字。初始配置如下所示：

result = NULL;
^---- pp

当我们插入一个新节点时，我们会填充 pp 中保存的地址指针。第一次该地址将指向result。请注意取消引用 *pp。所以添加一个新节点后，再将新节点的next指针地址移入pp，现在的画面是这样的：

result --> item0
           next
pp --------^

第二次插入后

result --> item0
           next --> item1
                    next
pp -----------------^

最后还有一个……

result --> item0
           next --> item1
                    next --> item2
                             next
pp --------------------------^

算法通过终止列表结束。这是通过将pp 寻址的指针设置为NULL 来完成的。注意那里的措辞。我们不会将 pp 设置为 NULL（那将毫无意义）。我们将指针 它的地址 设置为 NULL。

*pp = NULL;

生成的图片将像这样完成：

result --> item0
           next --> item1
                    next --> item2
                             next --> NULL

在每种情况下，插入咒语始终相同。

在*pp指向的节点中存储一个新的分配
将数据复制到新分配中
存储 next 指针以接收pp 中的下一个新分配
循环直到我们读完文件。
退出循环后，将*pp 设置为NULL，因为它是我们链中的最后一个 next 指针，应该为NULL 以终止链表。

有一些有趣的基础条件值得理解。一个值得注意的是“当输入文件有 no 项时会发生什么？这仍然有效吗？”是的，确实如此。在这种情况下，while 循环将永远不会添加新项目，pp 仍将包含result 的地址，而*pp = NULL; 将（冗余）将其设置为 NULL。结果将是一个 NULL 返回值，这正是您想要的“空”链表。

我强烈建议在调试器中运行它，看看pp、*pp 和**pp 在这个算法中是如何工作的。

【讨论】：