Strdup () - что он делает в C?

От мужчина:

Функция strdup() должна возвращать указатель на новую строку, которая является дубликатом строки, на которую указывает s1. Возвращенный указатель можно передать на free(). Если новая строка не может быть создана, возвращается нулевой указатель.

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

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

В точности то, на что это похоже, если вы привыкли к сокращенному способу, которым C и UNIX назначают слова, это дублирует строки :-)

Имея в виду, что ^(a) на самом деле не является частью стандарта ISO C (это POSIX), он фактически делает то же самое, что и следующий код:

char *strdup(const char *src) {
    char *dst = malloc(strlen (src) + 1);  // Space for length plus nul
    if (dst == NULL) return NULL;          // No memory
    strcpy(dst, src);                      // Copy the characters
    return dst;                            // Return the new string
}

Другими словами:

1. Он пытается выделить достаточно памяти для хранения старой строки (плюс символ '\ 0' для обозначения конца строки).

2. Если распределение не удалось, он устанавливает errno в ENOMEM и немедленно возвращает NULL. Установка errno на ENOMEM - это то, что malloc делает в POSIX, поэтому нам не нужно явно делать это в нашем strdup. Если вы совместимы с нет POSIX, ISO C фактически не требует наличия ENOMEM, поэтому я не включил это здесь ^(b).

3. В противном случае выделение сработало, поэтому мы копируем старую строку в новую строку ^(c) и возвращаем новый адрес (который вызывающий отвечает за освобождение в какой-то момент).

Имейте в виду, что это концептуальное определение. Любой писатель библиотеки, достойный своей зарплаты, мог предоставить сильно оптимизированный код, ориентированный на конкретный используемый процессор.

^(a) Однако функции, начинающиеся с str и строчной буквы, зарезервированы стандартом для будущих направлений. С C11 7.1.3 Reserved identifiers:

Each header declares or defines all identifiers listed in its associated sub-clause, and *optionally declares or defines identifiers listed in its associated future library directions sub-clause.**

Будущие направления для string.h можно найти в C11 7.31.13 String handling <string.h>:

Function names that begin with str, mem, or wcs and a lowercase letter may be added to the declarations in the <string.h> header.

Так что вам, вероятно, следует назвать это как-нибудь иначе, если вы хотите быть в безопасности.

^(b) В основном это изменение заключается в замене if (d == NULL) return NULL; на:

if (d == NULL) {
    errno = ENOMEM;
    return NULL;
}

^(c) Обратите внимание, что я использую для этого strcpy, поскольку это ясно показывает намерение. В некоторых реализациях может быть быстрее (поскольку длина вам уже известна) использовать memcpy, поскольку они могут позволять передавать данные большими порциями или параллельно. А может и нет :-) Оптимизационная мантра №1: «измеряйте, а не угадайте».

В любом случае, если вы решите пойти по этому пути, сделайте что-то вроде:

char *strdup(const char *src) {
    size_t len = strlen(src) + 1;       // String plus '\0'
    char *dst = malloc(len);            // Allocate space
    if (dst == NULL) return NULL;       // No memory
    memcpy (dst, src, len);             // Copy the block
    return dst;                         // Return the new string
}

Нет смысла повторять другие ответы, но обратите внимание, что strdup() может делать все, что захочет, с точки зрения C, поскольку он не является частью какого-либо стандарта C. Однако он определен в POSIX.1-2001.

char * strdup(const char * s)
{
  size_t len = 1+strlen(s);
  char *p = malloc(len);

  return p ? memcpy(p, s, len) : NULL;
}

Возможно, код немного быстрее, чем с strcpy(), поскольку символ \0 не требует повторного поиска (это уже было с strlen()).

strdup () выполняет динамическое выделение памяти для массива символов, включая конечный символ '\ 0', и возвращает адрес кучи памяти:

char *strdup (const char *s)
{
    char *p = malloc (strlen (s) + 1);   // allocate memory
    if (p != NULL)
        strcpy (p,s);                    // copy string
    return p;                            // return the memory
}

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

Функция strdup () является сокращением для дубликата строки, она принимает параметр как строковую константу или строковый литерал, выделяет достаточно места для строки и записывает соответствующие символы в выделенное пространство и, наконец, возвращает адрес выделенного пространство для вызывающей процедуры.

strdup и strndup определены в POSIX-совместимых системах как:

char *strdup(const char *str);
char *strndup(const char *str, size_t len);

Функция strdup () выделяет достаточно памяти для копии строка str, копирует и возвращает указатель на нее.

Указатель впоследствии можно использовать в качестве аргумента функции free.

Если доступно недостаточно памяти, возвращается NULL, а для errno устанавливается значение ENOMEM.

Функция strndup () копирует не более символов len из строки str, всегда завершая скопированную строку нулем.

Заявление:

strcpy(ptr2, ptr1);

эквивалентно (кроме того, что это изменяет указатели):

while(*ptr2++ = *ptr1++);

Тогда как:

ptr2 = strdup(ptr1);

эквивалентно:

ptr2 = malloc(strlen(ptr1) + 1);
if (ptr2 != NULL) strcpy(ptr2, ptr1);

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