Что самый безопасный путь состоит в том, чтобы раздать строки в C?

Ваш пример "update" завершен? Я бы не думал, что он будет компилироваться: он требует возврата значения, но вы никогда ничего не возвращаете. Вы никогда не делаете ничего will fullpath, но, возможно, это намеренно, возможно, вы просто хотите сказать, что когда вы делаете malloc, другие вещи ломаются.

Не видя вызывающей программы, невозможно однозначно сказать, что здесь происходит. Я предполагаю, что paths - это динамически выделенный блок, который был освобожден до вызова этой функции. В зависимости от реализации компилятора, освобожденный блок может казаться содержащим действительные данные до тех пор, пока будущий malloc не займет это место.

Обновление: чтобы действительно ответить на вопрос

Работа со строками - хорошо известная проблема в C. Если вы создаете массив фиксированного размера для хранения строки, вам придется беспокоиться о том, что длинная строка переполнит выделенное пространство. Это означает постоянную проверку размера строки при копировании, использование strncpy и strncat вместо обычных strcpy и strcat, или другие подобные приемы. Вы можете пропустить это и просто сказать: "Ну, никто никогда не будет иметь имя длиннее 60 символов" или что-то в этом роде, но всегда есть опасность, что кто-то это сделает. Даже при вводе чего-то, что должно иметь известный размер, например, номера социального страхования или ISBN, кто-то может ошибиться и дважды нажать на клавишу, или злоумышленник может намеренно ввести что-то длинное. И т.д. Конечно, в основном это проблема при вводе данных или чтении файлов. Как только у вас есть строка в поле какого-то известного размера, то для любых копий или других манипуляций вы знаете размер.

Альтернативой является использование динамически распределяемых буферов, где вы можете сделать их настолько большими, насколько это необходимо. Это звучит как хорошее решение, когда вы слышите его впервые, но на практике это гигантская боль в C, потому что выделение буферов и их освобождение, когда они вам больше не нужны, доставляет много хлопот. Другой постер здесь сказал, что функция, которая выделяет буфер, должна быть той же самой, которая его освобождает. Хорошее эмпирическое правило, я в целом согласен, но... Что если подпрограмма хочет вернуть строку? Она выделяет буфер, возвращает его и ... как она может освободить его? Никак, потому что смысл в том, что она хочет вернуть его вызывающей программе. Вызывающая сторона не может выделить буфер, потому что не знает его размера. Также невозможны такие, казалось бы, простые вещи, как:

if (strcmp(getMeSomeString(),stringIWantToCompareItTo)==0) etc

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

char* someString=getMeSomeString();
int f=strcmp(someString,stringIWantToCompareItTo);
free(someString);
if (f==0)
etc

Так что ладно, это работает, но читабельность только что резко упала.

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

Вы не можете вернуть указатель на массив, который размещен локально внутри функции. Как только функция вернется, этот массив будет уничтожен.

Кроме того, когда вы помещаете

char localstr[MAX_STRLENGTH] = strcpy(localstr, somestr);

, происходит то, что strcpy () копирует байты в массив localstr [], но тогда происходит ненужное присваивание. Вы, вероятно, могли бы получить желаемый эффект в виде двух строк, таким образом ..

char localstr[MAX_STRLENGTH];
strcpy(localstr, somestr);

Кроме того, это плохой тоном встраивать вызов free () в функцию, подобную этой. В идеале free () должен быть виден на том же уровне области видимости, на котором произошла malloc (). По той же логике несколько сомнительно выделять память в функции таким образом.

Если вы хотите, чтобы функция изменяла строку, общее соглашение выглядит примерно так

// use a prototype like this to use the same buffer for both input and output
int modifyMyString(char buffer[], int bufferSize) {
    // .. operate you find in buffer[],
    //    leaving the result in buffer[]
    //    and be sure not to exceed buffer length
    // depending how it went, return EXIT_FAILURE or maybe
    return EXIT_SUCCESS;

// or separate input and outputs
int workOnString(char inBuffer[], int inBufSize, char outBuffer[], int outBufSize) {
    // (notice, you could replace inBuffer with const char *)
    // leave result int outBuffer[], return pass fail status
    return EXIT_SUCCESS;

Отсутствие встраивания malloc () или free () внутрь также поможет избежать утечек памяти.