Библиотека работы со строками c. Функции обработки строк в Cи
Библиотека функций языков С и C++ включает богатый набор функций обработки строк и символов. Строковые функции работают с символьными массивами, завершающимися нулевыми символами. В языке С для использования строковых функций необходимо включить в начало модуля программы заголовочный файл
Поскольку в языках С и C++ при выполнении операций с массивами не предусмотрен автоматический контроль нарушения их границ, вся ответственность за переполнение массивов ложится на плечи программиста. Пренебрежение этими тонкостями может привести программу к аварийному отказу.
В языках С и C++ печатаемыми являются символы, отображаемые на терминале. В ASCII-средах они расположены между пробелом(0x20) и тильдой(OxFE). Управляющие символы имеют значения, лежащие в диапазоне между нулем и Ox1F; к ним также относится символ DEL(Ox7F).
Исторически сложилось так, что аргументами символьных функций являются целые значения, из которых используется только младший байт. Символьные функции автоматически преобразуют свои аргументы в тип unsigned char. Безусловно, вы вольны вызывать эти функции с символьными аргументами, поскольку символы автоматически возводятся в ранг целых в момент вызова функции.
В заголовке
В версии С99 к некоторым параметрам нескольких функций, первоначально определенных в версии С89, добавлен квалификатор restrict. При рассмотрении каждой такой функции будет приведен ее прототип, используемый в среде С89(а также в среде C++), а параметры с атрибутом restrict будут отмечены в описании этой функции.
Список функций
Проверка на принадлежность
isalnum - Проверка на принадлежность символа к алфавитно-цифровым
isalpha - Проверка на принадлежность символа к буквам
isblank - Проверка пустого символа
iscntrl - Проверка на принадлежность символа к управляющим
isdigit - Проверка на принадлежность символа к цифровым
isgraph - Проверка на принадлежность символа к печатным но не к пробелу
islower - Проверка на принадлежность символа к строчным
isprint - Проверка на принадлежность символа к печатным
ispunct - Проверка на принадлежность символа к знакам пунктуации
isspace - Проверка на принадлежность символа к пробельным
isupper - Проверка на принадлежность символа к прописным
isxdigit - Проверка на принадлежность символа к шестнадцатеричным
Работа с символьными массивами
memchr - Просматривает массив чтобы отыскать первое вхождение символа
memcmp - Сравнивает определённое количество символов в двух массивах
memcpy - Копирует символы из одного массива в другой
memmove - Копирует символы из одного массива в другой с учётом перекрытия массивов
memset - Заполняет определённое количество символов массива заданным
Манипуляции над строками
strcat - Присоединяет копию одной строки к заданной
strchr - Возвращает указатель на первое вхождение младшего байта заданного параметра
strcmp - Сравнивает в лексикографическом порядке две строки
strcoll - Сравнивает одну строку с другой в соответствии с параметром setlocale
strcpy - Копирует содержимое одной строки в другую
strcspn - Возвращает строку в которой отсутствуют заданные символы
strerror - Возвращает указатель на строку содержащую системное сообщение об ошибке
strlen - Возвращает длину строки с завершающим нулевым символом
Неслучайно тему про строки я поместил в раздел "Массивы". Так как строка это, по сути, массив символов. Вот пример:
char str = "Это просто строка";
Эту же строчку для большего понимания можно записать вот так:
char str = {"Э","т","о"," ","п","р","о","с","т","о","","с","т","р","о","к","а"};
Т.е. все тот же массив, только состоящий уже из символов. Поэтому работать с ним можно, так же как и с целочисленными массивами.
А теперь давайте попробуем работать со строками в c . На вводных уроках мы разбирали, что символы относятся к целочисленным типам, т.е. каждый символ имеет свое числовое значение. Вот пример и его решение:
- требуется перевести введенное слово в верхний регистр:
#include
#include
Int main()
{
char str = "sergey";
str[i] -= 32;
}
for (int i=0; str[i] != "\0";i++){
printf ("%c", str[i]);
}
getch();
Return 0;
}
для получения кода числа просто воспользуйтесь в функции printf спецификатором %d. Да, и еще один важный момент: окончанием любой строки является нуль-терминатор, который обозначается специальным символом - "\0".
Еще одним способом указания строки является объявление ее через char*. Вот пример:
char *str = "provod";
Т.е. создается указатель на строку, который располагается где-то в памяти.
А вот как можно вводить строки через, нам уже родной, опертаор scanf:
char str; scanf("%s", str);
Тут две тонкости:
- знак взятия адреса тут не нужен, так как имя массива, как мы уже знаем, и является адресом
- Длина вводимой строки не должна превышать 15 символов, так как последним обязательно должен быть нуль-терминатор. Причем компилятор сам заполнит этот символ после последнего введенного вашего символа.
Так как язык Си является языком структурным, то существуют уже встроенные функции для работы со строками и с символами. Для обработки строк вам понадобится подключить файл: ctype.h. Файл содержит функции определения регистра, формата символов. В принципе, все, что вам может понадобится узнать о символе, можно выполнить с помощью функций файла ctype.h
Иногда вам может понадобиться перевести строку в другой тип данных. Для перевода строк в другие типы существует библиотека stdlib. Вот ее функции:
- int atoi (char *str)
- long atol (char *str)
- double atof (char *str)
Иногда эти функции очень помогают, например, когда вам надо извлечь из строки год или цифровое значение. Работа со строками в c (си) является очень важной темой, поэтому постарайтесь вникнуть в этот урок.
Строки. Ввод-вывод строк. Форматированный ввод-вывод. Обработка строк с использованием стандартных функций языка С. Работа с памятью.
1.1. Объявление и инициализация строк.
Строкой называется массив символов, который заканчивается пустым символом ‘\0’. Строка объявляется как обычный символьный массив, например,
char s1; // строка длиной в девять символов
char *s2; // указатель на строку
Различие между указателями s1 и s2 заключается в том, что указатель s1 является именованной константой, а указатель s2 – переменной.
Строковые константы заключаются в двойные кавычки в отличие от символов, которые заключаются в одинарные кавычки. Например,
“This is a string.”
Длина строковой константы не может превышать 509 символов по стандарту. Однако, многие реализации допускают строки большей длины.
При инициализации строк размерность массива лучше не указывать, это выполнит компилятор, подсчитав длину строки и добавив к ней единицу. Например,
char s1 = “This is a string.”;
В языке программирования С для работы со строками существует большое количество функций, прототипы которых описаны в заголовочных файлах stdlib.h и string.h. Работа с этими функциями будет рассмотрена в следующих параграфах.
1.2. Ввод-вывод строк.
Для ввода строки с консоли служит функция
char* gets (char *str);
которая записывает строку по адресу str и возвращает адрес введенной строки. Функция прекращает ввод, если встретит символ ‘\n’ или EOF (конец файла). Символ перехода на новую строку не копируется. В конец прочитанной строки помещается нулевой байт. В случае успеха функция возвращает указатель на прочитанную строку, а в случае неудачи NULL.
Для вывода строки на консоль служит стандартная функция
int puts (const char *s);
которая в случае удачи возвращает неотрицательное число, а в случае неудачи – EOF.
Прототипы функций gets и puts описаны в заголовочном файле stdio.h.
#include
printf("Input String: ");
1.3. Форматированный ввод-вывод.
Для форматированного ввода данных с консоли используется функция
int scanf (const char *format, …);
которая в случае успешного завершения возвращает количество единиц прочитанных данных, а в случае неудачи – EOF. Параметр format должен указывать на форматируемую строку, которая содержит спецификации форматов ввода. Количество и типы аргументов, которые следуют после строки форматирования, должны соответствовать количеству и типам форматов ввода, заданным в строке форматирования. Если это условие не выполняется, то результат работы функции непредсказуем.
Пробел, символы "\t" или "\n" в форматной строке описывают один или более пустых символов во входном потоке, к которым относятся символы: пробел, ‘\t’, ‘\n’, ‘\v’, ‘\f’. Функция scanf пропускает пустые символы во входном потоке.
Литеральные символы в форматной строке, за исключением символа %, требуют, чтобы во входном потоке появились точно такие же символы. Если такого символа нет, то функция scanf прекращает ввод. Функция scanf пропускает литеральные символы.
В общем случае спецификация формата ввода имеет вид:
%[*] [ширина] [модификаторы] тип
Символ ‘*’ обозначает пропуск при вводе поля, определенного данной спецификацией;
- ‘ширина’ определяет максимальное число символов, вводимых по данной спецификации;
Тип может принимать следующие значения:
c – символьный массив,
s – строка символов, строки разделяются пустыми символами,
d – целое число со знаком в 10 с/c,
i – целое число со знаком, система счисления завит от двух первых цифр,
u – целое число без знака в 10 с/с,
o – целое число без знака в 8 с/c,
х, Х – целое число без знака в 16 с/с,
e, E, f, g, G – плавающее число,
p – указатель на указатель,
n – указатель на целое,
[…] – массив сканируемых символов, например, .
В последнем случае из входного потока будут вводиться только символы, заключенные в квадратные скобки. Если первый символ внутри квадратных скобок равен ‘^’, то вводятся только те символы, которые не входят в массив. Диапазон символов в массиве задается через символ ‘-‘. При вводе символов ведущие пустые символы и завершающий нулевой байт строки также вводятся.
Модификаторы могут принимать следующие значения:
h – короткое целое,
l, L – длинное целое или плавающее,
и используются только для целых или плавающих чисел.
В следующем примере показаны варианты использования функции scanf. Обратите внимание, что перед спецификатором формата, начиная с ввода плавающего числа, стоит символ пробел.
#include
printf("Input an integer: ");
scanf("%d", &n);
printf("Input a double: ");
scanf(" %lf", &d);
printf("Input a char: ");
scanf(" %c", &c);
printf("Input a string: ");
scanf(" %s", &s);
Обратите внимание, что в этой программе число с плавающей точкой проинициализировано. Это сделано для того, чтобы компилятор подключил библиотеку для поддержки работы с плавающими числами. Если этого не сделать, то на этапе выполнения при вводе плавающего числа произойдет ошибка.
Для форматированного вывода данных на консоль используется функция
int printf (const char *format, …);
которая в случае успешного завершения возвращает количество единиц выведенных данных, а в случае неудачи – EOF. Параметр format представляет собой форматируемую строку, которая содержит спецификации форматов вывода. Количество и типы аргументов, которые следуют после строки форматирования, должны соответствовать количеству и типам спецификациям формата вывода, заданным в строке форматирования. В общем случае спецификация формата вывода имеет вид:
%[флаги] [ширина] [.точность] [модификаторы] тип
- ‘флаги’ – это различные символы, уточняющие формат вывода;
- ‘ширина’ определяет минимальное количество символов, выводимых по данной спецификации;
- ‘.точность’ определяет максимальное число выводимых символов;
- ‘модификаторы’ уточняют тип аргументов;
- ‘тип’ определяет тип аргумента.
Для вывода целых чисел со знаком используется следующий формат вывода:
%[-] [+ | пробел] [ширина] [l] d
- – выравнивание влево, по умолчанию – вправо;
+ – выводится знак ‘+’, заметим, что для отрицательных чисел всегда выводится знак ‘-‘;
‘пробел’ – в позиции знака выводится пробел;
d – тип данных int.
Для вывода целых чисел без знака используется следующий формат вывода:
%[-] [#] [ширина] [l]
# – выводится начальный 0 для чисел в 8 c/c или начальные 0x или 0X для чисел в 16 c/c,
l – модификатор типа данных long;
u – целое число в 10c/c,
o – целое число в 8 c/c,
x, X – целое число в 16 c/c.
Для вывода чисел с плавающей точкой используется следующий формат вывода:
%[-] [+ | пробел] [ширина] [.точность]
"точность" – обозначает число цифр после десятичной точки для форматов f, e и E или число значащих цифр для форматов g и G. Числа округляются отбрасыванием. По умолчанию принимается точность в шесть десятичных цифр;
f – число с фиксированной точкой,
e – число в экспоненциальной форме, экспонента обозначается буквой "e",
E – число в экспоненциальной форме, экспонента обозначается буквой "E",
g – наиболее короткий из форматов f или g,
G – наиболее короткий из форматов f или G.
printf ("n = %d\n f = %f\n e = %e\n E = %E\n f = %.2f", -123, 12.34, 12.34, 12.34, 12.34);
// печатает: n = 123 f = 12.340000 e = 1.234000e+001 E = 1.234000E+001 f = 12.34
1.4. Форматирование строк.
Существуют варианты функций scanf и printf, которые предназначены для форматирования строк и называются соответственно sscanf и sprintf.
int sscanf (const char *str, const char *format, …);
читает данные из строки, заданной параметром str, в соответствии с форматной строкой, заданной параметром format. В случае удачи возвращает количество прочитанных данных, а в случае неудачи – EOF. Например,
#include
char str = "a 10 1.2 String No input";
sscanf(str, "%c %d %lf %s", &c, &n, &d, s);
printf("%c\n", c); // печатает: a
printf("%d\n", n); // печатает: 10
printf("%f\n", d); // печатает: 1.200000
printf("%s\n", s); // печатает: String
int sprintf (char *buffer, const char *format, …);
форматирует строку в соответствии с форматом, который задан параметром format и записывает полученный результат в символьный массив buffer. Возвращает функция количество символов, записанных в символьный массив buffer, исключая завершающий нулевой байт. Например,
#include
char str = "c = %c, n = %d, d = %f, s = %s";
char s = "This is a string.";
sprintf(buffer, str, c, n, d, s);
printf("%s\n", buffer); // печатает: c = c, n = 10, d = 1.200000, s = This is a string
1.5. Преобразование строк в числовые данные.
Прототипы функций преобразования строк в числовые данные приведены в заголовочном файле stdlib.h, который нужно включить в программу.
Для преобразования строки в целое число используется функция
int atoi (const char *str);
char *str = “-123”;
n = atoi (str); // n = -123
Для преобразования строки в длинное целое число используется функция
long int atol (const char *str);
которая в случае успешного завершения возвращает целое число, в которое преобразована строка str, а в случае – неудачи 0. Например,
char *str = “-123”;
n = atol (str); // n = -123
Для преобразования строки в число типа double используется функция
double atof (const char *str);
которая в случае успешного завершения возвращает плавающее число типа double, в которое преобразована строка str, а в случае – неудачи 0. Например,
char *str = “-123.321”;
n = atof (str); // n = -123.321
Следующие функции выполняют действия, аналогичные функциям atoi, atol, atof, но предоставляют более широкие возможности.
long int strtol (const char *str, char **endptr, int base);
преобразует строку str в число типа long int, которое и возвращает. Параметры этой функции имеют следующее назначение.
Если аргумент base равен 0, то преобразование зависит от первых двух символов строки str:
Если первый символ – цифра от 1 до 9, то предполагается, что число представлено в 10 c/c;
Если первый символ – цифра 0, а второй – цифра от 1 до 7, то предполагается, что число представлено в 8 c/c;
Если первый символ 0, а второй – ‘Х’ или ‘х’, то предполагается, что число представлено в 16 c/c.
Если аргумент base равен числу от 2 до 36, то это значение принимается за основание системы счисления и любой символ, выходящий за рамки этой системы, прекращает преобразование. В системах счисления с основанием от 11 до 36 для обозначения цифр используются символы от ‘A’ до ‘Z’ или от ‘a’ до ‘z’.
Значение аргумента endptr устанавливается функцией strtol. Это значение содержит указатель на символ, который остановил преобразование строки str. В случае успешного завершения функция strtol возвращает преобразованное число, а в случае неудачи – 0. Например,
n = strtol (“12a”, &p, 0);
printf (“ n = %ld, %stop = %c, n, *p); // n = 12, stop = a
n = strtol (“012b”, &p, 0);
printf (“ n = %ld, %stop = %c, n, *p); // n = 10, stop = b
n = strtol (“0x12z”, &p, 0);
printf (“ n = %ld, %stop = %c, n, *p); // n = 18, stop = z
n = strtol (“01117”, &p, 0);
printf (“ n = %ld, %stop = %c, n, *p); // n = 7, stop = 7
unsigned long int strtol (const char *str, char **endptr, int base);
работает аналогично функции strtol, но преобразует символьное представление числа в число типа unsigned long int.
double strtod (const char *str, char **endptr);
преобразует символьное представление числа в число типа double.
Все функции, перечисленные в этом параграфе, прекращают свою работу при встрече первого символа, который не подходит под формат рассматриваемого числа.
Кроме того, в случае если символьное значение числа превосходит диапазон допустимых значений для соответствующего типа данных, то функции atof, strtol, strtoul, strtod устанавливают значение переменной errno в ERANGE. Переменная errno и константа ERANGE определены в заголовочном файле math.h. При этом функции atof и strtod возвращают значение HUGE_VAL, функция strtol возвращает значение LONG_MAX или LONG_MIN, а функция strtoul – значение ULONG_MAX.
Для преобразования числовых данных в символьные строки могут использоваться нестандартные функции itoa, ltoa, utoa, ecvt, fcvt и gcvt. Но лучше для этих целей использовать стандартную функцию sprintf.
1.6. Стандартные функции для работы со строками.
В этом параграфе рассмотрены функции для работы со строками, прототипы которых описаны в заголовочном файле string.h.
1. Сравнение строк. Для сравнения строк используются функции strcmp и strncmp.
int strcmp (const char *str1, const char *str2);
лексикографически сравнивает строки str1, str2 и возвращает –1, 0 или 1, если строка str1 соответственно меньше, равна или больше строки str2.
int strncmp (const char *str1, const char *str2, size_t n);
лексикографически сравнивает не более чем n первых символов из строк str1 и str2. Функция возвращает –1, 0 или 1, если первые n символов из строки str1 соответственно меньше, равны или больше первых n символов из строки str2.
// пример сравнения строк
#include
#include
char str1 = "aa bb";
char str2 = "aa aa";
char str3 = "aa bb cc";
printf("%d\n", strcmp(str1, str3)); // печатает: -1
printf("%d\n", strcmp(str1, str1)); // печатает: -0
printf("%d\n", strcmp(str1, str2)); // печатает: 1
printf("%d\n", strncmp(str1, str3, 5)); // печатает: 0
2. Копирование строк. Для копирования строк используются функции strcpy и strncpy.
char *strcpy (char *str1, const char *str2);
копирует строку str2 в строку str1. Строка str2 копируется полностью, включая завершающий нулевой байт. Функция возвращает указатель на str1. Если строки перекрываются, то результат непредсказуем.
char *strncpy (char *str1, const char *str2, size_t n);
копирует n символов из строки str2 в строку str1. Если строка str2 содержит меньше чем n символов, то последний нулевой байт копируется столько раз, сколько нужно для расширения строки str2 до n символов. Функция возвращает указатель на строку str1.
char str2 = "Copy string.";
strcpy (str1, str2);
printf (str1); // печатает: Copy string.
4. Соединение строк. Для соединения строк в одну строку используются функции strcat и strncat.
char* strcat (char *str1, const char *str2);
присоединяет строку str2 к строке str1, причем завершающий нулевой байт строки str1 стирается. Функция возвращает указатель на строку str1.
char* strncat (char *str1, const char *str2, size_t n);
присоединяет n символов из строки str2 к строке str1, причем завершающий нулевой байт строки str1 стирается. Функция возвращает указатель на строку str1. если длина строки str2 меньше n, то присоединяются только символы, входящие в строку str2. После соединения строк к строке str1 всегда добавляется нулевой байт. Функция возвращает указатель на строку str1.
#include
#include
char str1 = "String ";
char str2 = "catenation ";
char str3 = "Yes No";
strcat (str1, str2);
printf ("%s\n", str1); // печатает: String catenation
strncat (str1, str3, 3);
printf ("%s\n", str1); // печатает: String catenation Yes
5. Поиск символа в строке. Для поиска символа в строке используются функции strchr, strrchr, strspn, strcspn и strpbrk.
char* strchr (const char *str, int c);
ищет первое вхождение символа, заданного параметром c, в строку str. В случае успеха функция возвращает указатель на первый найденный символ, а в случае неудачи – NULL.
char* strrchr (const char *str, int c);
ищет последнее вхождение символа, заданного параметром c, в строку str. В случае успеха функция возвращает указатель на последний найденный символ, а в случае неудачи – NULL.
#include
#include
char str = "Char search";
printf ("%s\n", strchr (str, "r")); // печатает: r search
printf ("%s\n", strrchr (str, "r")); // печатает: rch
size_t strspn (const char *str1, const char *str2);
возвращает индекс первого символа из строки str1, который не входит в строку str2.
size_t strcspn (const char *str1, const char *str2);
возвращает индекс первого символа из строки str1, который входит в строку str2.
char str = "123 abc";
printf ("n = %d\n", strspn (str, "321"); // печатает: n = 3
printf ("n = %d\n", strcspn (str, "cba"); // печатает: n = 4
char* strpbrk (const char *str1, const char *str2);
находит первый символ в строке str1, который равен одному из символов в строке str2. В случае успеха функция возвращает указатель на этот символ, а в случае неудачи – NULL.
char str = "123 abc";
printf ("%s\n", strpbrk (str, "bca")); // печатает: abc
6. Сравнение строк. Для сравнения строк используются функция strstr.
char* strstr (const char *str1, const char *str2);
находит первое вхождение строки str2 (без конечного нулевого байта) в строку str1. В случае успеха функция возвращает указатель на найденную подстроку, а в случае неудачи – NULL. Если указатель str1 указывает на строку нулевой длины, то функция возвращает указатель str1.
char str = "123 abc 456;
printf ("%s\n", strstr (str, "abc"); // печать: abc 456
7. Разбор строки на лексемы. Для разбора строки на лексемы используется функция strtok.
char* strtok (char *str1, const char *str2);
возвращает указатель на следующую лексему (слово) в строке str1, в которой разделителями лексем являются символы из строки str2. В случае если лексемы закончились, то функция возвращает NULL. При первом вызове функции strtok параметр str1 должен указывать на строку, которая разбирается на лексемы, а при последующих вызовах этот параметр должен быть установлен в NULL. После нахождения лексемы функция strtok записывает после этой лексемы на место разделителя нулевой байт.
#include
#include
char str = "12 34 ab cd";
p = strtok (str, " ");
printf ("%s\n", p); // печатает в столбик значения: 12 34 ab cd
p = strtok (NULL, " ");
8. Определение длины строки. Для определения длины строки используется функция strlen.
size_t strlen (const char *str);
возвращает длину строки, не учитывая последний нулевой байт. Например,
char str = "123";
printf ("len = %d\n", strlen (str)); // печатает: len = 3
1.7. Функции для работы с памятью.
В заголовочном файле string.h описаны также функции для работы с блоками памяти, которые аналогичны соответствующим функциям для работы со строками.
void* memchr (const void *str, int c, size_t n);
ищет первое вхождение символа, заданного параметром c, в n байтах строки str.
int memcmp (const void *str1, const void *str2, size_t n);
сравнивает первые n байт строк str1 и str2.
void* memcpy (const void *str1, const void *str2, size_t n);
копирует первые n байт из строки str1 в строку str2.
void* memmove (const void *str1, const void *str2, size_t n);
копирует первые n байт из строки str1 в строку str2, обеспечивая корректную обработку перекрывающихся строк.
void* memset (const void *str, int c, size_t n);
копирует символ, заданный параметром c, в первые n байтов строки str.
В современном стандарте C++ определен класс с функциями и свойствами (переменными) для организации работы со строками (в классическом языке C строк как таковых нет, есть лишь массивы символов char):
#include
#include#include
Для работы со строками также нужно подключить стандартный namespace:
Using namespace std;
В противном случае придётся везде указывать описатель класса std::string вместо string .
Ниже приводится пример программы, работающей со string (в старых си-совместимых компиляторах не работает!):
#include
Основные возможности, которыми обладает класс string:
- инициализация массивом символов (строкой встроенного типа) или другим объектом типа string . Встроенный тип не обладает второй возможностью;
- копирование одной строки в другую. Для встроенного типа приходится использовать функцию strcpy() ;
- доступ к отдельным символам строки для чтения и записи. Во встроенном массиве для этого применяется операция взятия индекса или косвенная адресация с помощью указателя;
- сравнение двух строк на равенство. Для встроенного типа используются функции семейства strcmp() ;
- конкатенация (сцепление) двух строк, дающая результат либо как третью строку, либо вместо одной из исходных. Для встроенного типа применяется функция strcat() , однако чтобы получить результат в новой строке, необходимо последовательно задействовать функции strcpy() и strcat() , а также позаботиться о выделении памяти;
- встроенные средства определения длины строки (функции-члены класса size() и l ength()). Узнать длину строки встроенного типа можно только вычислением с помощью функции strlen() ;
- возможность узнать, пуста ли строка.
Рассмотрим эти базовые возможности более подробно.
Инициализация строк при описании и длина строки (не включая завершающий нуль-терминатор):
String st("Моя строка\n"); cout << "Длина " << st << ": " << st.size() << " символов, включая символ новой строки\n";
Строка может быть задана и пустой:
String st2;
Для проверки того, пуста ли строка , можно сравнить ее длину с 0:
If (! st.size()) // пустая
или применить метод empty() , возвращающий true для пустой строки и false для непустой:
If (st.empty()) // пустая
Третья форма создания строки инициализирует объект типа string другим объектом того же типа:
String st3(st);
Строка st3 инициализируется строкой st . Как мы можем убедиться, что эти строки совпадают ? Воспользуемся оператором сравнения (==):
If (st == st3) // инициализация сработала
Как скопировать одну строку в другую ? С помощью обычной операции присваивания:
St2 = st3; // копируем st3 в st2
Для сцепления строк используется операция сложения (+) или операция сложения с присваиванием (+=). Пусть даны две строки:
String s1("hello, "); string s2("world\n");
Мы можем получить третью строку, состоящую из конкатенации первых двух, таким образом:
String s3 = s1 + s2;
Если же мы хотим добавить s2 в конец s1 , мы должны написать:
S1 += s2;
Операция сложения может сцеплять объекты класса string не только между собой, но и со строками встроенного типа. Можно переписать пример, приведенный выше, так, чтобы специальные символы и знаки препинания представлялись встроенным типом char * , а значимые слова – объектами класса string:
Const char *pc = ", "; string s1("hello"); string s2("world"); string s3 = s1 + pc + s2 + "\n"; cout << endl << s3;
Подобные выражения работают потому, что компилятор "знает", как автоматически преобразовывать объекты встроенного типа в объекты класса string . Возможно и простое присваивание встроенной строки объекту string:
String s1; const char *pc = "a character array"; s1 = pc; // правильно
Обратное преобразование при этом не работает . Попытка выполнить следующую инициализацию строки встроенного типа вызовет ошибку компиляции:
Char *str = s1; // ошибка компиляции
Чтобы осуществить такое преобразование, необходимо явно вызвать функцию-член с названием c_str() ("строка Си"):
Const char *str = s1.c_str();
Функция c_str() возвращает указатель на символьный массив, содержащий строку объекта string в том виде, в каком она находилась бы во встроенном строковом типе. Ключевое слово const здесь предотвращает "опасную" в современных визуальных средах возможность непосредственной модификации содержимого объекта через указатель.
К отдельным символам объекта типа string , как и встроенного типа, можно обращаться с помощью операции взятия индекса. Вот, например, фрагмент кода, заменяющего все точки символами подчеркивания:
String str("www.disney.com"); int size = str.size(); for (int i = 0; i < size; i++) if (str[i] == ".") str[ i ] = "_"; cout << str;
Replace(str.begin(), str.end(), ".", "_");
Правда, здесь использован не метод replace класса string , а одноимённый алгоритм:
#include
Поскольку объект string ведет себя как контейнер, к нему могут применяться и другие алгоритмы. Это позволяет решать задачи, не решаемые напрямую функциями класса string .
Ниже приводится краткое описание основных операторов и функций класса string , ссылки в таблице ведут к русскоязычным описаниям в интернете. Более полный список возможностей класса string можно получить, например, в Википедии или на сайте cplusplus.com .
|
Задание символов в строке |
|
|
operator= |
присваивает значения строке |
|
assign |
назначает символы строке |
|
Доступ к отдельным символам |
|
|
at |
получение указанного символа с проверкой выхода индекса за границы |
|
operator |
получение указанного символа |
|
front |
получение первого символа |
|
back |
получение последнего символа |
|
data |
возвращает указатель на первый символ строки |
|
c_str |
возвращает немодифицируемый массив символов С , содержащий символы строки |
|
Проверка на вместимость строки |
|
|
empty |
проверяет, является ли строка пустой |
|
size
|
возвращает количество символов в строке |
|
max_size |
возвращает максимальное количество символов |
|
reserve |
резервирует место под хранение |
|
Операции над строкой |
|
|
clear |
очищает содержимое строки |
|
insert |
вставка символов |
|
erase |
удаление символов |
|
push_back |
добавление символа в конец строки |
|
pop_back |
удаляет последний символ |
|
append |
|
|
operator+= |
добавляет символы в конец строки |
|
compare |
сравнивает две строки |
|
replace |
заменяет каждое вхождение указанного символа |
|
substr |
возвращает подстроку |
|
copy |
копирует символы |
|
resize |
изменяет количество хранимых символов |
Работа со строками. Класс string . Конструкторы класса. Функции assign() , append() , insert() , replace() , erase() , find() , rfind() , compare() , c_str() . Примеры1. Какое назначение класса string в программах на C++?Класс string предназначен для работы со строками типа char* , которые представляют собой строку с завершающим нулем. Класс string был введенн как альтернативный вариант для работы со строками типа char* . Строки, которые завершаются символом ‘\0’ еще называются C-строками. Поскольку, string есть классом, то можно объявлять объекты этого класса. 2. Какие модули (библиотеки) нужно подключить, чтобы использовать возможности класса string в MS Visual Studio C++?Чтобы использовать возможности класса string
в MS Visual Studio (C++), нужно подключить библиотеку 3. Каким образом осуществляется объявление переменной типа string ? ПримерыОбъявление переменной типа string осуществляется точно так же как и обычной переменной. Возможный вариант объявления с одновременной инициализацией. // тип string string s1; // переменная с именем s1 типа string string s2 = "This is a string variable" ; // объявление с инициализацией // использование переменной типа string с оператором присваивания s1 = s2; // s1 = "This is a string variable" s2 = "New text" ;4. Какие преимущества и недостатки дает использование класса string в сравнении с типом char* ?Создание нового типа string было обусловлено недостатками работы с строками символов, который демонстрировал тип char* . В сравнении с типом char* тип string имеет следующие основные преимущества:
Основным недостатком типа string в сравнении с типом char* , есть замедленная скорость обработки данных. Это связано с тем, что тип string – это, фактически, контейнерный класс. А работа с классом требует дополнительной реализации программного кода, который, в свою очередь занимает лишнее время. 5. Какие операторы можно использовать с объектами класса string ?Класс string есть удобен тем, что позволяет удобно манипулировать строками, используя стандартные (перегруженные) операторы. С объектами класса string можно использовать нижеследующие операторы
Пример, который демонстрирует использование вышеприведенных операторов // тип string, операции над строками string s1 = "s-1" ; string s2 = "s-2" ; string s3; bool b; // операция "=" (присваивание строк) s3 = s1; // s3 = "s-1" // операция "+" - конкатенация строк s3 = s3 + s2; // s3 = "s-1s-2" // операция "+=" - присваивание с конкатенацией s3 = "s-3" ; s3 += "abc" ; // s3 = "s-3abc" // операция "==" - сравнение строк b = s2==s1; // b = false b = s2=="s-2" ; // b = true // операция "!=" - сравнение строк (не равно) s1 = "s1" ; s2 = "s2" ; b = s1 != s2; // b = true // операции "<" и ">" - сравнение строк s1 = "abcd" ; s2 = "de "; b = s1 > s2; // b = false b = s1 < s2; // b = true // операции "<=" и ">=" - сравнение строк (меньше или равно, больше или равно) s1 = "abcd" ; s2 = "ab" ; b = s1 >= s2; // b = true b = s1 <= s2; // b = false b = s2 >= "ab" ; // b = true // операция - индексация char c; s1 = "abcd" ; c = s1; // c = "c" c = s1; // c = "a"6. Содержит ли класс string конструкторы?Как и любой класс, класс string имеет ряд конструкторов. Основные из них следующие: String(); string(const char * str); string(const string & str); 7. Примеры инициализации с помощью конструкторовНиже приведены примеры инициализации переменных типа string String s1("Hello!" ); string s2 = "Hello!" ; // инициализация - конструктор string(const char * str) char * ps = "Hello" ; string s3(ps); // инициализация string s4(s3); // инициализация - конструктор string(const string & str) string s5; // инициализация - конструктор string() 8. Присваивание строк. Функция assign() . ПримерыЧтобы присвоить одну строку другой, можно применить один из двух методов:
Функция assign() имеет несколько перегруженных реализаций. Первый вариант – это вызов функции без параметров String &assign(void ); В этом случае происходит простое присваивание одной строки другой. Второй вариант позволяет копировать заданное количество символов из строки: String &assign(const string & s, size_type st, size_type num);
Третий вариант функции assign() копирует в вызывающий объект первые num символов строки s : String & assign(const char * s, size_type num);
Ниже приведен пример с разными реализациями функции assign() . Пример. // присваивание строк, функция assign() string s1 = "сайт" ; string s2; string s3; char * ps = "сайт" ; s3 = s1; // s3 = "сайт" s2.assign(s1); // s2 = "сайт" s2.assign(s1, 0, 4); // s2 = "best" s2.assign(ps, 8); // s2 = "bestprog"9. Объединение строк. Функция append() . ПримерДля объединения строк используется функция append() . Для добавления строк также можно использовать операцию ‘+’ , например: String s1; string s2; s1 = "abc" ; s2 = "def" ; s1 = s1 + s2; // s1 = "abcdef" Однако, функция append() хорошо подходит, если нужно добавлять часть строки. Функция имеет следующие варианты реализации: String &append(const string & s, size_type start); string &append(const char * s, size_type num); В первом варианте реализации функция получает ссылку на строчный объект s , который добавляется к вызывающему объекту. Во втором варианте реализации функция получает указатель на строку типа const char * , которая завершается символом ‘\0’ . Пример. Демонстрация работы функции append() . String s1 = "abcdef" ; s2 = "1234567890" ; append(s2, 3, 4); // s1 = "abcdef4567" char * ps = "1234567890" ; s1 = "abcdef" ; s1.append(ps, 3); // s1 = "abcdef123" 10. Вставка символов в строке. Функция insert() . ПримерЧтобы вставить одну строку в заданную позицию другой строки нужно использовать функцию insert() , которая имеет несколько вариантов реализации. Первый вариант функции позволяет вставить полностью всю строку s в заданную позицию start вызывающей строки (вызывающего объекта): String & insert(size_type start, const string &s); Второй вариант функции позволяет вставить часть (параметры insStart , num ) строки s в заданную позицию start вызывающей строки: String & insert(size_type start, const string &s, size_type insStart, size_type num); В вышеприведенных функциях:
11. Замена символов в строке. Функция replace() . ПримерФункция replace() выполняет замену символов в вызывающей строке. Функция имеет следующие варианты реализации: String &replace(size_type start, size_type num, const string &s); string &replace(size_type start, size_type num, const string &s, size_type replStart, size_type replNum); В первом варианте реализации вызывающая строка заменяется строкой s . Есть возможность задать позицию (start ) и количество символов (num ) в вызывающей строке, которые нужно заменить строкой s . Второй вариант функции replace() отличается от первого тем, что позволяет заменять вызывающую строку только частью строки s . В этом случае задаются два дополнительных параметра: позиция replStart и количество символов в строке s , которые образуют подстроку, которая заменяет вызывающую строку. Пример. Демонстрация работы функции replace() . String s1 = "abcdef" ; string s2 = "1234567890" ; s2.replace(2, 4, s1); // s2 = "12abcdef7890" s2 = "1234567890" ; s2.replace(3, 2, s1); // s2 = "123abcdef67890" s2 = "1234567890" ; s2.replace(5, 1, s1); // s2 = "12345abcdef7890" // замена символов, функция replace() string s1 = "abcdef" ; string s2 = "1234567890" ; s2.replace(2, 4, s1); // s2 = "12abcdef7890" s2 = "1234567890" ; s2.replace(3, 2, s1); // s2 = "123abcdef67890" s2 = "1234567890" ; s2.replace(5, 1, s1); // s2 = "12345abcdef7890" s2 = "1234567890" ; s2.replace(5, 1, s1, 2, 3); // s2 = "12345cde7890" s2 = "1234567890" ; s2.replace(4, 2, s1, 0, 4); // s2 = "1234abcd7890" 12. Удаление заданного количества символов из строки. Функция erase() . ПримерДля удаления символов из вызывающей строки используется функция erase() : String & erase(size_type index=0, size_type num = npos);
Пример. String s = "01234567890" ; s.erase(3, 5); // s = "012890" s = "01234567890" ; s.erase(); // s = "" 13. Поиск символа в строке. Функции find() и rfind() . ПримерыВ классе string поиск строки в подстроке можно делать двумя способами, которые отличаются направлением поиска:
Прототип функции find() имеет вид: Size_type find(const string &s, size_type start = 0) const ;
Прототип функции rfind() имеет вид: Size_type rfind(const string &s, size_type start = npos) const ;
Пример 1. Фрагмент кода, который демонстрирует результат работы функции find() // тип string, функция find() string s1 = "01234567890" ; string s2 = "345" ; string s3 = "abcd" ; int pos; pos = s1.find(s2); // pos = 3 pos = s1.find(s2, 1); // pos = 3 pos = s1.find("jklmn" , 0); // pos = -1 pos = s1.find(s3); // pos = -1 pos = s2.find(s1); // pos = -1Пример 2. Демонстрация работы функции rfind() . // тип string, функции find() и rfind() string s1 = "01234567890" ; string s2 = "345" ; string s3 = "abcd" ; string s4 = "abcd---abcd" ; int pos; pos = s1.rfind(s2); // pos = 3 pos = s1.rfind(s2, 12); // pos = 3 pos = s1.rfind(s2, 3); // pos = 3 pos = s1.rfind(s2, 2); // pos = -1 pos = s2.rfind(s1); // pos = -1 pos = s1.rfind(s3, 0); // pos = -1 // разница между функциями find() и rfind() pos = s4.rfind(s3); // pos = 7 pos = s4.find(s3); // pos = 014. Сравнение частей строк. Функция compare() . ПримерПоскольку тип string есть классом, то, чтобы сравнить две строки между собой можно использовать операцию ‘= =’ . Если две строки одинаковы, то результат сравнения будет true . В противном случае, результат сравнения будет false . Но если нужно сравнить часть одной строки с другой, то для этого предусмотрена функция compare() . Прототип функции compare() : int compare(size_type start, size_type num, const string &s) const ;
Функция работает следующим образом. Если вызывающая строка меньше строки s , то функция возвращает -1 (отрицательное значение). Если вызывающая строка больше строки s , функция возвращает 1 (положительное значение). Если две строки равны, функция возвращает 0. Пример . Демонстрация работы функции compare() : // тип string, функция compare() string s1 = "012345" ; string s2 = "0123456789" ; int res; res = s1.compare(s2); // res = -1 res = s1.compare("33333" ); // res = -1 res = s1.compare("012345" ); // res = 0 res = s1.compare("345" ); // res = -1 res = s1.compare(0, 5, s2); // res = -1 res = s2.compare(0, 5, s1); // res = -1 res = s1.compare(0, 5, "012345" ); // res = -1 res = s2.compare(s1); // res = 1 res = s2.compare("456" ); // res = -1 res = s2.compare("000000" ); // res = 115. Получение строки с символом конца строки ‘\0’ (char * ). Функция c_str() . ПримерЧтобы получить строку, которая заканчивается символом ‘\0’ используется функция c_str() . Прототип функции: const char * c_str() const ;Функция объявлена с модификатором const . Это означает, что функция не может изменять вызывающий объект (строку). Пример 1 . Преобразование типа string в const char * . // тип string, функция c_str() string s = "abcdef" ; const char * ps; ps = s.c_str(); // ps = "abcdef"Пример 2. Ниже продемонстрирован перевод строки из string в тип System::String для отображения его в элементе управления типа Label Похожие статьи
Популярные статьи
| |
