Выделение памяти для языка char * C

Почти. Строки заканчиваются NULL, поэтому вы, вероятно, захотите выделить дополнительный байт для хранения байта NULL. То есть, хотя sides имеет длину 1 символ, на самом деле это 2 байта: {_2 _, _ 3_}.

Так было бы:

tempSides = (char *)malloc((strlen(sides)+1)*sizeof(char));

и если вы хотите скопировать его в:

strcpy(tempSides, sides);

Обратите внимание, что:

1. Строки заканчиваются нулем (\ 0), и strlen () не учитывает их;
2. По определению sizeof (char) равен 1 (байту), поэтому он не требуется;
3. Если вы используете компилятор C (не C ++), нет необходимости приводить его к char *;

Итак, это было бы:

char *tempSides = malloc(strlen(inSides) + 1);

Тем не менее, если вы хотите продублировать содержимое inSides, вы можете использовать strdup, например:

char *tempSides = strdup(inSides);
if (tempSides != NULL) {
    // do whatever you want...
    free(tempSides);
}

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

По определению sizeof(char) всегда равно 1, поэтому вы можете сократить строку выделения до:

tempSides = (char*)malloc(strlen(inSides) + 1);

Другое дело, что это похоже на то, что вы делаете дубликат строки. Есть встроенная функция, которая сделает это за вас:

tempSides = strdup(inSides);

Это обрабатывает получение длины, выделение правильного количества байтов и копирование данных.

С этим проблема. tempSides будет указывать на неинициализированный блок памяти размером 1. Если вы намереваетесь скопировать строку сторон в tempSides, вам нужно будет выделить размер на один байт больше, чтобы сохранить нулевой ограничитель для строки. Значение, возвращаемое функцией strlen (), не включает нулевой терминатор в конце строки.

Нет, не совсем. Как уже отмечали другие, вам нужно выделить место для терминатора NUL.

Кроме того, обычно вам не следует использовать возврат от malloc. Это может скрыть ошибку, из-за которой вы забыли #include правильный заголовок. Умножение на sizeof(char) также бессмысленно, поскольку стандарты (как C, так и C ++) определяют sizeof(char) всегда равным 1.

Наконец, каждый вызов malloc должен включать проверку результата. Я бы обернул все это в функцию:

char *dupe_string(char const *string) { 
    char *temp;
    if (NULL!=(temp=malloc(strlen(string)+1)))
        strcpy(temp, string);
    return temp;
}

Умножение количества элементов на sizeof(char) является делом личных предпочтений, поскольку sizeof(char) всегда равно 1. Однако, если вы делаете это для единообразия, лучше использовать тип указателя получателя для определения размера элемента вместо того, чтобы указывать тип явно. И не приводите результат malloc

tempSides = malloc(strlen(inSides) * sizeof *tempSides);

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

Правильный способ выделения динамической памяти для tempSides показан ниже:

char* sides ="5";
char* tempSides;
tempSides = (char*)malloc((strlen(sides) + 1) * sizeof(char));

char* хранит строковые данные, аналогичные char[]. Строки null (\0) завершаются. Таким образом, дополнительный один байт должен быть выделен для хранения null символов.

Динамически выделяемый блок памяти должен быть освобожден с помощью free() после его использования. Если не освободить, произойдет утечка памяти.

free(tempSides);

После освобождения памяти необходимо назначить NULL, чтобы он не был висящим указателем.

tempSides = NULL;