4.3. Символьная информация и строки
Теория
Зачем нужен этот пункт
До этого мы работали в основном с числами, массивами и указателями. Теперь нужно разобраться с текстовой информацией: отдельными символами, символьными массивами и строками.
В языке C нет отдельного встроенного типа string.
Строка в C — это массив символов типа char, который
заканчивается специальным нулевым символом '\0'.
В этом пункте рассматриваются:
- тип
char; - символьные константы;
- ввод и вывод символов через
%c; - внутренние коды символов;
- строковые литералы;
- строка как массив
char; - нулевой терминатор
'\0'; - инициализация строк;
- ввод и вывод строк;
- безопасная работа со строковыми буферами;
- ручная обработка текста;
- базовые функции из
string.h; - типичные ошибки при работе со строками.
Символьный тип char
Для хранения одного символа в C используется тип char.
char letter;
char digit;
char symbol;
Символьная переменная хранит один символ. Например:
char ch = 'A';
Символ записывается в апострофах:
'A'
'0'
'?'
' '
Запись ' ' означает символ пробела.
Символ — это ещё и числовой код
В памяти символ хранится как числовой код. Например, символ
'A' имеет один код, символ 'B' — другой,
символ '0' — третий.
Поэтому переменную типа char можно выводить и как символ,
и как число.
#include <stdio.h>
int main(void)
{
char ch = 'A';
printf("Символ: %c\n", ch);
printf("Код: %d\n", ch);
return 0;
}
Спецификатор %c выводит значение как символ.
Спецификатор %d выводит числовой код символа.
Ввод и вывод символов через scanf и printf
Для ввода и вывода одного символа используется спецификатор
%c.
#include <stdio.h>
int main(void)
{
char ch;
printf("Введите символ: ");
scanf("%c", &ch);
printf("Вы ввели: %c\n", ch);
return 0;
}
В scanf перед переменной пишется &,
потому что функции нужно передать адрес переменной, куда будет записан
введённый символ.
Пробел перед %c в scanf
При вводе символов важно помнить, что %c читает любой
следующий символ, включая пробел, табуляцию и перевод строки.
Если нужно пропустить пробельные символы перед вводом, в форматной
строке перед %c ставят пробел:
scanf(" %c", &ch);
Этот пробел в формате означает: сначала пропустить все пробельные символы, а затем прочитать один настоящий символ.
#include <stdio.h>
int main(void)
{
char answer;
printf("Введите y или n: ");
scanf(" %c", &answer);
if (answer == 'y')
{
printf("Да\n");
}
else if (answer == 'n')
{
printf("Нет\n");
}
else
{
printf("Неизвестный ответ\n");
}
return 0;
}
Функции getchar и putchar
Для посимвольного ввода и вывода также используются функции
getchar и putchar.
int getchar(void);
int putchar(int ch);
getchar читает один символ из стандартного ввода.
putchar выводит один символ в стандартный вывод.
#include <stdio.h>
int main(void)
{
int ch;
printf("Введите символ: ");
ch = getchar();
printf("Вы ввели: ");
putchar(ch);
putchar('\n');
return 0;
}
Переменная для результата getchar обычно имеет тип
int, а не char. Это нужно, чтобы можно было
отличить обычный символ от специального значения EOF.
EOF
EOF — это специальное значение, которое означает конец
входного потока или ошибку ввода.
#include <stdio.h>
int main(void)
{
int ch;
while ((ch = getchar()) != EOF)
{
putchar(ch);
}
return 0;
}
Эта программа читает символы из стандартного ввода и сразу выводит их
обратно. Цикл продолжается до тех пор, пока getchar
не вернёт EOF.
Символьные escape-последовательности
Некоторые символы невозможно удобно записать напрямую. Для них используются escape-последовательности.
| Запись | Смысл |
|---|---|
'\n' |
переход на новую строку |
'\t' |
табуляция |
'\0' |
нулевой символ |
'\\' |
обратная косая черта |
'\'' |
апостроф |
'\"' |
двойная кавычка |
Особенно важен символ '\0', потому что он используется
как признак конца строки.
Символы можно сравнивать и перебирать
Так как символы имеют числовые коды, их можно сравнивать. Например, можно проверить, является ли символ цифрой.
#include <stdio.h>
int main(void)
{
char ch;
printf("Введите символ: ");
scanf(" %c", &ch);
if (ch >= '0' && ch <= '9')
{
printf("Это цифра\n");
}
else
{
printf("Это не цифра\n");
}
return 0;
}
Символы цифр в таблице кодов обычно идут подряд:
'0', '1', '2' и так далее.
Поэтому проверка диапазона работает удобно.
Пример: вывод цифр и их кодов
#include <stdio.h>
int main(void)
{
char ch;
for (ch = '0'; ch <= '9'; ch++)
{
printf("Символ: %c, код: %d, hex: %x\n", ch, ch, ch);
}
return 0;
}
Здесь переменная ch увеличивается оператором
ch++. На каждой итерации она получает следующий код
символа цифры.
Строка в C
В C строка — это последовательность символов, которая заканчивается
нулевым символом '\0'.
H e l l o \0
То есть строка "Hello" занимает не 5, а 6 элементов
типа char:
'H', 'e', 'l', 'l', 'o', '\0'
Нулевой символ нужен для того, чтобы функции обработки строк понимали, где строка заканчивается.
Строковый литерал
Строковый литерал записывается в двойных кавычках:
"Hello"
"12345"
"Text with spaces"
"Line 1\nLine 2"
В отличие от символьной константы, строковый литерал содержит
завершающий нулевой символ '\0'.
| Запись | Что это | Размер по смыслу |
|---|---|---|
'A' |
один символ | один char |
"A" |
строка | 'A' и '\0' |
Поэтому 'A' и "A" — это не одно и то же.
Символьный массив как строка
Строку можно хранить в массиве типа char.
char text[6] = "Hello";
Массив будет содержать:
text[0] = 'H'
text[1] = 'e'
text[2] = 'l'
text[3] = 'l'
text[4] = 'o'
text[5] = '\0'
Если при инициализации размер массива не указан, компилятор сам подберёт нужный размер.
char text[] = "Hello";
В этом случае будет создан массив из 6 элементов.
Инициализация строки по символам
Строку можно записать и как обычный массив символов.
char text[] = { 'H', 'e', 'l', 'l', 'o', '\0' };
Эта запись эквивалентна:
char text[] = "Hello";
Важно не забыть '\0'. Без него массив будет просто набором
символов, но не корректной C-строкой.
char bad[] = { 'H', 'e', 'l', 'l', 'o' }; /* не строка */
Такой массив можно обрабатывать как массив символов фиксированной
длины, но нельзя безопасно передавать в функции, которые ждут
обычную строку с '\0' в конце.
Нельзя присвоить строку массиву через =
Массив можно инициализировать строкой при объявлении:
char text[20] = "Hello";
Но после объявления нельзя присвоить массиву новую строку обычным
оператором =.
char text[20];
text = "Hello"; /* ошибка */
Имя массива не является изменяемой переменной-указателем. Чтобы записать строку в уже существующий массив, используют ввод или функции копирования строк.
#include <string.h>
char text[20];
strcpy(text, "Hello");
При этом нужно следить, чтобы массив был достаточно большим.
Вывод строки
Для вывода строки через printf используется спецификатор
%s.
#include <stdio.h>
int main(void)
{
char text[] = "Hello";
printf("%s\n", text);
return 0;
}
При выводе %s функция начинает читать символы с адреса
первого элемента массива и продолжает до тех пор, пока не встретит
'\0'.
Поэтому строка обязательно должна быть завершена нулевым символом.
puts
Функция puts выводит строку и автоматически добавляет
перевод строки.
#include <stdio.h>
int main(void)
{
char text[] = "Hello";
puts(text);
return 0;
}
В отличие от:
printf("%s", text);
функция puts после вывода строки добавляет символ новой строки.
Ввод слова через scanf
Для ввода строки через scanf используется спецификатор
%s.
#include <stdio.h>
int main(void)
{
char word[20];
printf("Введите слово: ");
scanf("%19s", word);
printf("Слово: %s\n", word);
return 0;
}
Здесь не пишется &word, потому что имя массива
word во многих выражениях уже преобразуется в адрес
первого элемента.
Важно: %s читает только до первого пробела.
Если пользователь введёт:
Hello world
в массив word попадёт только:
Hello
Число 19 в %19s ограничивает количество
вводимых символов, чтобы оставить место для '\0'.
Ввод строки с пробелами через fgets
Если нужно прочитать строку целиком, включая пробелы, лучше использовать
fgets.
#include <stdio.h>
int main(void)
{
char line[80];
printf("Введите строку: ");
if (fgets(line, sizeof(line), stdin) != NULL)
{
printf("Вы ввели: %s", line);
}
return 0;
}
Функция fgets получает:
- массив, куда нужно записать строку;
- размер этого массива;
- поток ввода, например
stdin.
fgets безопаснее неограниченного ввода, потому что знает
размер буфера и не должна записывать за его пределы.
Символ новой строки после fgets
Если в буфере хватило места, fgets обычно сохраняет символ
новой строки '\n', который появляется после нажатия
Enter.
#include <stdio.h>
#include <string.h>
int main(void)
{
char line[80];
size_t len;
printf("Введите строку: ");
if (fgets(line, sizeof(line), stdin) != NULL)
{
len = strlen(line);
if (len > 0 && line[len - 1] == '\n')
{
line[len - 1] = '\0';
}
printf("Без перевода строки: [%s]\n", line);
}
return 0;
}
Здесь strlen вычисляет длину строки без учёта
завершающего '\0'. Если последний символ перед
'\0' равен '\n', он заменяется на
'\0'.
Почему не нужно использовать gets
В старых учебниках можно встретить функцию gets.
Она читает строку до нажатия Enter, но не знает размер
массива, куда записывает данные.
char line[80];
gets(line); /* опасно */
Если пользователь введёт слишком длинную строку, данные выйдут
за границы массива. Поэтому в учебном курсе лучше сразу использовать
fgets.
fgets(line, sizeof(line), stdin);
strlen
Функция strlen из заголовочного файла string.h
вычисляет длину строки.
#include <string.h>
size_t strlen(const char *s);
Длина строки — это количество символов до первого '\0'.
Сам нулевой символ в длину не входит.
#include <stdio.h>
#include <string.h>
int main(void)
{
char text[] = "Hello";
printf("strlen(text) = %zu\n", strlen(text));
printf("sizeof(text) = %zu\n", sizeof(text));
return 0;
}
Для строки "Hello" результат будет таким:
strlen(text) = 5
sizeof(text) = 6
strlen считает символы до '\0',
а sizeof для настоящего массива показывает размер всего
массива, включая '\0'.
Ручное вычисление длины строки
Чтобы понять, как работают строковые функции, полезно написать вычисление длины вручную.
#include <stdio.h>
int main(void)
{
char text[] = "Hello";
int i = 0;
while (text[i] != '\0')
{
i++;
}
printf("Длина = %d\n", i);
return 0;
}
Цикл идёт по массиву до тех пор, пока не встретит завершающий нулевой символ.
Копирование строки вручную
Строку нельзя присвоить массиву через =, но её можно
скопировать посимвольно.
#include <stdio.h>
int main(void)
{
char source[] = "Hello";
char destination[20];
int i = 0;
while (source[i] != '\0')
{
destination[i] = source[i];
i++;
}
destination[i] = '\0';
printf("%s\n", destination);
return 0;
}
После копирования обычных символов нужно отдельно записать
'\0', чтобы массив destination стал корректной
строкой.
strcpy
Для копирования строки можно использовать функцию strcpy
из string.h.
#include <stdio.h>
#include <string.h>
int main(void)
{
char source[] = "Hello";
char destination[20];
strcpy(destination, source);
printf("%s\n", destination);
return 0;
}
Важно: массив назначения должен быть достаточно большим,
чтобы вместить все символы исходной строки и завершающий
'\0'.
Сравнение строк
Строки нельзя сравнивать через == как обычные числа.
char a[] = "cat";
char b[] = "cat";
if (a == b) /* ошибка по смыслу */
{
printf("same\n");
}
Здесь сравниваются адреса массивов, а не содержимое строк.
Для сравнения содержимого используется функция strcmp.
#include <stdio.h>
#include <string.h>
int main(void)
{
char a[] = "cat";
char b[] = "cat";
if (strcmp(a, b) == 0)
{
printf("Строки равны\n");
}
else
{
printf("Строки различаются\n");
}
return 0;
}
Функция strcmp возвращает 0, если строки
равны.
Объединение строк
Для присоединения одной строки к концу другой используется функция
strcat.
#include <stdio.h>
#include <string.h>
int main(void)
{
char text[40] = "Hello";
char tail[] = ", world";
strcat(text, tail);
printf("%s\n", text);
return 0;
}
После выполнения strcat массив text будет
содержать строку:
Hello, world
Массив text должен быть достаточно большим, чтобы вместить
итоговую строку и завершающий '\0'.
Поиск символа в строке
Строку можно обрабатывать как обычный массив символов. Например, можно найти первое вхождение символа.
#include <stdio.h>
int main(void)
{
char text[] = "banana";
char target = 'a';
int i = 0;
int found = -1;
while (text[i] != '\0')
{
if (text[i] == target)
{
found = i;
break;
}
i++;
}
if (found != -1)
{
printf("Символ найден, индекс = %d\n", found);
}
else
{
printf("Символ не найден\n");
}
return 0;
}
Цикл идёт до '\0'. Если найден нужный символ,
запоминается его индекс и цикл завершается.
Подсчёт символов в строке
Частая задача — посчитать, сколько раз в строке встречается определённый символ.
#include <stdio.h>
int main(void)
{
char text[] = "banana";
char target = 'a';
int i = 0;
int count = 0;
while (text[i] != '\0')
{
if (text[i] == target)
{
count++;
}
i++;
}
printf("Количество символов '%c': %d\n", target, count);
return 0;
}
Удаление повторяющихся пробелов
Рассмотрим задачу: пользователь вводит предложение, слова разделены пробелами, предложение заканчивается точкой. Нужно вывести текст, оставив между словами только один пробел.
#include <stdio.h>
int main(void)
{
char current;
char previous = ' ';
printf("Введите предложение с точкой в конце:\n");
do
{
scanf("%c", ¤t);
if (!(current == ' ' && previous == ' '))
{
printf("%c", current);
}
previous = current;
} while (current != '.');
return 0;
}
Здесь используются две переменные:
current— текущий введённый символ;previous— предыдущий символ.
Если текущий символ — пробел и предыдущий символ тоже пробел, текущий пробел не выводится. Во всех остальных случаях символ выводится.
Выделение последнего слова предложения
Теперь рассмотрим более сложную задачу: ввести предложение, заканчивающееся точкой, и напечатать последнее слово.
#include <stdio.h>
int main(void)
{
char word[80];
char current;
char previous = ' ';
int length = 0;
int i;
printf("Введите предложение с точкой в конце:\n");
for (i = 0; i < 79; i++)
{
current = getchar();
if (current == EOF || current == '\n')
{
break;
}
if (current == '.')
{
break;
}
if (current == ' ')
{
previous = current;
continue;
}
if (previous == ' ')
{
length = 0;
}
word[length] = current;
length++;
previous = current;
}
if (current != '.' || length == 0)
{
printf("Неверное предложение\n");
}
else
{
word[length] = '\0';
printf("Последнее слово: %s\n", word);
}
return 0;
}
Идея такая:
- символы читаются по одному;
- если встретился пробел, он пропускается;
- если после пробела начинается новое слово, длина текущего слова сбрасывается;
- в массиве
wordвсё время хранится последнее прочитанное слово; - когда встречается точка, в конец слова добавляется
'\0'.
Строка и указатель на char
Так как строка хранится в массиве char, с ней можно
работать через указатель.
#include <stdio.h>
int main(void)
{
char text[] = "Hello";
char *p = text;
while (*p != '\0')
{
putchar(*p);
p++;
}
putchar('\n');
return 0;
}
Сначала p указывает на первый символ строки.
На каждой итерации выводится *p, после чего указатель
переходит к следующему символу.
char array и char pointer
Есть важное различие между массивом символов и указателем на строковый литерал.
char a[] = "Hello";
char *p = "Hello";
В первом случае создаётся изменяемый массив:
a[0] = 'h'; /* можно */
Во втором случае p указывает на строковый литерал.
Изменять строковый литерал нельзя.
p[0] = 'h'; /* ошибка: изменять строковый литерал нельзя */
Если строку нужно менять, используй массив:
char text[20] = "Hello";
Массив строк
Массив строк часто удобно хранить как массив указателей на строковые литералы.
#include <stdio.h>
int main(void)
{
char *words[] = {
"red",
"green",
"blue"
};
int i;
int count = sizeof(words) / sizeof(words[0]);
for (i = 0; i < count; i++)
{
printf("%s\n", words[i]);
}
return 0;
}
Здесь words — массив указателей. Каждый элемент массива
указывает на начало отдельной строки.
Такую строку нельзя изменять, потому что элементы указывают на строковые литералы. Если строки нужно изменять, нужны массивы символов достаточного размера.
Двумерный массив символов
Если нужно хранить несколько изменяемых строк одинакового максимального
размера, можно использовать двумерный массив char.
#include <stdio.h>
#include <string.h>
int main(void)
{
char words[3][20];
strcpy(words[0], "red");
strcpy(words[1], "green");
strcpy(words[2], "blue");
printf("%s\n", words[0]);
printf("%s\n", words[1]);
printf("%s\n", words[2]);
return 0;
}
Здесь каждая строка может занимать до 19 обычных символов плюс
завершающий '\0'.
Строки и кодировка
Важно понимать: тип char хранит байт. В английском тексте
один символ обычно занимает один байт, поэтому примеры выглядят просто.
Но в кодировке UTF-8 русские буквы обычно занимают больше одного байта.
Поэтому функция strlen считает не «видимые буквы»,
а количество байтов до '\0'.
#include <stdio.h>
#include <string.h>
int main(void)
{
char text[] = "Привет";
printf("strlen = %zu\n", strlen(text));
return 0;
}
В UTF-8 результат может быть больше, чем количество видимых букв. Для начального курса лучше отрабатывать алгоритмы на ASCII-строках, а особенности кодировок изучать отдельно.
ctype.h: проверка символов
Для проверки символов есть стандартный заголовок ctype.h.
#include <ctype.h>
Часто используются функции:
| Функция | Смысл |
|---|---|
isdigit(ch) |
проверяет, является ли символ цифрой |
isalpha(ch) |
проверяет, является ли символ буквой |
isspace(ch) |
проверяет пробельный символ |
toupper(ch) |
преобразует букву к верхнему регистру |
tolower(ch) |
преобразует букву к нижнему регистру |
#include <stdio.h>
#include <ctype.h>
int main(void)
{
char ch;
printf("Введите символ: ");
scanf(" %c", &ch);
if (isdigit((unsigned char)ch))
{
printf("Цифра\n");
}
else if (isalpha((unsigned char)ch))
{
printf("Буква\n");
}
else
{
printf("Другой символ\n");
}
return 0;
}
Мини-пример: подсчёт букв, цифр и пробелов
#include <stdio.h>
#include <ctype.h>
int main(void)
{
char line[100];
int i = 0;
int letters = 0;
int digits = 0;
int spaces = 0;
printf("Введите строку: ");
if (fgets(line, sizeof(line), stdin) == NULL)
{
printf("Ошибка ввода\n");
return 0;
}
while (line[i] != '\0')
{
if (isalpha((unsigned char)line[i]))
{
letters++;
}
else if (isdigit((unsigned char)line[i]))
{
digits++;
}
else if (isspace((unsigned char)line[i]))
{
spaces++;
}
i++;
}
printf("Буквы: %d\n", letters);
printf("Цифры: %d\n", digits);
printf("Пробельные символы: %d\n", spaces);
return 0;
}
В этом примере строка просматривается посимвольно до '\0'.
Каждый символ проверяется функциями из ctype.h.
Буфер и выход за границы
При работе со строками нужно всегда помнить размер массива.
char text[6] = "Hello";
Здесь места хватает ровно на:
H e l l o \0
Если попытаться записать более длинную строку, данные выйдут за границы массива.
char text[6];
strcpy(text, "Hello, world"); /* ошибка: массив слишком мал */
Такая ошибка опасна: она может повредить соседние данные в памяти.
Типичные ошибки
Ошибка 1. Путаница между символом и строкой
char ch = "A"; /* ошибка */
char ch = 'A'; /* правильно */
'A' — символ. "A" — строка из двух элементов:
'A' и '\0'.
Ошибка 2. Нет места под '\0'
char text[5] = "Hello"; /* ошибка: нужно 6 элементов */
Для строки "Hello" нужно 6 элементов:
5 букв и завершающий '\0'.
Ошибка 3. Забыли нулевой терминатор
char text[5] = { 'H', 'e', 'l', 'l', 'o' };
printf("%s\n", text); /* ошибка по смыслу */
Массив не содержит '\0', поэтому printf
не знает, где строка заканчивается.
Ошибка 4. Присваивание массиву строки через =
char text[20];
text = "Hello"; /* ошибка */
Для копирования строки используй ввод или функцию копирования,
например strcpy, если буфер достаточно большой.
Ошибка 5. Сравнение строк через ==
if (text == "yes") /* ошибка по смыслу */
{
printf("yes\n");
}
Для сравнения строк используется strcmp.
if (strcmp(text, "yes") == 0)
{
printf("yes\n");
}
Ошибка 6. Опасный ввод без ограничения длины
char word[20];
scanf("%s", word); /* опасно */
Лучше ограничить количество символов:
scanf("%19s", word);
Ошибка 7. Изменение строкового литерала
char *p = "Hello";
p[0] = 'h'; /* ошибка */
Если строку нужно изменять, используй массив:
char p[] = "Hello";
p[0] = 'h';
Ошибка 8. Ожидание, что strlen считает видимые русские буквы
strlen("Привет")
В UTF-8 результат может быть количеством байтов, а не количеством видимых букв.
Практические рекомендации
- Для одного символа используй
charи апострофы:'A'. - Для строки используй массив
charи двойные кавычки:"Hello". - Всегда оставляй место под завершающий
'\0'. - Помни, что C-строка заканчивается нулевым символом.
- Для вывода символа используй
%c. - Для вывода строки используй
%s. - Для ввода слова через
scanfограничивай длину:%19s. - Для ввода строки с пробелами используй
fgets. - Не используй
gets. - Не сравнивай строки через
==; используйstrcmp. - Не присваивай строку массиву через
=; используй копирование. - Не изменяй строковые литералы через
char *. - Для базовых строковых функций подключай
string.h. - Для проверки символов подключай
ctype.h.
Мини-разбор программы
Программа вводит строку, удаляет символ новой строки после
fgets, считает длину, количество цифр и количество пробелов.
#include <stdio.h>
#include <string.h>
#include <ctype.h>
int main(void)
{
char line[100];
size_t len;
int i;
int digits = 0;
int spaces = 0;
printf("Введите строку: ");
if (fgets(line, sizeof(line), stdin) == NULL)
{
printf("Ошибка ввода\n");
return 0;
}
len = strlen(line);
if (len > 0 && line[len - 1] == '\n')
{
line[len - 1] = '\0';
len--;
}
for (i = 0; line[i] != '\0'; i++)
{
if (isdigit((unsigned char)line[i]))
{
digits++;
}
if (line[i] == ' ')
{
spaces++;
}
}
printf("Строка: [%s]\n", line);
printf("Длина: %zu\n", len);
printf("Цифры: %d\n", digits);
printf("Пробелы: %d\n", spaces);
return 0;
}
Разберём программу:
line[100]— массив символов для хранения строки;fgetsчитает строку с ограничением размера буфера;strlenвычисляет длину строки до'\0';- если в конце есть
'\n', он заменяется на'\0'; - цикл
forпросматривает строку до нулевого символа; isdigitпроверяет цифры;- пробелы считаются сравнением с символом
' '.
Что нужно запомнить
charиспользуется для хранения одного символа.- Символьная константа записывается в апострофах:
'A'. - Строковый литерал записывается в двойных кавычках:
"A". 'A'и"A"— разные вещи.- В C строка — это массив
char, заканчивающийся'\0'. - Нулевой символ
'\0'показывает конец строки. - Для строки из
nвидимых символов нужен массив минимум изn + 1элементов. %cиспользуется для символов.%sиспользуется для строк.- Имя массива символов при передаче в функцию обычно даёт адрес первого элемента.
strlenсчитает длину строки без завершающего'\0'.sizeofнастоящего массива показывает размер всего массива.- Строки нельзя сравнивать через
==. - Строковые литералы нельзя изменять.
- При вводе строк нужно контролировать размер буфера.
Самопроверка перед переходом дальше
- Для чего используется тип
char? - Чем отличается
'A'от"A"? - Какой спецификатор используется для вывода символа?
- Какой спецификатор используется для вывода строки?
- Что такое нулевой терминатор?
- Почему строка
"Hello"занимает 6 элементовchar? - Почему строку нельзя присвоить массиву через
=? - Почему для
scanf("%s", word)не пишут&word? - Почему
scanf("%s", word)не читает строку с пробелами целиком? - Для чего используется
fgets? - Почему после
fgetsиногда нужно удалить'\n'? - Что возвращает
strlen? - Чем отличается
strlen(text)отsizeof(text)? - Почему нельзя сравнивать строки через
==? - Что делает
strcmp? - Почему нельзя изменять строковый литерал через
char *? - Что может произойти, если строка не содержит
'\0'?