Основы работы со строками в C++
В языке C++ для удобной работы со строками есть класс string, для использования которого необходимо подключить заголовочный файл string.
Строки можно объявлять и одновременно присваивать им значения:
string S1, S2 = «Hello»;
Строка S1 будет пустой, строка S2 будет состоять из 5 символов.
К отдельным символам строки можно обращаться по индексу, как к элементам массива или C-строк. Например S[0] — это первый символ строки.
Для того, чтобы узнать длину строки можно использовать метод size() строки. Например, последний символ строки S это S[S.size() — 1 ].
Строки в языке C++ могут
Конструкторы строк
Строки можно создавать с использованием следующих конструкторов:
string() — конструктор по умолчанию (без параметров) создает пустую строку.
string(string & S) — копия строки S
string( size_t n, char c) — повторение символа c заданное число n раз.
string(size_t c) — строка из одного символа c .
string(string & S, size_t start, size_t len) — строка, содержащая не более, чем len символов данной строки S , начиная с символа номер start .
Конструкторы можно вызывать явно, например, так:
В этом примере явно вызывается конструктор string для создания строки, состоящей из 10 символов ‘z’ .
Неявно конструктор вызывается при объявлении строки с указанием дополнительных параметров. Например, так:
Подробней о конструкторах для строк читайте здесь.
Ввод-вывод строк
Строка выводится точно так же, как и числовые значения:
Для считывания строки можно использовать операцию «>>» для объекта cin:
В этом случае считывается строка из непробельных символов, пропуская пробелы и концы строк. Это удобно для того, чтобы разбивать текст на слова, или чтобы читать данные до конца файла при помощи while (cin >> S) .
Можно считывать строки до появления символа конца строки при помощи функции getline. Сам символ конца строки считывается из входного потока, но к строке не добавляется:
Арифметические операторы
Со строками можно выполнять следующие арифметические операции:
= — присваивание значения.
+= — добавление в конец строки другой строки или символа.
+ — конкатенация двух строк, конкатенация строки и символа.
== , != — посимвольное сравнение.
< , >, = — лексикографическое сравнение.
То есть можно скопировать содержимое одной строки в другую при помощи операции S1 = S2, сравнить две строки на равенство при помощи S1 == S2, сравнить строки в лексикографическом порядке при помощи S1 < S2, или сделать сложение (конкатенацию) двух строк в виде S = S1 + S2.
Подробней об операторах для строк читайте здесь.
Методы строк
У строк есть разные методы, многие из них можно использовать несколькими разными способами (с разным набором параметров).
Рассмотрим эти методы подробней.
size
Метод size() возращает длину длину строки. Возвращаемое значение является беззнаковым типом (как и во всех случаях, когда функция возращает значение, равное длине строке или индексу элемента — эти значения беззнаковые). Поэтому нужно аккуратно выполнять операцию вычитания из значения, которое возвращает size(). Например, ошибочным будет запись цикла, перебирающего все символы строки, кроме последнего, в виде for (int i = 0; i < S.size() - 1; ++i).
Кроме того, у строк есть метод length(), который также возвращает длину строки.
Подробней о методе size.
resize
S.resize(n) — Изменяет длину строки, новая длина строки становится равна n. При этом строка может как уменьшится, так и увеличиться. Если вызвать в виде S.resize(n, c) , где c — символ, то при увеличении длины строки добавляемые символы будут равны c.
Подробней о методе resize.
clear
S.clear() — очищает строчку, строка становится пустой.
Подробней о методе clear.
empty
S.empty() — возвращает true, если строка пуста, false — если непуста.
Подробней о методе empty.
push_back
S.push_back(c) — добавляет в конец строки символ c, вызывается с одним параметром типа char.
Подробней о методе push_back.
append
Добавляет в конец строки несколько символов, другую строку или фрагмент другой строки. Имеет много способов вызова.
S.append(n, c) — добавляет в конец строки n одинаковых символов, равных с. n имеет целочисленный тип, c — char.
S.append(T) — добавляет в конец строки S содержимое строки T. T может быть объектом класса string или C-строкой.
S.append(T, pos, count) — добавляет в конец строки S символы строки T начиная с символа с индексом pos количеством count.
Подробней о методе append.
erase
S.erase(pos) — удаляет из строки S с символа с индексом pos и до конца строки.
S.erase(pos, count) — удаляет из строки S с символа с индексом pos количеством count или до конца строки, если pos + count > S.size().
Подробней о методе erase.
insert
Вставляет в середину строки несколько символов, другую строку или фрагмент другой строки. Способы вызова аналогичны способам вызова метода append, только первым параметром является значение i — позиция, в которую вставляются символы. Первый вставленный символ будет иметь индекс i, а все символы, которые ранее имели индекс i и более сдвигаются вправо.
S.insert(i, n, c) — вставить n одинаковых символов, равных с. n имеет целочисленный тип, c — char.
S.insert(i, T) — вставить содержимое строки T. T может быть объектом класса string или C-строкой.
S.insert(i, T, pos, count) — вставить символы строки T начиная с символа с индексом pos количеством count.
Подробней о методе insert.
substr
S.substr(pos) — возвращает подстроку данной строки начиная с символа с индексом pos и до конца строки.
S.substr(pos, count) — возвращает подстроку данной строки начиная с символа с индексом pos количеством count или до конца строки, если pos + count > S.size().
Подробней о методе substr.
replace
Заменяет фрагмент строки на несколько равных символов, другую строку или фрагмент другой строки. Способы вызова аналогичны способам вызова метода append, только первыми двумя параметрами являются два числа: pos и count. Из данной строки удаляется count символов, начиная с символа pos, и на их место вставляются новые символы.
S.replace(pos, count, n, c) — вставить n одинаковых символов, равных с. n имеет целочисленный тип, c — char.
S.replace(pos, count, T) — вставить содержимое строки T. T может быть объектом класса string или C-строкой.
S.replace(pos, count, T, pos2, count2) — вставить символы строки T начиная с символа с индексом pos количеством count.
Подробней о методе replace.
find
Ищет в данной строке первое вхождение другой строки str. Возвращается номер первого символа, начиная с которого далее идет подстрока, равная строке str. Если эта строка не найдена, то возвращается константа string::npos (которая равна -1, но при этом является беззнаковой, то есть на самом деле является большим безннаковым положительным числом).
Если задано значение pos, то поиск начинается с позиции pos, то есть возращаемое значение будет не меньше, чем pos. Если значение pos не указано, то считается, что оно равно 0 — поиск осуществляется с начала строки.
S.find(str, pos = 0) — искать первое входение строки str начиная с позиции pos. Если pos не задано — то начиная с начала строки S.
S.find(str, pos, n) — искать в данной строке подстроку, равную первым n символам строки str. Значение pos должно быть задано.
Подробней о методе find.
rfind
Ищет последнее вхождение подстроки («правый» поиск). Способы вызова аналогичны способам вызова метода find.
Подробней о методе rfind.
find_first_of
Ищет в данной строке первое появление любого из символов данной строки str. Возвращается номер этого символа или значение string::npos.
Если задано значение pos, то поиск начинается с позиции pos, то есть возращаемое значение будет не меньше, чем pos. Если значение pos не указано, то считается, что оно равно 0 — поиск осуществляется с начала строки.
S.find_first_of(str, pos = 0) — искать первое входение любого символа строки str начиная с позиции pos. Если pos не задано — то начиная с начала строки S.
find_last_of
Ищет в данной строке последнее появление любого из символов данной строки str. Способы вызова и возвращаемое значение аналогичны методу find_first_of.
Подробней о методе find_last_of.
find_first_not_of
Ищет в данной строке первое появление символа, отличного от символов строки str. Способы вызова и возвращаемое значение аналогичны методу find_first_of.
find_last_not_of
Ищет в данной строке последнее появление символа, отличного от символов строки str. Способы вызова и возвращаемое значение аналогичны методу find_first_of.
c_str
Возвращает указать на область памяти, в которой хранятся символы строки, возвращает значение типа char*. Возвращаемое значение можно рассматривать как C-строку и использовать в функциях, которые должны получать на вход C-строку.
Подробней о методе c_str.
Строки в языке C
Строка — это последовательность ASCII или UNICODE символов.
Строки в C, как и в большинстве языков программирования высокого уровня рассматриваются как отдельный тип, входящий в систему базовых типов языка. Так как язык C по своему происхождению является языком системного программирования, то строковый тип данных в C как таковой отсутствует, а в качестве строк в С используются обычные массивы символов.
Исторически сложилось два представления формата строк:
- формат ANSI;
- cтроки с завершающим нулем (используется в C).
Формат ANSI устанавливает, что значением первой позиции в строке является ее длина, а затем следуют сами символы строки. Например, представление строки «Моя строка!» будет следующим:
11 ‘М’ ‘о’ ‘я’ ‘ ‘ ‘с’ ‘т’ ‘р’ ‘о’ ‘к’ ‘а’ ‘!’
В строках с завершающим нулем, значащие символы строки указываются с первой позиции, а признаком завершения строки является значение ноль. Представление рассмотренной ранее строки в этом формате имеет вид:
‘М’ ‘о’ ‘я’ ‘ ‘ ‘с’ ‘т’ ‘р’ ‘о’ ‘к’ ‘а’ ‘!’ 0
Объявление строк в C
Строки реализуются посредством массивов символов. Поэтому объявление ASCII строки имеет следующий синтаксис:
char имя[длина];
Объявление строки в С имеет тот же синтаксис, что и объявление одномерного символьного массива. Длина строки должна представлять собой целочисленное значение (в стандарте C89 – константа, в стандарте C99 может быть выражением). Длина строки указывается с учетом одного символа на хранение завершающего нуля, поэтому максимальное количество значащих символов в строке на единицу меньше ее длины. Например, строка может содержать максимально двадцать символов, если объявлена следующим образом:
char str[21]; Инициализация строки в С осуществляется при ее объявлении, используя следующий синтаксис:
char str[длина] = строковый литерал;
Строковый литерал – строка ASCII символов заключенных в двойные кавычки. Примеры объявления строк с инициализацией:
char str1[20] = «Введите значение: «, str2[20] = «»;
const char message[] = «Сообщение об ошибке!»;
Работа со строками в С
Так как строки на языке С являются массивами символов, то к любому символу строки можно обратиться по его индексу. Для этого используется синтаксис обращения к элементу массива, поэтому первый символ в строке имеет индекс ноль. Например, в следующем фрагменте программы в строке str осуществляется замена всех символов ‘a’ на символы ‘A’ и наоборот.
for(int i = 0; str[i] != 0; i++)
if (str[i] == ‘a’) str[i] = ‘A’;
else if (str[i] == ‘A’) str[i] = ‘a’;
>
Массивы строк в С
Объявление массивов строк в языке С также возможно. Для этого используются двумерные массивы символов, что имеет следующий синтаксис:
char имя[количество][длина];
Первым размером матрицы указывается количество строк в массиве, а вторым – максимальная (с учетом завершающего нуля) длина каждой строки. Например, объявление массива из пяти строк максимальной длиной 30 значащих символов будет иметь вид:
При объявлении массивов строк можно производить инициализацию:
char имя[количество][длина] = ;
Число строковых литералов должно быть меньше или равно количеству строк в массиве. Если число строковых литералов меньше размера массива, то все остальные элементы инициализируются пустыми строками. Длина каждого строкового литерала должна быть строго меньше значения длины строки (для записи завершающего нуля).
char days[12][10] = <
«Январь», «Февраль», «Март», ”Апрель», «Май»,
«Июнь», «Июль», «Август», «Сентябрь»,»Октябрь»,
«Ноябрь», «Декабрь»
>;
При объявлении массивов строк с инициализацией допускается не указывать количество строк в квадратных скобках. В таком случае, количество строк в массиве будет определено автоматически по числу инициализирующих строковых литералов.
Например, массив из семи строк:
char days[][12] = <
«Понедельник», «Вторник», «Среда», «Четверг»,
«Пятница», «Суббота», «Воскресенье»
>;
Функции для работы со строками в С
Все библиотечные функции, предназначенные для работы со строками, можно разделить на три группы:
- ввод и вывод строк;
- преобразование строк;
- обработка строк.
Ввод и вывод строк в С
Для ввода и вывода строковой информации можно использовать функции форматированного ввода и вывода (printf и scanf). Для этого в строке формата при вводе или выводе строковой переменной необходимо указать спецификатор типа %s. Например, ввод и последующий вывод строковой переменной будет иметь вид:
char str[31] = «»;
printf(«Введите строку: «);
scanf(«%30s”,str);
printf(«Вы ввели: %s”,str);
Недостатком функции scanf при вводе строковых данных является то, что символами разделителями данной функции являются:
- перевод строки,
- табуляция;
- пробел.
Поэтому, используя данную функцию невозможно ввести строку, содержащую несколько слов, разделенных пробелами или табуляциями. Например, если в предыдущей программе пользователь введет строку: «Сообщение из нескольких слов», то на экране будет выведено только «Сообщение».
Для ввода и вывода строк в библиотеке stdio.h содержатся специализированные функции gets и puts.
Функция gets предназначена для ввода строк и имеет следующий заголовок:
char * gets(char *buffer);
Между тем использовать функцию gets категорически не рекомендуется, ввиду того, что она не контролирует выход за границу строки, что может произвести к ошибкам. Вместо нее используется функция fgets с тремя параметрами:
char * fgets(char * buffer, int size, FILE * stream);
где buffer — строка для записи результата, size — максимальное количество байт, которое запишет функция fgets, stream — файловый объект для чтения данных, для чтения с клавиатуры нужно указать stdin. Эта функция читает символы со стандартного ввода, пока не считает n — 1 символ или символ конца строки, потом запишет считанные символы в строку и добавит нулевой символ. При этом функция fgets записывает в том символ конца строки в данную строку, что нужно учитывать.
Функция puts предназначена для вывода строк и имеет следующий заголовок:
int puts(const char *string);
Простейшая программа: ввод и вывод строки с использованием функций fgets и puts будет иметь вид:
char str[102] = «»;
printf(«Введите строку: «);
fgets(str, 102, stdin);
printf(«Вы ввели: «);
puts(str);
Для считывания одного символа можно использовать функцию fgetc(FILE * stream) . Она считывает один символ и возвращает значение этого символа, преобразованное к типу int, если же считывание не удалось, то возвращается специальная константа EOF, равная -1. Функция возвращает значение -1 для того, чтобы можно было обрабатывать ситуацию конца файла, посимвольное чтение до конца файла можно реализовать следующим образом:
int c;
while ((c = fgetc(stdin)) != EOF) // Обработка символа
>
Для вывода одного символа можно использовать функцию int fputc(int c, FILE *stream); .
Помимо функций ввода и вывода в потоки в библиотеке stdio.h присутствуют функции форматированного ввода и вывода в строки. Функция форматированного ввода из строки имеет следующий заголовок:
int sscanf(const char * restrict buffer, const char * restrict string, [address] . );
Функции форматированного вывода в строку имеют следующие заголовки:
int sprintf(char * restrict buffer,
const char * restrict format, [argument] . );
int snprintf(char * restrict buffer, size_t maxsize,
const char * restrict format, [argument] . );
Преобразование строк
В С для преобразования строк, содержащих числа, в численные значения в библиотеке stdlib.h
предусмотрен следующий набор функций:
double atof(const char *string); // преобразование строки в число типа double
int atoi(const char *string); // преобразование строки в число типа int
long int atol(const char *string); // преобразование строки в число типа long int
long long int atoll(const char *string); // преобразование строки в число типа long long int
Корректное представление вещественного числа в текстовой строке должно удовлетворять формату:
После символов E, e указывается порядок числа. Корректное представление целого числа в текстовой строке должно удовлетворять формату:
Помимо приведенных выше функций в библиотеке stdlib.h доступны также следующие функции преобразования строк в вещественные числа:
float strtof(const char * restrict string, char ** restrict endptr);
double strtod(const char * restrict string, char ** restrict endptr);
long double strtold(const char * restrict string,char ** restrict endptr);
Аналогичные функции присутствуют и для преобразования строк в целочисленные значения:
long int strtol(const char * restrict string, char ** restrict endptr, int base);
unsigned long strtoul(const char * restrict string,
char ** restrict endptr, int base);
long long int strtoll(const char * restrict string,
char ** restrict endptr, int base);
unsigned long long strtoull(const char * restrict string,char ** restrict endptr, int base);
Функции обратного преобразования (численные значения в строки) в библиотеке stdlib.h присутствуют, но они не регламентированы стандартом, и рассматриваться не будут. Для преобразования численных значений в строковые наиболее удобно использовать функции sprintf и snprintf.
Обработка строк
В библиотеке string.h содержаться функции для различных действий над строками.
Функция вычисления длины строки:
size_t strlen(const char *string);
char str[] = «1234»;
int n = strlen(str); //n == 4
Функции копирования строк:
char * strcpy(char * restrict dst, const char * restrict src);
char * strncpy(char * restrict dst, const char * restrict src, size_t num);
Функции сравнения строк:
int strcmp(const char *string1, const char *string2);
int strncmp(const char *string1, const char *string2,size_t num);
Функции осуществляют сравнение строк по алфавиту и возвращают:
положительное значение – если string1 больше string2;
отрицательное значение – если string1 меньше string2;
нулевое значение – если string1 совпадает с string2;
Функции объединения (конкатенации) строк:
char * strcat(char * restrict dst, const char * restrict src);
char * strncat(char * restrict dst, const char * restrict src, size_t num);
Функции поиска символа в строке:
char * strchr(const char *string, int c);
char * strrchr(const char *string, int c);
Функция поиска строки в строке:
char * strstr(const char *str, const char *substr);
char str[] = «Строка для поиска»;
char *str1 = strstr(str,»для»); //str1 == «для поиска»
Функция поиска первого символа в строке из заданного набора символов:
size_t strcspn(const char *str, const char *charset);
Функции поиска первого символа в строке не принадлежащему заданному набору символов:
size_t strspn(const char *str, const char *charset);
Функции поиска первого символа в строке из заданного набора символов:
char * strpbrk(const char *str, const char *charset);
Функция поиска следующего литерала в строке:
char * strtok(char * restrict string, const char * restrict charset);
Как обратиться к элементу строки
Обработка текстовых строк является одной из важнейших задач на современных компьютерах. В языке C# имеются развитые средства по обработке строк. Ранее мы частично рассматривали работу со строками. Здесь разберёмся с этим вопросом более подробно.
Для хранения символьной информации в языке C# используется Unicode . Под один символ отводится 16 бит. Строка в C# представляет собой цепочку символов Unicode и является объектом класса System.String .
Создание строки
1)Строку с именем s можно создать так:
string s=»Это строка»;
2)Строка может содержать различные управляющие символы, например, символ перехода на новую строку ‘\n’ :
string s1=»Текст в \n две строки»;
Если вывести строку s1 на экран монитора, то текст напечатается в две строки:
3)Можно создавать строки с посимвольным соответствием — в этом случае все символы воспринимаются «как есть», т.е. управляющие символы в таких строках становятся обычными символами. Для того, чтобы показать, что в строке используется посимвольное соответствие, перед строкой записывают символ ‘@’ (Эт-коммерческое). Применим это для текста, который был в строке s1 :
string s2=@»Текст в \n две строки»;
Здесь строка выведется на печать «как есть»:
Текст в \n две строки
4)Если имеется массив символов Unicode типа char , то его можно преобразовать в строку. Для этого используется конструктор класса String() :
string s=new String(c);
Сейчас в s хранится строка:
5)Но можно построить новую строку не из всего массива типа char , а из его части:
s=new String(c, i, k);
В этом случае строка строится не из всего массива c , а начиная с элемента под номером i , и используется k символов. Вывод строки s на экран даёт следующее:
6)Можно создать строку, в которой будет многократно повторяться один и тот же символ:
string s=new String(‘*’, 10);
Получится строка из 10 символов «звёздочка».
Замечание . Не пытайтесь таким способом получать строку из строк. Вариант
string s = new String(«*», 10);
работать не будет ( «*» — это строка, а ‘*’ — это символ).
Консольный ввод-вывод строк
Выполняется просто. Достаточно использовать стандартные методы ReadLine() и WriteLine() класса Console :
Обращение к отдельным элементам строки
Если в строке имеется какая-либо информация, то можно эту строку обрабатывать посимвольно как массив. Индексы в строке так же начинаются с 0 . Текущая длина определяется свойством Length :
На экран будет выведено количество цифр, найденных в этой строке. Но здесь, как не сложно понять, к элементу строки используется доступ по чтению. А что будет, если мы попробуем менять символы в строке? Например, заменим все символы ‘2’ на ‘5’ :
В этом случае для строки
будет выдано сообщение об ошибке:
Невозможно присвоить значение свойству или индексатору ‘string.this[int]’ — доступ только для чтения (CS0200)
Решить проблему можно двумя путями: использовать методы класса String (для замены подойдёт метод Replace() ) или отказаться от класса String и использовать класс StringBuilder , для которого допустимо изменение отдельных элементов строки (так же, как это делалось в массиве).
Операции над строками
Для строк допустимы операция присваивания (смотри выше), сцепление строк (в конец первой строки добавляется вторая) и проверка на равенство или неравенство. Другие операции не допустимы.
1) Сцепление (слияние) строк:
string s1=»122″, s2=»123″;
string s1 = s + s2;
На экран будет выведено:
2) Проверка на равенство ( == ) или на неравенство ( != ):
string s1=»122″, s2=»123″;
Здесь будет напечатано:
Методы по обработке строк
Для строк в языке C# существует большое количество готовых методов, позволяющие выполнять различные действия над строками. Рассмотрим наиболее употребительные из них.
1) Конкатенация (сцепление, слияние) строк — используется статический метод Concat() :
string s = «123», s1 = «45»;
Результатом будет строка, содержащая обе исходные строки:
Интересно применение метода Concat() для объединения массива строк:
Результатом будет строка:
2) Копирование строки выполняется с помощью статического метода Copy() :
string s2 = String.Copy(s);
Тоже самое можно получить и с помощью оператора присваивания:
3) Получение подстроки — используется метод Substring() , например:
s = «Язык программирования C#»;
s2 = s.Substring(12, 3);
Здесь из исходной строки s , начиная с позиции 12 , копируется 3 символа и полученный результат заносится в строку s2 . На экране будет выведено:
4) Вставка подстроки — в заданную позицию ( 2 ) исходной строки s включаем подстроку ( «AB» ):
string s = «12345»
s2 = s.Insert(2, «AB»);
Результатом будет строка s2 , равная:
5) Замена символов и строк — используется метод Replace() . Имеется два варианта. Рассмотрим их оба.
а) Замена символов . Заменим в строке s все вхождения символа ‘2’ на ‘5’ :
string s = «123422»;
string s1 = s.Replace(‘2’, ‘5’);
Как видим, рассматриваемая ранее задача (попытка замены s[i]=’5′ ) при использовании метода Replace() решается предельно просто.
б) Замена строк . Заменим все слова «abc» на «alfa» :
string s1 = s.Replace(«abc», «alfa»);
К стати . Метод Replace() работает корректно даже в том случае, когда делается замена на строку, которая является расширением исходной. Например, заменим в тексте все вхождения слова «child» на «children» :
string s1 = s.Replace(«child», «children»);
Как видно из выведенного на экран текста, всё получилось так, как и ожидалось:
6) Удаление символов из строки (метод Remove () ) — в строке s удаляем k символов, начиная с позиции i :
string s = «123429»;
7) Поиск индекса первого вхождения символа в строке (метод IndexOf () ):
string s = «It is false»;
int i = s.IndexOf(‘f’);
Полученный результат (позиция символа ‘f’ ):
8) Поиск первого вхождения любого из символов массива в строке (метод IndexOfAny() ) — в строке s ищется позиция первого вхождения любого из символов массива x :
int i = s.IndexOfAny(x);
Полученный результат (позиция символа ‘
9) Поиск индекса последнего вхождения символа в строке (метод LastIndexOf () ):
string s = «It is false for»;
int i = s.LastIndexOf(‘f’);
Полученный результат (позиция последнего символа ‘f’ ):
10) Поиск последнего вхождения любого из символов массива в строке — в строке s ищется позиция последнего вхождения любого из символов массива x ( метод LastIndexOfAny() ):
int i = s.LastIndexOfAny(x);
Полученный результат (позиция символа ‘(‘ ):
Пример 1 . Дана символьная строка s , известно, что в этой строке есть хотя бы один символ «точка». Преобразовать строку, удалив из неё запятые, предшествующие первой точке, и заменив знаком * все символы пробела, встречающиеся после первой точки.
public static void Main(string[] args)
string s = «qwerty, t, r . abc f t»;
int k = s.IndexOf(«.»);
Console.WriteLine(«Первая точка находится в позиции: «+k);
string s1 = s.Substring(0, k);
s1 = s1.Remove(i, 1);
string s2 = s.Substring(k);
Console.Write(«Press any key to continue . . . «);
qwerty, t, r . abc f t
Первая точка находится в позиции: 13
qwerty t r .*abc*f*t
Press any key to continue . . .
Работа со строками
Довольно большое количество задач, которые могут встретиться при разработке приложений, так или иначе связано с обработкой строк — парсинг веб-страниц, поиск в тексте, какие-то аналитические задачи, связанные с извлечением нужной информации из текста и т.д. Поэтому в этом плане работе со строками уделяется особое внимание.
В языке C# строковые значения представляет тип string , а вся функциональность работы с данным типом сосредоточена в классе System.String . Собственно string является псевдонимом для класса String. Объекты этого класса представляют текст как последовательность символов Unicode. Максимальный размер объекта String может составлять в памяти 2 ГБ, или около 1 миллиарда символов.
Создание строк
Создавать строки можно, как используя переменную типа string и присваивая ей значение, так и применяя один из конструкторов класса String:
string s1 = "hello"; string s2 = new String('a', 6); // результатом будет строка "aaaaaa" string s3 = new String(new char[] < 'w', 'o', 'r', 'l', 'd' >); string s4 = new String(new char[] < 'w', 'o', 'r', 'l', 'd' >, 1, 3); // orl Console.WriteLine(s1); // hello Console.WriteLine(s2); // aaaaaaa Console.WriteLine(s3); // world Console.WriteLine(s4); // orl
Конструктор String имеет различное число версий. Так, вызов конструктора
new String('a', 6)
6 раз повторит объект из первого параметра, то есть фактически создаст строку «aaaaaa».
Еще один конструктор принимает массив символов, из которых создается строка
string s3 = new String(new char[] < 'w', 'o', 'r', 'l', 'd' >);
Третий использованный выше в примере конструктор позволяет создать строку из части массива символов. Второй параметр передает начальный индекс, с которого извлкаются символы, а третий параметр указывает на количество символов:
string s4 = new String(new char[] < 'w', 'o', 'r', 'l', 'd' >, 1, 3); // orl
Строка как набор символов
Так как строка хранит коллекцию символов, в ней определен индексатор для доступа к этим символам:
public char this[int index]
Применяя индексатор, мы можем обратиться к строке как к массиву символов и получить по индексу любой из ее символов:
string message = "hello"; // получаем символ char firstChar = message[1]; // символ 'e' Console.WriteLine(firstChar); //e Console.WriteLine(message.Length); // длина строки
Используя свойство Length , как и в обычном массиве, можно получить длину строки.
Перебор строк
Класс String реализует интерфейс IEnumerable, благодаря чему строку можно перебрать в цикле foreach как набор объектов char. Также можно с помощью других типов циклов перебрать строку, применяя обращение к символам по индексу:
string message = «hello»; for(var i =0; i < message.Length; i++) < Console.WriteLine(message[i]); >foreach(var ch in message)
Сравнение строк
В отличие от других классов строки сравниваются по значению их символов, а не по ссылкам:
string message1 = "hello"; string message2 = "hello"; Console.WriteLine(message1 == message2); // true
Многострочные строки
Начиная с C# 11 с помощью трех пар двойных кавычек можно оформить многострочный текст, в том числе с применением интерполяции:
Print(); PrintValue("hello"); void Print() """; Console.WriteLine(text); > void PrintValue(string val) < string text = $""" """; //// или так //string text = $$""" // // // > // // // """; Console.WriteLine(text); >
Основные методы строк
Основная функциональность класса String раскрывается через его методы, среди которых можно выделить следующие:
- Compare : сравнивает две строки с учетом текущей культуры (локали) пользователя
- CompareOrdinal : сравнивает две строки без учета локали
- Contains : определяет, содержится ли подстрока в строке
- Concat : соединяет строки
- CopyTo : копирует часть строки, начиная с определенного индекса в массив
- EndsWith : определяет, совпадает ли конец строки с подстрокой
- Format : форматирует строку
- IndexOf : находит индекс первого вхождения символа или подстроки в строке
- Insert : вставляет в строку подстроку
- Join : соединяет элементы массива строк
- LastIndexOf : находит индекс последнего вхождения символа или подстроки в строке
- Replace : замещает в строке символ или подстроку другим символом или подстрокой
- Split : разделяет одну строку на массив строк
- Substring : извлекает из строки подстроку, начиная с указанной позиции
- ToLower : переводит все символы строки в нижний регистр
- ToUpper : переводит все символы строки в верхний регистр
- Trim : удаляет начальные и конечные пробелы из строки
В следующих статьях разберем работу этих методов.