Что происходит с памятью после '' в строке с?

после добавления '\0 ' память просто возвращается, или это сидя там забивая пространство до тех пор, пока free() не называется?

в этом нет ничего волшебного . Вы должны позвонить realloc Если вы хотите "сжать" выделенной памяти. В противном случае память будет просто сидеть там, пока вы не позвоните free.

если я вставляю '\0 ' в середину выделенной памяти, делает (a.) free () все еще работает правильно

что бы вы ни делали в Что памятиfree всегда будет работать правильно, если вы передадите ему точно такой же указатель, возвращенный malloc. Конечно, если вы пишете вне его, все ставки выключены.

Это всего лишь еще один символ из malloc и free перспектива, им все равно, какие данные вы помещаете в память. Так что free все равно будет работать, добавляете ли вы в середине или не добавить на всех. Выделенное дополнительное пространство все равно будет там, оно не будет возвращено обратно в процесс, как только вы добавите память. Я лично предпочел бы выделить только необходимый объем памяти, а не выделять на какой-то верхней границе, как это будет просто напрасная трата ресурсов.

Как только вы получаете память из кучи, вызывая malloc (), память ваша, чтобы использовать. Вставка \0 похожа на вставку любого другого символа. Эта память останется в вашем распоряжении до тех пор, пока вы не освободите ее или пока ОС не потребует ее обратно.

The Это чистая конвенция для интерпретации символьных массивов как жала - это не зависит от управления памятью. Т. е., если вы хотите получить свои деньги обратно, вы должны позвонить realloc. Строка не заботится о памяти (что является источником многих проблем безопасности).

malloc просто выделяет кусок памяти .. Его до вас, чтобы использовать, как вы хотите и звонить из начального положения указателя... Вставка '\0 ' в середине не имеет никакого значения...

чтобы быть конкретным malloc не знает, какой тип памяти вы хотите (он возвращает onle указатель void) ..

предположим, вы хотите выделить 10 байт памяти, начиная с 0x10 до 0x19 ..

char * ptr = (char *)malloc(sizeof(char) * 10);

вставить значение null в 5-й позиции (0x14) не освобождает память 0x15 года...

однако свободный от 0x10 освобождает весь кусок 10 байт..

1. free() все равно будет работать с нулевым байтом в памяти

2. пространство будет оставаться впустую, пока free() вызывается, или если вы впоследствии не сократите выделение

Как правило, память память память. Его не волнует, что вы пишете в нем. Но у него есть раса, или если вы предпочитаете аромат (malloc, new, VirtualAlloc, HeapAlloc и т. д.). Это означает, что сторона, которая выделяет часть памяти, также должна предоставить средства для ее освобождения. Если ваш API поставляется в DLL, то он должен предоставлять какую-то свободную функцию. Это, конечно, накладывает бремя на абонента, не так ли? Так почему бы не поставить все нагрузка на абонента? Лучший способ борьбы с динамически выделенной памятью это не выделить ее самостоятельно. Попросите вызывающего выделить его и передать вам. Он знает, какой аромат он выделил, и он несет ответственность, чтобы освободить его всякий раз, когда он сделал с его помощью.

как абонент знает, сколько выделить? Как и многие API-интерфейсы Windows, ваша функция возвращает необходимое количество байтов при вызове, например, с нулевым указателем, а затем выполняет задание при наличии ненулевого указателя (используя IsBadWritePtr, если это так подходит для вашего случая, чтобы дважды проверить доступность).

Это также может быть намного более эффективным. Выделение памяти стоит очень дорого. Слишком много выделений памяти вызывают фрагментацию кучи, а затем распределения стоят еще больше. Вот почему в режиме ядра мы используем так называемые"look-aside списки". Чтобы свести к минимуму количество выделений памяти, мы повторно используем блоки, которые мы уже выделили и" освободили", используя службы, которые ядро NT предоставляет авторам драйверов. Если вы передадите на ответственность за выделение памяти для вашего абонента, то он может передавать вам дешевую память из стека (_alloca), или передавая вам ту же память снова и снова без каких-либо дополнительных выделений. Конечно, вам все равно, но вы позволяете своему абоненту отвечать за оптимальную обработку памяти.

подробнее об использовании нулевого Терминатора в C: Вы не можете выделить строку " C " вы можете выделить массив символов и сохранить строку в нем, но malloc и free просто видят его как массив запрошенной длины.

строка C - это не тип данных, а соглашение об использовании массива символов, где нулевой символ '\0' рассматривается как признак конца строки. Это способ передачи строк без необходимости передавать значение длины в качестве отдельного аргумента. Некоторые другие программы языки имеют явные строковые типы, которые хранят длину вместе с символьными данными, чтобы разрешить передачу строк в одном параметре.

функции, которые документируют свои аргументы как "строки C", передаются массивы символов, но не имеют возможности узнать, насколько велик массив без нулевого Терминатора, поэтому, если его нет, все пойдет ужасно неправильно.

вы заметите, что функции, которые ожидают массивы символов, которые не обязательно обрабатываются как строки, всегда будут требовать буфера параметр длины, который будет передан. Например, если вы хотите обработать данные char, где нулевой байт является допустимым значением, вы не можете использовать '\0' в качестве символа-Терминатора.

вы можете сделать то, что делают некоторые API MS Windows, где вы (вызывающий) передаете указатель и размер выделенной памяти. Если размер не достаточно, Вам говорят, сколько байтов выделить. Если этого было достаточно, используется память, и результатом является количество используемых байтов.

таким образом, решение о том, как эффективно использовать память осталось абонента. Они могут выделять фиксированные 255 байт (общие при работе с путями в Windows) и использовать результат от вызов функции, чтобы узнать, требуется ли больше байтов (не в случае с путями из-за MAX_PATH 255 без обхода Win32 API) или можно ли игнорировать большинство байтов... Вызывающий также может передать ноль в качестве размера памяти и точно сказать, сколько нужно выделить - не так эффективно с точки зрения обработки, но может быть более эффективным с точки зрения пространства.

вы можете, конечно, предварительно выделить верхний предел и использовать все или что-то меньше. Просто убедитесь, что вы на самом деле используете все или что-то меньше.

сделать два прохода тоже нормально.

вы задали правильные вопросы о компромиссах.

Как вы решаете?

сначала используйте два прохода, потому что:

1. you'll know you aren't wasting memory.
2. you're going to profile to find out where
   you need to optimize for speed anyway.
3. upperbounds are hard to get right before
   you've written and tested and modified and
   used and updated the code in response to new
   requirements for a while.
4. simplest thing that could possibly work.

вы также можете немного подтянуть код. Короче, как правило, лучше. И больше код использует преимущества известных правды, тем более мне удобно, что он делает то, что говорит.

char* copyWithoutDuplicateChains(const char* str)
    {
    if (str == NULL) return NULL;

    const char* s = str;
    char prev = *s;               // [prev][s+1]...
    unsigned int outlen = 1;      // first character counted

    // Determine length necessary by mimicking processing

    while (*s)
        { while (*++s == prev);  // skip duplicates
          ++outlen;              // new character encountered
          prev = *s;             // restart chain
        }

    // Construct output

    char* outstr = (char*)malloc(outlen);
    s = str;
    *outstr++ = *s;               // first character copied
    while (*s)
        { while (*++s == prev);   // skip duplicates
          *outstr++ = *s;         // copy new character
        }

    // done

    return outstr;
    }