Исполняемые доки C: Функции для строк

Q: Почему нельзя сравнивать строки через == в C?

a == b сравнивает два адреса, а не символы. Два отдельных массива со словом "cat" лежат по разным адресам, поэтому сравнение ложно, хотя текст совпадает. Используйте strcmp(a, b) == 0 из .

Q: Чем strcpy отличается от strncpy?

strcpy копирует до '\0' источника, не имея понятия о размере приёмника. strncpy останавливается максимум на n байтах, но если источник такой длины, завершающий ноль не копируется, поэтому вы обязаны сами написать dst[n - 1] = '\0';. Автоматически безопасна ни та ни другая: дисциплина размеров на вас.

Q: Как найти подстроку в C?

strstr(haystack, needle) возвращает указатель на первое вхождение или NULL, если его нет. Поскольку указатель ведёт внутрь исходной строки, found - haystack даёт индекс. Для поиска одного символа используйте strchr.

Каждая функция из <string.h> — это небольшой цикл по массиву char, останавливающийся на завершающем нуле. Как только это понятно, библиотека перестаёт выглядеть списком загадочных имён и становится горсткой циклов, которые вы написали бы сами. Здесь разобраны те, что выполняют почти всю реальную работу, и правила расчёта размеров, не дающие им писать за конец ваших буферов.

Всему на этой странице нужен один заголовок:

#include <string.h>

strlen: сколько символов

strlen считает байты до завершающего нуля, не включая его. Возвращает size_t, поэтому печатайте результат через %zu.

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

int main(void) {
    char word[32] = "banana";

    printf("strlen = %zu\n", strlen(word));
    printf("sizeof = %zu\n", sizeof word);
    return 0;
}

strlen даёт 6, sizeof — 32. Первое — это текст, второе — хранилище; почему это различие так важно, см. в статье строки.

strlen при каждом вызове проходит всю строку, поэтому не ставьте его в условие цикла по одной и той же неизменной строке:

/* пересчитывает всю строку на каждой итерации */
for (size_t i = 0; i < strlen(s); i++) { ... }

/* посчитать один раз */
size_t n = strlen(s);
for (size_t i = 0; i < n; i++) { ... }

strcpy и strncpy: копирование

strcpy(dst, src) копирует символы вместе с завершающим нулём. Он не знает размера dst, поэтому вызывающий обязан гарантировать, что в dst помещается минимум strlen(src) + 1 байт.

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

int main(void) {
    char src[] = "portable";
    char dst[16];

    strcpy(dst, src);
    printf("%s\n", dst);

    /* правило размера, проверенное явно */
    if (strlen(src) + 1 <= sizeof dst) {
        printf("помещается, свободно ещё %zu байт\n", sizeof dst - strlen(src) - 1);
    }
    return 0;
}

strncpy принимает максимальное количество байт, но у него есть знаменитая ловушка: если источник длиной не меньше n, копируется ровно n символов и никакого завершающего нуля. Всегда завершайте строку сами:

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

int main(void) {
    char src[] = "a very long project name";
    char dst[10];

    strncpy(dst, src, sizeof dst - 1);
    dst[sizeof dst - 1] = '\0';        /* обязательно, а не по желанию */

    printf("[%s]\n", dst);
    return 0;
}

sizeof dst - 1 плюс явный завершающий ноль — тот шаблон, который стоит запомнить. (strncpy к тому же добивает короткий источник нулями до n байт, что для больших буферов лишняя работа: функция создавалась для записей фиксированной ширины, а не ради безопасности.)

strcat и strncat: склейка

strcat(dst, src) дописывает src в конец того, что уже лежит в dst. Приёмник должен вмещать обе строки плюс один завершающий ноль и обязан уже содержать корректную строку — дописывание в неинициализированную память есть неопределённое поведение.

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

int main(void) {
    char path[64] = "/home/ada";

    strcat(path, "/");
    strcat(path, "notes.txt");

    printf("%s\n", path);
    printf("занято %zu из %zu байт\n", strlen(path) + 1, sizeof path);
    return 0;
}

Обратите внимание на char path[64] = "/home/ada";, а не char path[64]; — именно инициализатор делает массив корректной строкой для первого strcat.

strncat(dst, src, n) дописывает не более n символов и всегда добавляет завершающий ноль, поэтому n — это оставшееся место, а не полный размер буфера:

strncat(dst, src, sizeof dst - strlen(dst) - 1);

Повторные вызовы strcat каждый раз заново просматривают приёмник в поисках его конца. Сборка длинной строки в цикле таким способом квадратична; для чего-то объёмного ведите собственную позицию записи или используйте snprintf, разобранный в статье преобразование строк.

strcmp: сравнение

== сравнивает адреса, поэтому для двух разных массивов с одинаковым текстом он ложен. strcmp сравнивает символы и возвращает знак разности.

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

int main(void) {
    char a[] = "apple";
    char b[] = "apple";
    char c[] = "banana";

    const char *pa = a;
    const char *pb = b;
    printf("pa == pb (адреса)? %s\n", pa == pb ? "да" : "нет");
    printf("strcmp(a, b) == 0?  %s\n", strcmp(a, b) == 0 ? "да" : "нет");

    printf("знак strcmp(a, c): %s\n", strcmp(a, c) < 0 ? "a раньше c" : "a позже c");
    return 0;
}

Три правила:

Для проверки равенства пишите strcmp(a, b) == 0. Запись if (strcmp(a, b)) означает «если они различаются», что почти для всех читается наоборот.
Определён только знак. Не сравнивайте результат с 1 или -1.
Порядок задаётся значениями байтов, поэтому в ASCII "Zebra" идёт раньше "apple". Для сравнения без учёта регистра сначала приведите обе копии к нижнему регистру: широко известный strcasecmp — расширение POSIX, а не стандартный C.

