Операции работы со строками. Строки в си
Пожалуйста, приостановите работу AdBlock на этом сайте.
Итак, строки в языке Си. Для них не предусмотрено отдельного типа данных, как это сделано во многих других языках программирования. В языке Си строка – это массив символов. Чтобы обозначить конец строки, используется символ "\0" , о котором мы говорили в прошлой части этого урока. На экране он никак не отображается, поэтому посмотреть на него не получится.
Создание и инициализация строки
Так как строка – это массив символов, то объявление и инициализация строки аналогичны подобным операциям с одномерными массивами.
Следующий код иллюстрирует различные способы инициализации строк.
Листинг 1.
Char str; char str1 = {"Y","o","n","g","C","o","d","e","r","\0"}; char str2 = "Hello!"; char str3 = "Hello!";
Рис.1 Объявление и инициализация строк
В первой строке мы просто объявляем массив из десяти символов. Это даже не совсем строка, т.к. в ней отсутствует нуль-символ \0 , пока это просто набор символов.
Вторая строка. Простейший способ инициализации в лоб. Объявляем каждый символ по отдельности. Тут главное не забыть добавить нуль-символ \0 .
Третья строка – аналог второй строки. Обратите внимание на картинку. Т.к. символов в строке справа меньше, чем элементов в массиве, остальные элементы заполнятся \0 .
Четвёртая строка. Как видите, тут не задан размер. Программа его вычислит автоматически и создаст массив символов нужный длины. При этом последним будет вставлен нуль-символ \0 .
Как вывести строку
Дополним код выше до полноценной программы, которая будет выводить созданные строки на экран.
Листинг 2.
#include
Рис.2 Различные способы вывода строки на экран
Как видите, есть несколько основных способов вывести строку на экран.
- использовать функцию printf со спецификатором %s
- использовать функцию puts
- использовать функцию fputs , указав в качестве второго параметра стандартный поток для вывода stdout .
Единственный нюанс у функций puts и fputs . Обратите внимание, что функция puts переносит вывод на следующую строку, а функция fputs не переносит.
Как видите, с выводом всё достаточно просто.
Ввод строк
С вводом строк всё немного сложнее, чем с выводом. Простейшим способом будет являться следующее:
Листинг 3.
#include
Функция gets приостанавливает работу программы, читает строку символов, введенных с клавиатуры, и помещает в символьный массив, имя которого передаётся функции в качестве параметра.
Завершением работы функции gets
будет являться символ, соответствующий клавише ввод и записываемый в строку как нулевой символ.
Заметили опасность? Если нет, то о ней вас любезно предупредит компилятор. Дело в том, что функция gets
завершает работу только тогда, когда пользователь нажимает клавишу ввод. Это чревато тем, что мы можем выйти за рамки массива, в нашем случае - если введено более 20
символов.
К слову, ранее ошибки переполнения буфера считались самым распространенным типом уязвимости. Они встречаются и сейчас, но использовать их для взлома программ стало гораздо сложнее.
Итак, что мы имеем. У нас есть задача: записать строку в массив ограниченного размера. То есть, мы должны как-то контролировать количество символов, вводимых пользователем. И тут нам на помощь приходит функция fgets :
Листинг 4.
#include
Функция fgets принимает на вход три аргумента: переменную для записи строки, размер записываемой строки и имя потока, откуда взять данные для записи в строку, в данном случае - stdin . Как вы уже знаете из 3 урока, stdin – это стандартный поток ввода данных, обычно связанный с клавиатурой. Совсем необязательно данные должны поступать именно из потока stdin , в дальнейшем эту функцию мы также будем использовать для чтения данных из файлов.
Если в ходе выполнения этой программы мы введем строку длиннее, чем 10 символов, в массив все равно будут записаны только 9 символов с начала и символ переноса строки, fgets «обрежет» строку под необходимую длину.
Обратите внимание, функция fgets считывает не 10 символов, а 9 ! Как мы помним, в строках последний символ зарезервирован для нуль-символа.
Давайте это проверим. Запустим программу из последнего листинга. И введём строку 1234567890 . На экран выведется строка 123456789 .
Рис.3 Пример работы функции fgets
Возникает вопрос. А куда делся десятый символ? А я отвечу. Он никуда не делся, он остался в потоке ввода. Выполните следующую программу.
Листинг 5.
#include
Вот результат её работы.
Рис.4 Непустой буфер stdin
Поясню произошедшее. Мы вызвали функцию fgets . Она открыла поток ввода и дождалась пока мы введём данные. Мы ввели с клавиатуры 1234567890\n (\n я обозначаю нажатие клавиша Enter ). Это отправилось в поток ввода stdin . Функция fgets , как и полагается, взяла из потока ввода первые 9 символов 123456789 , добавила к ним нуль-символ \0 и записала это в строку str . В потоке ввода осталось ещё 0\n .
Далее мы объявляем переменную h . Выводим её значение на экран. После чего вызываем функцию scanf . Тут-то ожидается, что мы можем что-то ввести, но т.к. в потоке ввода висит 0\n , то функция scanf воспринимает это как наш ввод, и записывается 0 в переменную h . Далее мы выводим её на экран.
Это, конечно, не совсем такое поведение, которое мы ожидаем. Чтобы справиться с этой проблемой, необходимо очистить буфер ввода после того, как мы считали из него строку, введённую пользователем. Для этого используется специальная функция fflush . У неё всего один параметр – поток, который нужно очистить.
Исправим последний пример так, чтобы его работа была предсказуемой.
Листинг 6.
#include
Теперь программа будет работать так, как надо.
Рис.4 Сброс буфера stdin функцией fflush
Подводя итог, можно отметить два факта. Первый. На данный момент использование функции gets является небезопасным, поэтому рекомендуется везде использовать функцию fgets .
Второй. Не забывайте очищать буфер ввода, если используете функцию fgets .
На этом разговор о вводе строк закончен. Идём дальше.
Неслучайно тему про строки я поместил в раздел "Массивы". Так как строка это, по сути, массив символов. Вот пример:
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 (си) является очень важной темой, поэтому постарайтесь вникнуть в этот урок.
Работа со строками. Класс 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 имеет следующие основные преимущества:
- возможность обработки строк стандартными операторами C++ (= , + , = = , <> и т.п.). Как известно, при использовании типа char* даже наиболее простые операции со строками выглядели сложно и требовали написания чрезмерного программного кода;
- обеспечение лучшей надежности (безопасности) программного кода. Например, при копировании строк, тип string обеспечивает соответствующие действия, которые могут возникнуть в случае, если строка-источник имеет больший размер чем строка-приемник;
- обеспечение строки, как самостоятельного типа данных. Объявление типа 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() имеет несколько перегруженных реализаций.
Первый вариант – это вызов функции без параметров
String &assign(void );
В этом случае происходит простое присваивание одной строки другой.
Второй вариант позволяет копировать заданное количество символов из строки:
String &assign(const string & s, size_type st, size_type num);
- s – объект, из которого берется исходная строка;
- st – индекс (позиция) в строке, из которой начинается копирование num символов;
- num – количество символов, которые нужно скопировать из позиции st ;
- size_type – порядковый тип данных.
Третий вариант функции assign() копирует в вызывающий объект первые num символов строки s :
String & assign(const char * s, size_type num);
- s – строка, которая завершается символом ‘\0’ ;
- num – количество символов, которые копируются в вызывающий объект. Копируются первые num символов из строки s .
Ниже приведен пример с разными реализациями функции 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);
В вышеприведенных функциях:
- s – строка, которая вставляется в вызывающую строку;
- start – позиция в вызывающей строке, из которой осуществляется вставка строки s ;
- insStart – позиция в строке s , из которой происходит вставка;
- num – количество символов в строке s , которые вставляются с позиции insStart .
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);
- index – индекс (позиция), начиная из которой нужно удалить символы в вызывающей строке;
- num – количество символов, которые удаляются.
Пример.
String s = "01234567890" ; s.erase(3, 5); // s = "012890" s = "01234567890" ; s.erase(); // s = ""
13. Поиск символа в строке. Функции find() и rfind() . Примеры
В классе string поиск строки в подстроке можно делать двумя способами, которые отличаются направлением поиска:
- путем просмотра строки от начала до конца с помощью функции find() ;
- путем просмотра строки от конца к началу функцией rfind() .
Прототип функции find() имеет вид:
Size_type find(const string &s, size_type start = 0) const ;
- s – подстрока, которая ищется в строке, что вызывает данную функцию. Функция осуществляет поиск первого вхождения строки s . Если подстрока s найдена в строке, что вызвала данную функцию, тогда возвращается позиция первого вхождения. В противном случае возвращается -1;
Прототип функции rfind() имеет вид:
Size_type rfind(const string &s, size_type start = npos) const ;
- s – подстрока, которая ищется в вызывающей строке. Поиск подстроки в строке осуществляется от конца к началу. Если подстрока s найдена в вызывающей строке, то функция возвращает позицию первого вхождения. В противном случае функция возвращает -1;
- npos – позиция последнего символа вызывающей строки;
- start – позиция, из которой осуществляется поиск.
Пример 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 – строка, которая сравнивается с вызывающей строкой;
- start – позиция (индекс) в строке s , из которой начинается просмотр символов строки для сравнения;
- num – количество символов в строке s , которые сравниваются с вызывающей строкой.
Функция работает следующим образом. Если вызывающая строка меньше строки 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 s = "abcdef" ; const char * ps; ps = s.c_str(); // ps = "abcdef"Пример 2.
Ниже продемонстрирован перевод строки из string в тип System::String для отображения его в элементе управления типа Label для приложений типа Windows Forms Application .
// тип string, функция c_str() string s = "abcdef" ; String ss; ss = gcnew String(s.c_str()); // конвертирование label1->Text = ss; // отображение на форме 34--- Руководство по C# --- Строки
С точки зрения регулярного программирования строковый тип данных string относится к числу самых важных в C#. Этот тип определяет и поддерживает символьные строки. В целом ряде других языков программирования строка представляет собой массив символов. А в C# строки являются объектами. Следовательно, тип string относится к числу ссылочных.
Построение строк
Самый простой способ построить символьную строку - воспользоваться строковым литералом . Например, в следующей строке кода переменной ссылки на строку str присваивается ссылка на строковый литерал:
String str = "Пример строки";
В данном случае переменная str инициализируется последовательностью символов "Пример строки". Объект типа string можно также создать из массива типа char. Например:
Char chararray = {"e", "x", "a", "m", "p", "l", "e"}; string str = new string(chararray);
Как только объект типа string будет создан, его можно использовать везде, где только требуется строка текста, заключенного в кавычки.
Постоянство строк
Как ни странно, содержимое объекта типа string не подлежит изменению. Это означает, что однажды созданную последовательность символов изменить нельзя. Но данное ограничение способствует более эффективной реализации символьных строк. Поэтому этот, на первый взгляд, очевидный недостаток на самом деле превращается в преимущество. Так, если требуется строка в качестве разновидности уже имеющейся строки, то для этой цели следует создать новую строку, содержащую все необходимые изменения. А поскольку неиспользуемые строковые объекты автоматически собираются в "мусор", то о дальнейшей судьбе ненужных строк можно даже не беспокоиться.
Следует, однако, подчеркнуть, что переменные ссылки на строки (т.е. объекты типа string) подлежат изменению, а следовательно, они могут ссылаться на другой объект. Но содержимое самого объекта типа string не меняется после его создания.
Рассмотрим пример:
Static void addNewString() { string s = "This is my stroke"; s = "This is new stroke"; }
Скомпилируем приложение и загрузим результирующую сборку в утилиту ildasm.exe . На рисунке показан CIL-код, который будет сгенерирован для метода void addNewString():
Обратите внимание на наличие многочисленных вызовов кода операции ldstr (загрузка строки). Этот код операции ldstr в CIL предусматривает выполнение загрузки нового объекта string в управляемую кучу. В результате предыдущий объект, в котором содержалось значение "This is my stroke", будет в конечном итоге удален сборщиком мусора.
Работа со строками
В классе System.String предоставляется набор методов для определения длины символьных данных, поиска подстроки в текущей строке, преобразования символов из верхнего регистра в нижний и наоборот, и т.д. Далее мы рассмотрим этот класс более подробно.
Поле, индексатор и свойство класса String
В классе String определено единственное поле:
Public static readonly string Empty;
Поле Empty обозначает пустую строку, т.е. такую строку, которая не содержит символы. Этим оно отличается от пустой ссылки типа String, которая просто делается на несуществующий объект.
Помимо этого, в классе String определен единственный индексатор, доступный только для чтения:
Public char this { get; }
Этот индексатор позволяет получить символ по указанному индексу. Индексация строк, как и массивов, начинается с нуля. Объекты типа String отличаются постоянством и не изменяются, поэтому вполне логично, что в классе String поддерживается индексатор, доступный только для чтения.
И наконец, в классе String определено единственное свойство, доступное только для чтения:
Public int Length { get; }
Свойство Length возвращает количество символов в строке. В примере ниже показано использование индексатора и свойства Length:
Using System; class Example { static void Main() { string str = "Простая строка"; // Получить длину строки и 6й символ в строке используя индексатор Console.WriteLine("Длина строки - {0}, 6й символ - "{1}"", str.Length, str); } }
Операторы класса String
В классе String перегружаются два следующих оператора: == и!=. Оператор == служит для проверки двух символьных строк на равенство. Когда оператор == применяется к ссылкам на объекты, он обычно проверяет, делаются ли обе ссылки на один и тот же объект. А когда оператор == применяется к ссылкам на объекты типа String, то на предмет равенства сравнивается содержимое самих строк. Это же относится и к оператору!=. Когда он применяется к ссылкам на объекты типа String, то на предмет неравенства сравнивается содержимое самих строк. В то же время другие операторы отношения, в том числе =, сравнивают ссылки на объекты типа String таким же образом, как и на объекты других типов. А для того чтобы проверить, является ли одна строка больше другой, следует вызвать метод Compare(), определенный в классе String.
Как станет ясно дальше, во многих видах сравнения символьных строк используются сведения о культурной среде. Но это не относится к операторам == и!=. Ведь они просто сравнивают порядковые значения символов в строках. (Иными словами, они сравнивают двоичные значения символов, не видоизмененные нормами культурной среды, т.е. региональными стандартами.) Следовательно, эти операторы выполняют сравнение строк без учета регистра и настроек культурной среды.
Методы класса String
В следующей таблице перечислены некоторые наиболее интересные методы этого класса, сгруппированные по назначению:
| Метод | Структура и перегруженные версии | Назначение |
|---|---|---|
| Сравнение строк | ||
| Compare() | public static int Compare(string strA, string strB) Public static int Compare(string strA, string strB, bool ignoreCase) Public static int Compare(string strA, string strB, StringComparison comparisonType) Public static int Compare(string strA, string strB, bool ignoreCase, CultureInfo culture) |
Статический метод, сравнивает строку strA со строкой strB. Возвращает положительное значение, если строка strA больше строки strB; отрицательное значение, если строка strA меньше строки strB; и нуль, если строки strA и strB равны. Сравнение выполняется с учетом регистра и культурной среды. Если параметр ignoreCase принимает логическое значение true, то при сравнении не учитываются различия между прописным и строчным вариантами букв. В противном случае эти различия учитываются. Параметр comparisonType определяет конкретный способ сравнения строк. Класс CultureInfo определен в пространстве имен System.Globalization. |
| public static int Compare(string strA, int indexA, string strB, int indexB, int length) Public static int Compare(string strA, int indexA, string strB, int indexB, int length, bool ignoreCase) Public static int Compare(string strA, int indexA, string strB, int indexB, int length, StringComparison comparisonType) Public static int Compare(string strA, int indexA, string strB, int indexB, int length, bool ignoreCase, CultureInfo culture) |
Сравнивает части строк strA и strB. Сравнение начинается со строковых элементов strA и strB и включает количество символов, определяемых параметром length. Метод возвращает положительное значение, если часть строки strA больше части строки strB; отрицательное значение, если часть строки strA меньше части строки strB; и нуль, если сравниваемые части строк strA и strB равны. Сравнение выполняется с учетом регистра и культурной среды. |
|
| CompareOrdinal() | public static int CompareOrdinal(string strA, string strB) Public static int CompareOrdinal(string strA, int indexA, string strB, int indexB, int count) |
Делает то же, что и метод Compare(), но без учета локальных установок |
| CompareTo() | public int CompareTo(object value) | Сравнивает вызывающую строку со строковым представлением объекта value. Возвращает положительное значение, если вызывающая строка больше строки value; отрицательное значение, если вызывающая строка меньше строки value; и нуль, если сравниваемые строки равны |
| public int CompareTo(string strB) | Сравнивает вызывающую строку со строкой strB |
|
| Equals() | public override bool Equals(object obj) | Возвращает логическое значение true, если вызывающая строка содержит ту же последовательность символов, что и строковое представление объекта obj. Выполняется порядковое сравнение с учетом регистра, но без учета культурной среды |
| public bool Equals(string value) Public bool Equals(string value, StringComparison comparisonType) |
Возвращает логическое значение true, если вызывающая строка содержит ту же последовательность символов, что и строка value. Выполняется порядковое сравнение с учетом регистра, но без учета культурной среды. Параметр comparisonType определяет конкретный способ сравнения строк |
|
| public static bool Equals(string a, string b) Public static bool Equals(string a, string b, StringComparison comparisonType) |
Возвращает логическое значение true, если строка a содержит ту же последовательность символов, что и строка b . Выполняется порядковое сравнение с учетом регистра, но без учета культурной среды. Параметр comparisonType определяет конкретный способ сравнения строк |
|
| Конкатенация (соединение) строк | ||
| Concat() | public static string Concat(string str0, string str1); public static string Concat(params string values); |
Комбинирует отдельные экземпляры строк в одну строку (конкатенация) |
| Поиск в строке | ||
| Contains() | public bool Contains(string value) | Метод, который позволяет определить, содержится ли в строке определенная подстрока (value) |
| StartsWith() | public bool StartsWith(string value) Public bool StartsWith(string value, StringComparison comparisonType) |
Возвращает логическое значение true, если вызывающая строка начинается с подстроки value. В противном случае возвращается логическое значение false. Параметр comparisonType определяет конкретный способ выполнения поиска |
| EndsWith() | public bool EndsWith(string value) Public bool EndsWith(string value, StringComparison comparisonType) |
Возвращает логическое значение true, если вызывающая строка оканчивается подстрокой value. В противном случае возвращает логическое значение false. Параметр comparisonType определяет конкретный способ поиска |
| IndexOf() | public int IndexOf(char value) Public int IndexOf(string value) |
Находит первое вхождение заданной подстроки или символа в строке. Если искомый символ или подстрока не обнаружены, то возвращается значение -1 |
| public int IndexOf(char value, int startIndex) Public int IndexOf(string value, int startIndex) Public int IndexOf(char value, int startIndex, int count) Public int IndexOf(string value, int startIndex, int count) |
Возвращает индекс первого вхождения символа или подстроки value в вызывающей строке. Поиск начинается с элемента, указываемого по индексу startIndex, и охватывает число элементов, определяемых параметром count (если указан). Метод возвращает значение -1, если искомый символ или подстрока не обнаружен |
|
| LastIndexOf() | Перегруженные версии аналогичны методу IndexOf() | То же, что IndexOf, но находит последнее вхождение символа или подстроки, а не первое |
| IndexOfAny() | public int IndexOfAny(char anyOf) Public int IndexOfAny(char anyOf, int startIndex) Public int IndexOfAny(char anyOf, int startIndex, int count) |
Возвращает индекс первого вхождения любого символа из массива anyOf, обнаруженного в вызывающей строке. Поиск начинается с элемента, указываемого по индексу startIndex, и охватывает число элементов, определяемых параметром count (если они указаны). Метод возвращает значение -1, если не обнаружено совпадение ни с одним из символов из массива anyOf. Поиск осуществляется порядковым способом |
| LastIndexOfAny | Перегруженные версии аналогичны методу IndexOfAny() | Возвращает индекс последнего вхождения любого символа из массива anyOf, обнаруженного в вызывающей строке |
| Разделение и соединение строк | ||
| Split | public string Split(params char separator) Public string Split(params char separator, int count) |
Метод, возвращающий массив string с присутствующими в данном экземпляре подстроками внутри, которые отделяются друг от друга элементами из указанного массива char или string. В первой форме метода Split() вызывающая строка разделяется на составные части. В итоге возвращается массив, содержащий подстроки, полученные из вызывающей строки. Символы, ограничивающие эти подстроки, передаются в массиве separator. Если массив separator пуст или ссылается на пустую строку, то в качестве разделителя подстрок используется пробел. А во второй форме данного метода возвращается количество подстрок, определяемых параметром count. |
| public string Split(params char separator, StringSplitOptions options) Public string Split(string separator, StringSplitOptions options) Public string Split(params char separator, int count, StringSplitOptions options) Public string Split(string separator, int count, StringSplitOptions options) |
В двух первых формах метода Split() вызывающая строка разделяется на части и возвращается массив, содержащий подстроки, полученные из вызывающей строки. Символы, разделяющие эти подстроки, передаются в массиве separator. Если массив separator пуст, то в качестве разделителя используется пробел. А в третьей и четвертой формах данного метода возвращается количество строк, ограничиваемое параметром count. Но во всех формах параметр options обозначает конкретный способ обработки пустых строк, которые образуются в том случае, если два разделителя оказываются рядом. В перечислении StringSplitOptions определяются только два значения: None и RemoveEmptyEntries . Если параметр options принимает значение None, то пустые строки включаются в конечный результат разделения исходной строки. А если параметр options принимает значение RemoveEmptyEntries, то пустые строки исключаются из конечного результата разделения исходной строки. |
|
| Join() | public static string Join(string separator, string value) Public static string Join(string separator, string value, int startIndex, int count) |
Строит новую строку, комбинируя содержимое массива строк. В первой форме метода Join() возвращается строка, состоящая из сцепляемых подстрок, передаваемых в массиве value. Во второй форме также возвращается строка, состоящая из подстрок, передаваемых в массиве value, но они сцепляются в определенном количестве count, начиная с элемента массива value. В обеих формах каждая последующая строка отделяется от предыдущей разделительной строкой, определяемой параметром separator. |
| Заполнение и обрезка строк | ||
| Trim() | public string Trim() Public string Trim(params char trimChars) |
Метод, который позволяет удалять все вхождения определенного набора символов с начала и конца текущей строки. В первой форме метода Trim() из вызывающей строки удаляются начальные и конечные пробелы. А во второй форме этого метода удаляются начальные и конечные вхождения в вызывающей строке символов из массива trimChars. В обеих формах возвращается получающаяся в итоге строка. |
| PadLeft() | public string PadLeft(int totalWidth) Public string PadLeft(int totalWidth, char paddingChar) |
Позволяет дополнить строку символами слева. В первой форме метода PadLeft() вводятся пробелы с левой стороны вызывающей строки, чтобы ее общая длина стала равной значению параметра totalWidth. А во второй форме данного метода символы, обозначаемые параметром paddingChar, вводятся с левой стороны вызывающей строки, чтобы ее общая длина стала равной значению параметра totalWidth. В обеих формах возвращается получающаяся в итоге строка. Если значение параметра totalWidth меньше длины вызывающей строки, то возвращается копия неизмененной вызывающей строки. |
| PadRight() | Аналогично PadLeft() | Позволяет дополнить строку символами справа. |
| Вставка, удаление и замена строк | ||
| Insert() | public string Insert(int startIndex, string value) | Используется для вставки одной строки в другую, где value обозначает строку, вставляемую в вызывающую строку по индексу startIndex. Метод возвращает получившуюся в итоге строку. |
| Remove() | public string Remove(int startIndex) Public string Remove(int startIndex, int count) |
Используется для удаления части строки. В первой форме метода Remove() удаление выполняется, начиная с места, указываемого по индексу startIndex, и продолжается до конца строки. А во второй форме данного метода из строки удаляется количество символов, определяемое параметром count, начиная с места, указываемого по индексу startIndex. |
| Replace() | public string Replace(char oldChar, char newChar) Public string Replace(string oldValue, string newValue) |
Используется для замены части строки. В первой форме метода Replace() все вхождения символа oldChar в вызывающей строке заменяются символом newChar. А во второй форме данного метода все вхождения строки oldValue в вызывающей строке заменяются строкой newValue. |
| Смена регистра | ||
| ToUpper() | public string ToUpper() | Делает заглавными все буквы в вызывающей строке. |
| ToLower() | public string ToLower() | Делает строчными все буквы в вызывающей строке. |
| Получение подстроки из строки | ||
| Substring() | public string Substring(int startIndex) Public string Substring(int startIndex, int length) |
В первой форме метода Substring() подстрока извлекается, начиная с места, обозначаемого параметром startIndex, и до конца вызывающей строки. А во второй форме данного метода извлекается подстрока, состоящая из количества символов, определяемых параметром length, начиная с места, обозначаемого параметром startIndex. |
Пример следующей программы использует несколько из вышеуказанных методов:
Using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 { class Program { static void Main(string args) { // Сравним первые две строки string s1 = "это строка"; string s2 = "это текст, а это строка"; if (String.CompareOrdinal(s1, s2) != 0) Console.WriteLine("Строки s1 и s2 не равны"); if (String.Compare(s1, 0, s2, 13, 10, true) == 0) Console.WriteLine("При этом в них есть одинаковый текст"); // Конкатенация строк Console.WriteLine(String.Concat("\n" + "Один, два ","три, четыре")); // Поиск в строке // Первое вхождение подстроки if (s2.IndexOf("это") != -1) Console.WriteLine("Слово \"это\" найдено в строке, оно "+ "находится на: {0} позиции", s2.IndexOf("это")); // Последнее вхождение подстроки if (s2.LastIndexOf("это") != -1) Console.WriteLine("Последнее вхождение слова \"это\" находится " + "на {0} позиции", s2.LastIndexOf("это")); // Поиск из массива символов char myCh = {"Ы","х","т"}; if (s2.IndexOfAny(myCh) != -1) Console.WriteLine("Один из символов из массива ch "+ "найден в текущей строке на позиции {0}", s2.IndexOfAny(myCh)); // Определяем начинается ли строка с заданной подстроки if (s2.StartsWith("это текст") == true) Console.WriteLine("Подстрока найдена!"); // Определяем содержится ли в строке подстрока // на примере определения ОС пользователя string myOS = Environment.OSVersion.ToString(); if (myOS.Contains("NT 5.1")) Console.WriteLine("Ваша операционная система Windows XP"); else if (myOS.Contains("NT 6.1")) Console.WriteLine("Ваша операционная система Windows 7"); Console.ReadLine(); } } }
Немного о сравнении строк в C#
Вероятно, из всех операций обработки символьных строк чаще всего выполняется сравнение одной строки с другой. Прежде чем рассматривать какие-либо методы сравнения строк, следует подчеркнуть следующее: сравнение строк может быть выполнено в среде.NET Framework двумя основными способами:
Во-первых, сравнение может отражать обычаи и нормы отдельной культурной среды, которые зачастую представляют собой настройки культурной среды, вступающие в силу при выполнении программы. Это стандартное поведение некоторых, хотя и не всех методов сравнения.
И во-вторых, сравнение может быть выполнено независимо от настроек культурной среды только по порядковым значениям символов, составляющих строку. Вообще говоря, при сравнении строк без учета культурной среды используется лексикографический порядок (и лингвистические особенности), чтобы определить, является ли одна строка больше, меньше или равной другой строке. При порядковом сравнении строки просто упорядочиваются на основании невидоизмененного значения каждого символа.
В силу отличий способов сравнения строк с учетом культурной среды и порядкового сравнения, а также последствий каждого такого сравнения настоятельно рекомендуется руководствоваться лучшими методиками, предлагаемыми в настоящее время корпорацией Microsoft. Ведь выбор неверного способа сравнения строк может привести к неправильной работе программы, когда она эксплуатируется в среде, отличающей от той, в которой она разработана.
Выбор способа сравнения символьных строк представляет собой весьма ответственное решение. Как правило и без всяких исключений, следует выбирать сравнение строк с учетом культурной среды, если это делается для целей отображения результата пользователю (например, для вывода на экран ряда строк, отсортированных в лексикографическом порядке). Но если строки содержат фиксированную информацию, не предназначенную для видоизменения с учетом отличий в культурных средах, например, имя файла, ключевое слово, адрес веб-сайта или значение, связанное с обеспечением безопасности, то следует выбрать порядковое сравнение строк. Разумеется, особенности конкретного разрабатываемого приложения будут диктовать выбор подходящего способа сравнения символьных строк.
В классе String предоставляются самые разные методы сравнения строк, которые перечислены в таблице выше. Наиболее универсальным среди них является метод Compare(). Он позволяет сравнивать две строки полностью или частично, с учетом или без учета регистра, способа сравнения, определяемого параметром типа StringComparison , а также сведений о культурной среде, предоставляемых с помощью параметра типа CultureInfo .
Те перегружаемые варианты метода Compare(), которые не содержат параметр типа StringComparison, выполняют сравнение символьных строк с учетом регистра и культурной среды. А в тех перегружаемых его вариантах, которые не содержат параметр типа CultureInfo, сведения о культурной среде определяются текущей средой выполнения.
Тип StringComparison представляет собой перечисление, в котором определяются значения, приведенные в таблице ниже. Используя эти значения, можно организовать сравнение строк, удовлетворяющее потребностям конкретного приложения. Следовательно, добавление параметра типа StringComparison расширяет возможности метода Compare() и других методов сравнения, например, Equals(). Это дает также возможность однозначно указывать способ предполагаемого сравнения строк.
В силу имеющих отличий между сравнением строк с учетом культурной среды и порядковым сравнением очень важно быть предельно точным в этом отношении.
| Значение | Описание |
|---|---|
| CurrentCulture | Сравнение строк производится с использованием текущих настроек параметров культурной среды |
| CurrentCultureIgnoreCase | Сравнение строк производится с использованием текущих настроек параметров культурной среды, но без учета регистра |
| InvariantCulture | Сравнение строк производится с использованием неизменяемых, т.е. универсальных данных о культурной среде |
| InvariantCultureIgnoreCase | Сравнение строк производится с использованием неизменяемых, т.е. универсальных данных о культурной среде и без учета регистра |
| Ordinal | Сравнение строк производится с использованием порядковых значений символов в строке. При этом лексикографический порядок может нарушиться, а условные обозначения, принятые в отдельной культурной среде, игнорируются |
| OrdinalIgnoreCase | Сравнение строк производится с использованием порядковых значений символов в строке, но без учета регистра |
В любом случае метод Compare() возвращает отрицательное значение, если первая сравниваемая строка оказывается меньше второй; положительное значение, если первая сравниваемая строка больше второй; и наконец, нуль, если обе сравниваемые строки равны. Несмотря на то что метод Compare() возвращает нуль, если сравниваемые строки равны, для определения равенства символьных строк, как правило, лучше пользоваться методом Equals() или же оператором ==.
Дело в том, что метод Compare() определяет равенство сравниваемых строк на основании порядка их сортировки. Так, если выполняется сравнение строк с учетом культурной среды, то обе строки могут оказаться одинаковыми по порядку их сортировки, но не равными по существу. По умолчанию равенство строк определяется в методе Equals(), исходя из порядковых значений символов и без учета культурной среды. Следовательно, по умолчанию обе строки сравниваются в этом методе на абсолютное, посимвольное равенство подобно тому, как это делается в операторе ==.
Несмотря на большую универсальность метода Compare(), для простого порядкового сравнения символьных строк проще пользоваться методом CompareOrdinal(). И наконец, следует иметь в виду, что метод CompareTo() выполняет сравнение строк только с учетом культурной среды.
В приведенной ниже программе демонстрируется применение методов Compare(), Equals(), CompareOrdinal(), а также операторов == и!= для сравнения символьных строк. Обратите внимание на то, что два первых примера сравнения наглядно демонстрируют отличия между сравнением строк с учетом культурной среды и порядковым сравнением в англоязычной среде:
Using System; class Example { static void Main() { string str1 = "alpha"; string str2 = "Alpha"; string str3 = "Beta"; string str4 = "alpha"; string str5 = "alpha, beta"; int result; // Сначала продемонстрировать отличия между сравнением строк // с учетом культурной среды и порядковым сравнением result = String.Compare(str1, str2, StringComparison.CurrentCulture); Console.Write("Сравнение строк с учетом культурной среды: "); if (result 0) Console.WriteLine(str1 + " больше " + str2); else Console.WriteLine(str1 + " равно " + str2); result = String.Compare(str1, str2, StringComparison.Ordinal); Console.Write("Порядковое сравнение строк: "); if (result 0) Console.WriteLine(str1 + " больше " + str2); else Console.WriteLine(str1 + " равно " + str4); // Использовать метод CompareOrdinal() result = String.CompareOrdinal(str1, str2); Console.Write("Сравнение строк методом CompareOrdinal():\n"); if (result 0) Console.WriteLine(str1 + " больше " + str2); else Console.WriteLine(str1 + " равно " + str4); Console.WriteLine(); // Определить равенство строк с помощью оператора == // Это порядковое сравнение символьных строк if (str1 == str4) Console.WriteLine(str1 + " == " + str4); // Определить неравенство строк с помощью оператора!= if(str1 != str3) Console.WriteLine(str1 + " != " + str3); if(str1 != str2) Console.WriteLine(str1 + " != " + str2); Console.WriteLine(); // Выполнить порядковое сравнение строк без учета регистра, // используя метод Equals() if(String.Equals(str1, str2, StringComparison.OrdinalIgnoreCase)) Console.WriteLine("Сравнение строк методом Equals() с " + "параметром OrdinalIgnoreCase:\n" + str1 + " равно " + str2); Console.WriteLine (); // Сравнить части строк if(String.Compare(str2, 0, str5, 0, 3, StringComparison.CurrentCulture) > 0) { Console.WriteLine("Сравнение строк с учетом текущей культурной среды:" + "\n3 первых символа строки " + str2 + " больше, чем 3 первых символа строки " + str5); } } }
Выполнение этой программы приводит к следующему результату:
В языке Си отдельного типа данных «строки символов» нет. Работа со строками реализована путем использования одномерных массивов типа char, т.е. строка символов – это одномерный массив типа char, заканчивающийся нулевым байтом.
Нулевой байт – это байт, каждый бит которого равен нулю, при этом для нулевого байта определена символьная константа ´\0´ (признак окончания строки, или нуль-терминатор). Поэтому, если строка должна содержать k символов, то в описании массива необходимо указать k+1 элемент.
Например, char a; - означает, что строка может содержать шесть символов, а последний байт отведен под нулевой.
Строковая константа – это набор символов, заключенных в двойные кавычки. Например:
сhar S=“Работа со строками”;
В конце строковой константы явно указывать символ ´\0´ не нужно.
При работе со строками удобно пользоваться указателями, например:
x = "БГУИР";
x = (i>0)? "положительное":(i<0)? "отрицательное":"нулевое";
Напомним, что для ввода строк обычно используются две стандартные функции:
scanf() - вводит значения для строковых переменных спецификатором ввода %s до появления первого символа “пробел” (символ «&» перед ID строковых данных указывать не надо);
gets() - ввод строки с пробелами внутри этой строки завершается нажатием клавиши ENTER.
Обе функции автоматически ставят в конец строки нулевой байт.
Вывод строк производится функциями printf() или puts() до первого нулевого байта (‘\0’):
printf() не переводит курсор после вывода на начало новой строки;
puts() автоматически переводит курсор после вывода строковой информации в начало новой строки.
Например:
printf(“ Введите строку без пробелов: \n”);
scanf(“%s”,Str);
puts(“ Введите строку ”);
Остальные операции над строками выполняются с использованием стандартных библиотечных функций, описание прототипов которых находятся в файле string.h . Рассмотрим наиболее часто используемые функции.
Функция int strlen (char *S) возвращает длину строки (количество символов в строке), при этом завершающий нулевой байт не учитывается.
char *S1=”Минск!\0”, S2=”БГУИР-Ура!”;
printf(“ %d, %d .”, strlen(S1), strlen(S2));
Результат выполнения данного участка программы:
Функция int strcpy (char *S1, char *S2) - копирует содержимое строки S2 в строку S1.
Функция strcat (char *S1, char *S2) - присоединяет строку S2 к строке S1 и помещает ее в массив, где находилась строка S1, при этом строка S2 не изменяется. Нулевой байт, который завершал строку S1, заменяется первым символом строки S2.
Функция int strcmp
(char *S1, char *S2) сравнивает строки S1 и S2 и возвращает значение <0, если S1
Функции преобразования строки S в число:
Целое: int atoi (char *S);
Длинное целое: long atol (char *S);
Действительное: double atof (char *S);
при ошибке данные функции возвращают значение 0.
Функции преобразования числа V в строку S.
