Как перезаписать строковый буфер, не изменяя его ранее использовавшиеся

Вы передаете указатель на new_entry(char *id)

Для компьютера, создающего в стеке переменную с адресом памяти строки идентификатора.

Когда вы делаете e->id = id; в new_entry(), вы сохраняете e->id адрес памяти строки идентификатора, а не самой строки.

При повторном вызове snprintf(id, ...); вы переписываете строку, сохраняете в своем char id[8];.

И когда вы читаете свой идентификатор, вы читаете указатель на char id[8] и читаете последнее внесенное вами изменение.

Мы можем проверить это, распечатав адрес указателя всех идентификаторов элементов:

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

struct Entry
{
    char *id;
};

struct Entry *new_entry(char *id)
{
    struct Entry *e = malloc(sizeof(struct Entry));
    if (e == NULL)
        return (NULL);
    e->id = id;
    return e;
}

int main(void)
{
    struct Entry * b[2];

    for (int i = 0; i < 2; i++)
    {
        char id[8];
        id[0] = '0' + i;
        id[1] = '\0';
        struct Entry *e = new_entry(id);
        if (e == NULL)
            return (-1);
        b[i] = e;
    }

    printf("Entry 0 id: %s.\n", b[0]->id);
    printf("Entry 1 id: %s.\n", b[1]->id);
    printf("Adress 0 id: %p.\n", b[0]->id);
    printf("Adress 1 id: %p.\n", b[1]->id);
    free(b[0]);
    free(b[1]);
    return (0);
}

Результат:

➜  test ./a.out
Entry 0 id: 1.
Entry 1 id: 1.
Adress 0 id: 0x7ffd7496bd30.
Adress 1 id: 0x7ffd7496bd30.

У нас есть время для одного и того же адреса, чтобы синхронизировать одну и ту же строку. У нас также есть проблема, потому что char id[8] больше нет в стеке при печати. И это может привести к повреждению стека:

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

struct Entry
{
    char *id;
};

struct Entry *new_entry(char *id)
{
    struct Entry *e = malloc(sizeof(struct Entry));
    if (e == NULL)
        return (NULL);
    e->id = id;
    return e;
}

int main(void)
{
    struct Entry * b[2];

    for (int i = 0; i < 2; i++)
    {
        char id[8];
        id[0] = '0' + i;
        id[1] = '\0';
        struct Entry *e = new_entry(id);
        if (e == NULL)
            return (-1);
        b[i] = e;
    }

    char test[8];

    test[0] = ';';
    test[1] = '\0';
(void)test;

    printf("Entry 0 id: %s.\n", b[0]->id);
    printf("Entry 1 id: %s.\n", b[1]->id);
    printf("Adress 0 id: %p.\n", b[0]->id);
    printf("Adress 1 id: %p.\n", b[1]->id);
    free(b[0]);
    free(b[1]);
    return (0);
}

Результат:

➜  test ./a.out
Entry 0 id: ;.
Entry 1 id: ;.
Adress 0 id: 0x7ffc08207880.
Adress 1 id: 0x7ffc08207880.

Если вы хотите сохранить копию строки, вам нужно вызвать strdup (дублировать строку) или strcpy (копировать строку):

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

struct Entry
{
    char *id;
};

struct Entry *new_entry(char *id)
{
    struct Entry *e = malloc(sizeof(struct Entry));
    if (e == NULL)
        return (NULL);
    e->id = strdup(id);
    if (e->id == NULL)
    {
        free(e);
        return (NULL);
    }
    return e;
}

int main(void)
{
    struct Entry * b[2];

    for (int i = 0; i < 2; i++)
    {
        char id[8];
        id[0] = '0' + i;
        id[1] = '\0';
        struct Entry *e = new_entry(id);
        if (e == NULL)
            return (-1);
        b[i] = e;
    }

    printf("Entry 0 id: %s.\n", b[0]->id);
    printf("Entry 1 id: %s.\n", b[1]->id);
    printf("Adress 0 id: %p.\n", b[0]->id);
    printf("Adress 1 id: %p.\n", b[1]->id);
    free(b[0]->id);
    free(b[1]->id);
    free(b[0]);
    free(b[1]);
    return (0);
}

Результат:

➜  test ./a.out
Entry 0 id: 0.
Entry 1 id: 1.
Adress 0 id: 0x556eb8f522c0.
Adress 1 id: 0x556eb8f52300.

А еще кастинг своего malloc()вообще плохая идея.

И не забывайте, что вызов функции, такой как malloc() или strdup, должен иметь результат free() и может привести к сбою, и вы несете ответственность за его обработку.

Благодаря комментариям к моему вопросу, я теперь понимаю проблему.

У меня возникла ошибка «использование стека после области». Эта ошибка возникает, когда указатель на память в стеке используется после завершения области, в которой была выделена память.

В приведенном ниже коде я создал буфер char id[8] в цикле for, придав ему локальную область действия внутри блока. Это означает, что id не только выходит из области видимости в конце каждой итерации (что большинство программистов распознает в других языках программирования), но, что особенно важно, сама базовая память также помечается как доступная.

for (int i = 0; i < 5; i++)
{
    char id[8];
    snprintf(id, 8, "entry-%d", i);
    struct Entry *e = new_entry(id);
    bucket_add(b, e);
}

На каждой итерации моего цикла for из стека запрашиваются новые 8 байтов и присваиваются новой переменной с локальной областью действия под названием id. Мой компилятор повторно использует 8 байтов в стеке, которые только что стали доступны в предыдущей итерации, поэтому id получает тот же адрес памяти в стеке, что и в предыдущей итерации. Однако это зависит от реализации и не всегда может работать таким образом.

Это само по себе нормально и ожидаемо, как и обычные правила определения области действия. Ошибка возникает потому, что я беру указатель на стековую память id и копирую этот указатель в кучу памяти здесь:

struct Entry *new_entry(char *id)
{
    struct Entry *e = (struct Entry *)malloc(sizeof(struct Entry));
    e->id = id;
    return e;
}

У компилятора нет проблем с указателем в куче, указывающим на память в стеке. Но это становится ошибкой, когда этот указатель в куче используется для доступа к памяти в стеке после того, как она выходит за пределы области видимости и становится доступной для повторного использования. Это неопределенное поведение, что означает, что мы рискуем повредить память или указать на непреднамеренную память.

Итак, когда я получил доступ к данным за пределами локальной области, в которой они были объявлены:

printf("Entry 0 id: %s.\n", b->_entries[0]->id);
printf("Entry 1 id: %s.\n", b->_entries[1]->id);

Выход:

Entry 0 id: entry-4.
Entry 1 id: entry-4.

Неопределённое поведение проявлялось в том, что каждая запись в моей корзине имела указатель id на одну и ту же ячейку памяти и, следовательно, на одно и то же значение. Чем позже будет использоваться указатель, тем хуже будет, потому что вскоре эта память будет снова перезаписана.

Эта проблема решается путем обеспечения того, чтобы, когда указатель должен пережить свою область действия, базовая память, на которую он указывает, *также переживет свою область действия. В моем случае это означает, что мне нужно скопировать строку, на которую указывает id, в кучу памяти и вместо этого сохранить новый адрес кучи.

Для этого я решил использовать функцию strdup:

#include <string.h>

struct Entry *new_entry(char *id)
{
    struct Entry *e = (struct Entry *)malloc(sizeof(struct Entry));
    e->id = strdup(id);
    return e;
}

Вывод показывает, что ошибка устранена:

Entry 0 id: entry-0.
Entry 1 id: entry-1.