strncmp(a, b, n) сравнивает только первые n символов, и это опрятный способ проверить префикс:

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

int main(void) {
    const char *url = "https://coddy.tech";

    if (strncmp(url, "https://", 8) == 0) {
        printf("защищённый URL\n");
    }
    return 0;
}

strchr и strstr: поиск

strchr(s, ch) находит первое вхождение символа, strrchr — последнее. strstr(haystack, needle) находит подстроку. Все три возвращают указатель внутрь исходной строки или NULL, если совпадения нет.

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

int main(void) {
    char email[] = "ada@coddy.tech";

    char *at = strchr(email, '@');
    if (at != NULL) {
        printf("'@' по индексу %td\n", at - email);
        printf("домен: %s\n", at + 1);
    }

    char *dot = strrchr(email, '.');
    printf("зона: %s\n", dot != NULL ? dot + 1 : "(нет)");

    if (strstr(email, "coddy") != NULL) {
        printf("содержит \"coddy\"\n");
    }
    return 0;
}

Вычитание возвращённого указателя из начала даёт индекс; его тип — ptrdiff_t, печатается через %td. Поскольку результат указывает внутрь исходного массива, at + 1 — это остаток строки вообще без копирования, очень распространённая идиома C.

Всегда проверяйте на NULL перед разыменованием. strchr(email, '@') + 1 на строке без @ вычисляет адрес от NULL, и программа перестаёт быть определённой.

Разделение строки

Функции split здесь нет, но strchr плюс завершающий ноль делают работу прямо на месте. В этом примере адрес электронной почты разрезается на пользователя и домен:

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

int main(void) {
    char input[] = "ada@coddy.tech";
    char user[32];
    char domain[64];

    char *at = strchr(input, '@');
    if (at == NULL) {
        printf("это не адрес электронной почты\n");
        return 1;
    }

    size_t user_len = (size_t)(at - input);
    if (user_len >= sizeof user) {
        printf("имя пользователя слишком длинное\n");
        return 1;
    }

    memcpy(user, input, user_len);
    user[user_len] = '\0';

    strncpy(domain, at + 1, sizeof domain - 1);
    domain[sizeof domain - 1] = '\0';

    printf("пользователь: %s\n", user);
    printf("домен:        %s\n", domain);
    return 0;
}

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

Разобранный пример: приведение имени в порядок

Соберём обзор воедино — обрезка, сравнение, копирование и склейка:

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

int main(void) {
    char first[32] = "  ada  ";
    char last[32]  = "lovelace";
    char full[80];

    /* пропустить ведущие пробелы */
    char *start = first;
    while (*start == ' ') {
        start++;
    }

    /* срезать хвостовые пробелы */
    size_t len = strlen(start);
    while (len > 0 && start[len - 1] == ' ') {
        start[--len] = '\0';
    }

    /* сделать первую букву каждой части заглавной */
    start[0] = (char)toupper((unsigned char)start[0]);
    last[0]  = (char)toupper((unsigned char)last[0]);

    /* склеить с ограниченным копированием */
    strncpy(full, start, sizeof full - 1);
    full[sizeof full - 1] = '\0';
    strncat(full, " ", sizeof full - strlen(full) - 1);
    strncat(full, last, sizeof full - strlen(full) - 1);

    printf("[%s]\n", full);
    printf("это Ada Lovelace? %s\n",
           strcmp(full, "Ada Lovelace") == 0 ? "да" : "нет");
    return 0;
}

Каждая запись ограничена собственным sizeof приёмника, а за каждым strncpy следует явный завершающий ноль. Именно эта дисциплина, применяемая последовательно, и делает строковый код на C безопасным.

Правила размеров, которые стоит держать в голове

strcpy требует свободных strlen(src) + 1 байт в приёмнике.
strcat требует strlen(dst) + strlen(src) + 1.
После strncpy сами пишите dst[n - 1] = '\0'.
Для strncat счётчик — это оставшееся место: sizeof dst - strlen(dst) - 1.
Проверяйте результат strchr и strstr на NULL перед использованием.
Используйте sizeof dst только там, где dst — настоящий массив. Внутри функции, принимающей char *dst, sizeof даст размер указателя: передавайте длину буфера отдельным параметром.

Часто задаваемые вопросы

Что возвращает strcmp в C?

Ноль, когда строки одинаковы, отрицательное значение, когда первая идёт раньше по порядку, и положительное, когда позже. Смысл имеет только знак — никогда не рассчитывайте, что вернётся -1 или 1. Нужная вам проверка почти всегда выглядит как if (strcmp(a, b) == 0).

Почему нельзя сравнивать строки через == в C?

a == b сравнивает два адреса, а не символы. Два отдельных массива со словом "cat" лежат по разным адресам, поэтому сравнение ложно, хотя текст совпадает. Используйте strcmp(a, b) == 0 из <string.h>.

Чем strcpy отличается от strncpy?

strcpy копирует до '\0' источника, не имея понятия о размере приёмника. strncpy останавливается максимум на n байтах, но если источник такой длины, завершающий ноль не копируется, поэтому вы обязаны сами написать dst[n - 1] = '\0';. Автоматически безопасна ни та ни другая: дисциплина размеров на вас.

Как найти подстроку в C?

strstr(haystack, needle) возвращает указатель на первое вхождение или NULL, если его нет. Поскольку указатель ведёт внутрь исходной строки, found - haystack даёт индекс. Для поиска одного символа используйте strchr.

Связанные концепции

Функции для строк в C: strlen, strcpy, strcat, strcmp и другие