对PyMC3确定性变量的后验预测(Posterior Predictive Check on PyMC3 Deterministic Variable)

 这里有一个逻辑问题。 您最初使用calloc为一个对象分配空间，然后调用add_entry并将count等于0。 
 
 然后在索引current_count处添加新条目，该条目在此处为0。 然后你用current_count + 1调整内存大小，这也是1.所以你根本没有调整内存的大小。 
 
 在下一次迭代中， entry_count为1，并在entries[1]处添加一个新元素。 这就是问题所在，你正在越界访问内存，因为此时你只剩下一个对象的空间。 
 
 而不是通过current_count + 1重新分配，您应该通过current_count + 2重新分配，以便下一次迭代有空间将新元素放在内存末尾。 
 
void *add_entry(Entry *entries, int current_count)
{
    Entry entry;

    printf("Enter name: ");
    scanf(" %[^\n]s", entry.name);
    printf("Enter number: ");
    scanf(" %[^\n]s", entry.number);
    printf("\n");

    entries[current_count] = entry;
    return realloc(entries, sizeof(Entry) * (current_count + 2));  // <-- +2
}
 
 请注意，您的current_count变量总是比实际分配的大小落后一步，这就是为什么您需要+2 
 
 编辑 
 
 还要注意更自然的方式是先调整大小，然后插入新的对象。 所以我会用NULL初始化内存，并像这样做： 
 
int main()
{
    size_t entry_count = 0;
    Entry *entries = NULL, *tmp;
    int choice = 0;

    while (1) {
        printf("Options:\n1) Add Entry\n2) Modify Entry\n3) Print Entries\n4) Exit\n\nSelect an option: ");
        scanf(" %d", &choice);
        switch (choice) {
        case 1:
            tmp = add_entry(entries, &entry_count);
            if(tmp == NULL)
            {
                // error handling
                // entries still point to the old memory
                // could be useful in error handling

                free(entries);
                return 1;
            }

            entries = tmp;
            break;
            // ...
        }
    }
}

void *add_entry(Entry *entries, size_t *current_count)
{
    if(current_count == NULL)
        return NULL;

    Entry entry;

    printf("Enter name: ");
    scanf(" %[^\n]s", entry.name);
    printf("Enter number: ");
    scanf(" %[^\n]s", entry.number);
    printf("\n");

    if(entries == NULL)
        *current_count = 0;

    Entry *tmp = realloc(entries, (*current_count + 1) * sizeof *entries);

    if(tmp == NULL)
        return NULL;

    entries = tmp;

    entries[(*current_count)++] = entry;

    return entries;
}
 
 请注意，计数变量的realloc 和增量发生在同一个函数中。 只有当一切顺利时，你才应该增加计数器。 还要注意， entries初始化为NULL ，因为realloc(NULL, size)等价于malloc(size) 。 

There is a logic problem here. You initially allocate space for one object with calloc then call add_entry with the count equals to 0.
 
Then you add the new entry at index current_count which is 0 at this point. Then you resize the memory with current_count + 1, which is also 1. So you are not resizing the memory at all.
 
In the next iteration, entry_count is 1 and you add a new element at entries[1]. And that's the problem, you are accessing the memory out of bounds, because you still have space for only one object at this time.
 
Instead of reallocating by current_count + 1, you should reallocate by current_count + 2, so that the next iteration has space to put the new elements at the end of the memory.
 
void *add_entry(Entry *entries, int current_count)
{
    Entry entry;

    printf("Enter name: ");
    scanf(" %[^\n]s", entry.name);
    printf("Enter number: ");
    scanf(" %[^\n]s", entry.number);
    printf("\n");

    entries[current_count] = entry;
    return realloc(entries, sizeof(Entry) * (current_count + 2));  // <-- +2
}
 
Note that your current_count variable is always one step behind the real size of the allocation, that's why you need the +2
 
edit
 
Note also that the more natural way would be to resize first, and then insert the new object. So I would initialize the memory with NULL and do it like this:
 
int main()
{
    size_t entry_count = 0;
    Entry *entries = NULL, *tmp;
    int choice = 0;

    while (1) {
        printf("Options:\n1) Add Entry\n2) Modify Entry\n3) Print Entries\n4) Exit\n\nSelect an option: ");
        scanf(" %d", &choice);
        switch (choice) {
        case 1:
            tmp = add_entry(entries, &entry_count);
            if(tmp == NULL)
            {
                // error handling
                // entries still point to the old memory
                // could be useful in error handling

                free(entries);
                return 1;
            }

            entries = tmp;
            break;
            // ...
        }
    }
}

void *add_entry(Entry *entries, size_t *current_count)
{
    if(current_count == NULL)
        return NULL;

    Entry entry;

    printf("Enter name: ");
    scanf(" %[^\n]s", entry.name);
    printf("Enter number: ");
    scanf(" %[^\n]s", entry.number);
    printf("\n");

    if(entries == NULL)
        *current_count = 0;

    Entry *tmp = realloc(entries, (*current_count + 1) * sizeof *entries);

    if(tmp == NULL)
        return NULL;

    entries = tmp;

    entries[(*current_count)++] = entry;

    return entries;
}
 
Note here that the realloc and the increment of the counting variable happens in the same function. Only when everything goes OK, you should increase the counter. Also note that entries is initialized with NULL, because realloc(NULL, size) is equivalent to malloc(size).