Символы и строки
Проект к данной лекции Вы можете скачать здесь.
Общий взгляд
Строкам не повезло. По понятным причинам в первых языках программирования строковому типу уделялось гораздо меньше внимания, чем арифметическому типу или массивам. Поэтому в разных языках строки представлены по -разному и стандарт на строковый тип сложился относительно недавно. Когда говорят о строковом типе, то обычно различают тип, представляющий:
- отдельные символы, чаще всего его называют типом char;
- строки постоянной длины, часто они представляются массивом символов;
- строки переменной длины — это, как правило, тип string, соответствующий современному представлению о строковом типе.
Символьный тип char , представляющий частный случай строк длиной 1, полезен во многих задачах. Основные операции над строками — это разбор и сборка . При их выполнении приходится чаще всего доходить до каждого символа строки. В языке Паскаль , где был введен тип char , сам строковый тип рассматривался, как char []- массив символов. При таком подходе получение i-го символа строки становится такой же простой операцией, как и получение i-го элемента массива, следовательно, эффективно реализуются обычные операции над строками — определение вхождения одной строки в другую, выделение подстроки , замена символов строки. Однако заметьте, представление строки массивом символов хорошо только для строк постоянной длины. Массив не приспособлен к изменению его размеров, вставки или удалению символов (подстрок).
Наиболее часто используемым строковым типом является тип, обычно называемый string , который задает строки переменной длины. Над этим типом допускаются операции поиска вхождения одной строки в другую, операции вставки, замены и удаления подстрок.
Тип string в языке C# допускает двойственную интерпретацию. С одной стороны, значения переменной типа string можно рассматривать, как неделимое значение — скаляр — строку текста. С другой стороны, это значение можно интерпретировать, как массив из n элементов, где n — это длина строки. Каждый такой элемент задает отдельный символ и принадлежит символьному типу char .
В этом примере показано, как можно работать с отдельными символами строки и как можно работать со скалярным представлением строки.
Класс char
В C# есть символьный класс char, основанный на классе System.Char и использующий двухбайтную кодировку Unicode представления символов. Для этого типа в языке определены символьные константы — символьные литералы. Константу можно задавать:
- символом, заключенным в одинарные кавычки;
- escape-последовательностью;
- Unicode-последовательностью, задающей Unicode код символа.
Вот несколько примеров объявления символьных переменных и работы с ними:
Три символьные переменные инициализированы константами, значения которых заданы тремя разными способами. Переменная ch объявляется в объектном стиле, используя new и вызов конструктора класса. Тип char , как и все типы C#, является классом. Этот класс наследует свойства и методы класса object и имеет большое число собственных методов.
Существуют ли преобразования между классом char и другими классами? Явные или неявные преобразования между классами char и string отсутствуют, но, благодаря методу ToString , переменные типа char стандартным образом преобразуются в тип string . Поскольку у каждого символа есть свой код, существуют неявные преобразования типа char в целочисленные типы, начиная с типа ushort . Обратные преобразования целочисленных типов в тип char также существуют, но они уже явные.
В результате работы процедуры TestChar строка s , полученная сцеплением трех символов, преобразованных в строки, имеет значение BZX , переменная ch равна A в латинском алфавите, а ее код — переменная code — 65 . Хотя преобразования символа в код и обратно просты, полезно иметь процедуры, выполняющие взаимно-обратные операции , — получение по коду символа и получение символа по его коду:
В первой процедуре преобразование к целому типу выполняется неявно. Во второй — преобразование явное.
Говоря о символах и их кодировке, следует помнить, что для символов алфавитов естественных языков (латиницы, кириллицы) применяется плотная кодировка . Это означает, что поскольку буква z в латинице следует за буквой y, код z на единицу больше кода y . Только буква «Ё» в кириллице не подчиняется этому правилу. Для цифр также используется плотная кодировка , и их коды предшествуют кодам букв. Заглавные буквы в кодировке предшествуют строчным. Ряд символов воспринимаются как управляющие , выполняя при их появлении определенное действие. К подобным относятся такие символы, как » перевод строки » ( new line ), » возврат каретки » ( carriage return ), «звонок». Эти символы не имеют видимого образа, а их коды задаются escape последовательностями ( ‘\n’, ‘\r’ ). Поскольку алфавит , задаваемый Unicode-кодировкой, содержит более 65000 символов, большинство кодов зарезервировано и им пока не соответствуют реальные символы. Рассмотрим пример, демонстрирующий коды некоторых символов.
Процедуры печати PrintCode и PrintSym достаточно просты, так что код их не приводится. Результат работы этого метода показан на рис. 7.1.
Класс char , как и все классы в C#, наследует свойства и методы родительского класса object . Но у него есть и собственные методы и свойства, и их немало. Приведу сводку этих методов.
| Метод | Описание |
|---|---|
| GetNumericValue | Возвращает численное значение символа, если он является цифрой, и (-1) в противном случае. |
| GetUnicodeCategory | Все символы разделены на категории. Метод возвращает Unicode категорию символа. Ниже приведен пример. |
| IsControl | Возвращает true, если символ является управляющим. |
| IsDigit | Возвращает true, если символ является десятичной цифрой. |
| IsLetter | Возвращает true, если символ является буквой. |
| IsLetterOrDigit | Возвращает true, если символ является буквой или цифрой. |
| IsLower | Возвращает true, если символ задан в нижнем регистре. |
| IsNumber | Возвращает true, если символ является числом (десятичной или шестнадцатеричной цифрой). |
| IsPunctuation | Возвращает true, если символ является знаком препинания. |
| IsSeparator | Возвращает true, если символ является разделителем. |
| IsSurrogate | Некоторые символы Unicode с кодом в интервале [0x1000, 0x10FFF] представляются двумя 16-битными «суррогатными» символами. Метод возвращает true, если символ является суррогатным. |
| IsUpper | Возвращает true, если символ задан в верхнем регистре. |
| IsWhiteSpace | Возвращает true, если символ является «белым пробелом». К белым пробелам, помимо пробела, относятся и другие символы, например, символ конца строки и символ перевода каретки. |
| Parse | Преобразует строку в символ. Естественно, строка должна состоять из одного символа, иначе возникнет ошибка. |
| ToLower | Приводит символ к нижнему регистру. |
| ToUpper | Приводит символ к верхнему регистру. |
| MaxValue, MinValue | Свойства, возвращающие символы с максимальным и минимальным кодом. Возвращаемые символы не имеют видимого образа. |
Большинство статических методов перегружены. Они могут применяться как к отдельному символу, так и к строке, для которой указывается номер символа для применения метода. Основную группу составляют методы Is , крайне полезные при разборе строки. Приведу примеры, в которых используются многие из перечисленных методов:
Вот как выглядят результаты консольного вывода, порожденного выполнением метода.
Обратите внимание: буквенными символами являются как символы латиницы, так и кириллицы, символ возврата каретки относится к белым пробелам и к управляющим символам, а символ точки с запятой к разделителям не относится.
Кроме статических методов, у класса char есть и динамические методы. Большинство из них — это методы родительского класса object , унаследованные и переопределенные в классе char . Из собственных динамических методов стоит отметить метод CompareTo , позволяющий проводить сравнение символов. Он отличается от метода Equal тем, что для несовпадающих символов выдает » расстояние » между символами в соответствии с их упорядоченностью в кодировке Unicode.
Класс char[] — массив символов
В языке C# определен класс char[], и его можно использовать для представления строк постоянной длины, как это делается в С++. Более того, поскольку массивы в C# динамические, расширяется класс задач, в которых можно использовать массивы символов для представления строк. Так что имеет смысл разобраться, насколько хорошо C# поддерживает работу с таким представлением строк.
Массив char[] — это обычный массив, элементы которого являются символами. Массив символов можно преобразовать в строку, можно выполнить и обратное преобразование. У класса string есть конструктор, которому в качестве аргументов можно передать массив символов. У класса string есть динамический метод ToCharArray , преобразующий строку в массив символов.
Класс char[] , как и всякий класс-массив в C#, является наследником не только класса object , но и класса Array . Некоторые методы класса Array можно рассматривать как операции над строками. Например, метод Copy дает возможность выделять и заменять подстроку в теле строки. Методы IndexOf , LastIndexOf позволяют определить индексы первого и последнего вхождения в строку некоторого символа. К сожалению, их нельзя использовать для более интересной операции — нахождения индекса вхождения подстроки в строку. При необходимости такую процедуру можно написать самому. Вот как она выглядит:
В реализации используется метод IndexOf класса Array , позволяющий найти начало совпадения строк, после чего проверяется совпадение остальных символов. Реализованный здесь алгоритм является самым очевидным, но не самым эффективным.
А теперь рассмотрим метод, тестирующий преобразования строк и массивов символов.
Существует ли в C# строки типа char*
В языке C# указатели допускаются в блоках, отмеченных как небезопасные. Теоретически в таких блоках можно объявить переменную типа char*, рассматривая ее как строку. В C# строки типа char* использовать не рекомендуется.
4.11 – Символы
На данный момент базовые типы данных, которые мы рассмотрели, использовались для хранения чисел (целые числа и числа с плавающей запятой) или значений истина/ложь (логические значения). Но что, если мы хотим хранить буквы?
Для хранения символов был разработан тип данных char . Символом может быть одна буква, цифра, знак или пробел.
Тип данных char является целочисленным типом, что означает, что базовое значение хранится как целое число. Подобно тому, как логическое значение 0 интерпретируется как false , а ненулевое значение интерпретируется как true , целое число, хранимое переменной char , интерпретируется как символ ASCII.
ASCII расшифровывается как American Standard Code for Information Interchange (Американский стандартный код для обмена информацией) и определяет конкретный способ представления английских символов (плюс несколько других символов) в виде чисел от 0 до 127 (называемых кодом ASCII или кодовым обозначением). Например, код ASCII 97 интерпретируется как символ ' а '.
Символьные литералы всегда помещаются в одинарные кавычки (например, ' g ', ' 1 ', ' ').
Ниже приведена полная таблица символов ASCII:
Коды 0–31 называются непечатаемыми символами и в основном используются для форматирования и управления принтерами. Большинство из них сейчас устарели.
Коды 32–127 называются печатными символами и представляют собой буквы, цифры и знаки препинания, которые большинство компьютеров используют для отображения основного английского текста.
Инициализация переменных char
Вы можете инициализировать переменные типа char , используя символьные литералы:
Вы также можете инициализировать переменные типа char целыми числами, но этого, если возможно, следует избегать.
Предупреждение
Будьте осторожны, чтобы не перепутать символы чисел с целыми числами. Следующие две инициализации не эквивалентны:
Символы чисел предназначены для использования, когда мы хотим представить числа в виде текста, а не в виде чисел и применения к ним математических операций.
Печать переменных типа char
При использовании std::cout для печати переменной типа char , std::cout выводит переменную char как символ ASCII:
Данная программа дает следующий результат:
Мы также можем напрямую выводить символьные литералы:
В результате это дает:
Напоминание
В C++ целочисленный тип фиксированной ширины int8_t обычно обрабатывается так же, как signed char , поэтому он обычно печатается как символ ( char ) вместо целого числа.
Печать переменных char как целых чисел через приведение типов
Если мы хотим вывести char как число вместо символа, мы должны указать std::cout , чтобы он печатал переменную char , как если бы она была целочисленного типа. Один (плохой) способ сделать это – присвоить значение переменной char другой переменной целочисленного типа и напечатать эту переменную:
Однако это довольно коряво. Лучше использовать приведение типа. Приведение типа создает значение одного типа из значения другого типа. Для преобразования между базовыми типами данных (например, из char в int или наоборот) мы используем приведение типа, называемое статическим приведением.
Синтаксис статического приведения выглядит немного забавным:
static_cast принимает значение из выражения в качестве входных данных и преобразует его в любой базовый тип, который представляет новый_тип (например, int , bool , char , double ).
Ключевые выводы
Всякий раз, когда вы видите синтаксис C++ (за исключением препроцессора), в котором используются угловые скобки, то, что между угловыми скобками, скорее всего, будет типом. Обычно C++ работает с концепциями, которым нужен параметризуемый тип.
Ниже показан пример использования статического приведения для создания целочисленного значения из нашего значения char :
Эта программа дает следующий вывод:
Важно отметить, что параметр static_cast вычисляется как выражение. Когда мы передаем переменную, эта переменная вычисляется для получения ее значения, которое затем преобразуется в новый тип. На переменную не влияет приведение ее значения к новому типу. В приведенном выше случае переменная ch по-прежнему является char и сохраняет то же значение.
Также обратите внимание, что статическое приведение не выполняет никакой проверки диапазона значений, поэтому, если вы приведете большое целое число в char , вы вызовете переполнение своей переменной char .
О статическом приведении типов и других типах приведения мы поговорим подробнее в следующем уроке (8.5 – Явное преобразование типов (приведение) и static_cast ).
Ввод символов
Следующая программа просит пользователя ввести символ, а затем печатает его как символ и его код ASCII:
Ниже показан результат одного запуска:
Обратите внимание, что std::cin позволяет вводить несколько символов. Однако переменная ch может содержать только 1 символ. Следовательно, в переменную ch извлекается только первый входной символ. Остальная часть пользовательского ввода остается во входном буфере, который использует std::cin , и может быть извлечена с помощью последующих вызовов std::cin .
Вы можете увидеть это поведение в следующем примере:
Размер, диапазон и символ по умолчанию у переменных char
char определяется C++ всегда размером 1 байт. По умолчанию char может быть со знаком или без знака (хотя обычно он со знаком). Если вы используете переменные char для хранения символов ASCII, вам не нужно указывать знак (поскольку переменные char со знаком и без знака могут содержать значения от 0 до 127).
Если вы используете char для хранения небольших целых чисел (чего не следует делать, если вы явно не оптимизируете используемую память), вы всегда должны указывать, со знаком переменная или нет. signed char (со знаком) может содержать число от -128 до 127. unsigned char (без знака) может содержать число от 0 до 255.
Экранированные последовательности
В C++ есть некоторые символы, которые имеют особое значение. Эти символы называются экранированными последовательностями (управляющими последовательностями, escape-последовательностями). Экранированная последовательность начинается с символа '\' (обратный слеш), за которым следует буква или цифра.
Вы уже видели наиболее распространенную экранированную последовательность: ' \n ', которую можно использовать для вставки символа новой строки в текстовую строку:
Эта программа выдает:
Еще одна часто используемая экранированная последовательность – ' \t ', которая включает горизонтальную табуляцию:
Три других примечательных экранированных последовательности:
- \' – печатает одинарную кавычку;
- \" – печатает двойную кавычку;
- \\ – печатает обратный слеш.
Ниже приведена таблица всех экранированных последовательностей:
| Название | Символ | Назначение |
|---|---|---|
| Предупреждение | \a | Выдает предупреждение, например звуковой сигнал |
| Backspace | \b | Перемещает курсор на одну позицию назад |
| Перевод страницы | \f | Перемещает курсор на следующую логическую страницу |
| Новая строка | \n | Перемещает курсор на следующую строку |
| Возврат каретки | \r | Перемещает курсор в начало строки |
| Горизонтальная табуляция | \t | Печать горизонтальной табуляции |
| Вертикальная табуляция | \v | Печатает вертикальную табуляцию |
| Одинарная кавычка | \' | Печать одинарной кавычки |
| Двойная кавычка | \" | Печать двойной кавычки |
| Обратная косая черта | \\ | Печатает обратный слеш |
| Вопросительный знак | \? | Печатает вопросительный знак Больше не актуально. Вы можете использовать вопросительные знаки без экранирования. |
| Восьмеричное число | \(число) | Преобразуется в символ, представленный восьмеричным числом |
| Шестнадцатеричное число | \x(число) | Преобразуется в символ, представленный шестнадцатеричным числом |
Вот несколько примеров:
Эта программа напечатает:
Новая строка ( \n ) против std::endl
В чем разница между заключением символов в одинарные и двойные кавычки?
Отдельные символы всегда заключаются в одинарные кавычки (например, 'a', '+', '5'). char может представлять только один символ (например, букву а, знак плюса, цифру 5). Что-то вроде этого некорректно:
Текст, заключенный в двойные кавычки (например, "Hello, world!"), называется строкой. Строка – это набор последовательных символов (и, таким образом, строка может содержать несколько символов).
Пока вы можете использовать строковые литералы в своем коде:
Правило
Всегда помещайте отдельные символы в одинарные кавычки (например, ' t ' или ' \n ', а не " t " или " \n "). Это помогает компилятору более эффективно выполнять оптимизацию.
А как насчет других типов символов, wchar_t , char16_t и char32_t ?
wchar_t следует избегать почти во всех случаях (за исключением взаимодействия с Windows API). Его размер определяется реализацией и не является надежным. Он не рекомендуется для использования.
В качестве отступления.
Англоязычный термин «deprecated» (не рекомендуется) означает «всё еще поддерживается, но больше не рекомендуется для использования, потому что он был заменен чем-то лучшим или больше не считается безопасным».
Подобно тому, как ASCII сопоставляет целые числа 0–127 с символами английского алфавита, существуют и другие стандарты кодировки символов для сопоставления целых чисел (разного размера) с символами других языков. Наиболее известной кодировкой за пределами диапазона ASCII является стандарт Unicode (Юникод), который сопоставляет более 110 000 целых чисел с символами на многих языках. Поскольку Unicode содержит очень много кодовых обозначений, то для одного кодового обозначения, чтобы представить один символ, Unicode требуется 32 бита (кодировка UTF-32). Однако символы Unicode также могут быть закодированы с использованием 16-ти или 8-ми битов (кодировки UTF-16 и UTF-8 соответственно).
char16_t и char32_t были добавлены в C++11 для обеспечения явной поддержки 16-битных и 32-битных символов Unicode. char8_t был добавлен в C++20.
Если вы не планируете сделать свою программу совместимой с Unicode, вам не нужно использовать char8_t , char16_t или char32_t . Юникод и локализация в основном выходят за рамки этих руководств, поэтому мы не будем рассматривать их дальше.
А пока при работе с символами (и строками) вы должны использовать только символы ASCII. Использование символов из других наборов символов может привести к неправильному отображению ваших символов.
Переменная типа char в C++ для начинающих и как с ней работать
#include <conio.h>
int main()
clrscr(); //Очищаем экран
char s1; //Объявляем переменную s1
s1[0]=*”y” //Присвоение переменной s1 значения
cout<<y; //Выводим букву y на экран
return 0;
>
Настолько всё оказалось просто, перед знаком = нужно было поставить знак * и нужнобыло объявить номер элемента (ноль соответствет первому)
Но переменную char чаще используют как массив каких-то символьных значений. Знакомство с простым массивом было изложено в статье
Одномерный массив в C++ для начинающих
Для работы с массивами часто необходимо использовать циклы. В прошлой статье был использован цикл for. Про ккотрый описано в статье
Цикл for в С++ для начинающих
Т.е. часто символьную переменную объявляют как набор одинарных символов. Даже строковая переменная, о которой я когда-нибудь тоже напишу – это не более чем набор значений типа char
Первоначально лучше изучить как работать и как использовать именно символьную переменную типа char, а потом уже изучать строковую. Посимвольное считывание из каких-то источников очень часто используется в программировании, поэтому это важный этап.
Есть много технической литературы, где правильно и глубоко описывается принцип работы и главная идея переменной char , но я считаю, углубляться пока не особо нужно. Но важно знать как при необходимости присваивать значения переменной.
Второй вопрос передо мной встал как – а как обнулить переменную типа char в C++ ?, при поиске я почему-то натыкался на исходник целой функции, которая была написана не самым понятным для новичков языком. На этот вопрос я легко смог ответить, когда понял как такой переменной присваивать значения.
т.е. Если у нас переменная s1 равна Буква y, но нам нужно её очистить, то мы это делаем так
s1=*””
Ставим знак равенства, ставим звездочку и ставим две двойные кавычки подряд
Две двойные кавычки подряд соответсвтуют обнулению значения в символьных переменных.
Так как переменную типа char часто используют как массив, то определяют количество возможных значений.
Например, код
int main()
char s1 [100]; //Объявляем переменную s1
return 0;
>
Почти равносилен тому, что мы объявили строку, состоящую из 101 символа.
Если не понимаете почему 101, а не 100 – лучше изучайте массивы. Напоминаю пример простого массива приведен в одной из прошлых статей Одномерный массив в C++ для начинающих
Есть небольшой нюанс при обработке массива. Так как для обработки мы используем цикл, то если объявленный нами символьный Массив типа char в 101 символ, содержит, например, 5 символов, то неразумно использовать цикл пока мы не достигнем конца нашего массива. – Потомучто если в программе будут тысячи таких операций – это существенно замедлит скорость работы программы
При объявлении любой переменной, переменной отводится какой-то участок памяти и память эта может уже содержать какое-то значение. Это значение не обязательно пустое или ноль и по умолчанию очень легко присвоится нашей переменной.
Поэтому любые переменные при объявлении правильно обнулять.
Для того, чтобы обнулить наш символьный массив s1 типа Char на языке программирования C++, после его объявления мы пишем такой код
===============
Программа обнуления массива типа char
int main()
char s1 [100]; //Объявляем переменную s1
(for int i=0;i<=100;i++) s1[i]=*””;
return 0;
>
==============
Преимущество этого кода в том, что теперь мы можем определить окончание заполненных ячеек массива, независимо от того, сколько их объявлено. Для этого мы должны указывать условие, что если ячейка пустая, то значит можно прекращать работу с этим массивом и перехоить к дальнейшим действиям. Соответственно количество операций и нагрузка на процессор существенно уменьшаются.
Working with character (char) in C
C uses char type to store characters and letters. However, the char type is integer type because underneath C stores integer numbers instead of characters.In C, char values are stored in 1 byte in memory,and value range from -128 to 127 or 0 to 255.
In order to represent characters, the computer has to map each integer with a corresponding character using a numerical code. The most common numerical code is ASCII, which stands for American Standard Code for Information Interchange.
How to declare characters?
To declare a character in C, the syntax:
Complete Example in C:
Output
C library functions for characters
The Standard C library #include <ctype.h> has functions you can use for manipulating and testing character values:
How to convert character to lower case?
- int islower(ch)
Returns value different from zero (i.e., true) if indeed c is a lowercase alphabetic letter. Zero (i.e., false) otherwise.
Output:
How to convert character to upper case?
- int isupper(ch)
A value different from zero (i.e., true) if indeed c is an uppercase alphabetic letter. Zero (i.e., false) otherwise.
Check if character is an alphabet?
- isalpha(ch)
Returns value different from zero (i.e., true) if indeed c is an alphabetic letter. Zero (i.e., false) otherwise.
Check if character is a digit
- int isdigit(ch);
Returns value different from zero (i.e., true) if indeed c is a decimal digit. Zero (i.e., false) otherwise.
Check if character is a digit or alphabet
- int isalnum(ch);
Returns value different from zero (i.e., true) if indeed c is either a digit or a letter. Zero (i.e., false) otherwise.
Check if character is a punctuation
- int ispunct(ch)
Returns value different from zero (i.e., true) if indeed c is a punctuation character. Zero (i.e., false) otherwise.
Check if character is a space
- int isspace(ch)
Retuns value different from zero (i.e., true) if indeed c is a white-space character. Zero (i.e., false) otherwise.
- char tolower(ch) & char toupper(ch)
The value of the character is checked other if the vlaue is lower or upper case otherwise it is change and value is returned as an int value that can be implicitly casted to char.
Find size of character using Sizeof()?
To get the exact size of a type or a variable on a particular platform, you can use the sizeof operator. The expressions sizeof(type) yields the storage size of the object or type in bytes.
In the below example the size of char is 1 byte, but the type of a character constant like ‘a’ is actually an int, with size of 4.
Output
Note:
- All the function in Ctype work under constant time
What are the different characters supported?
The characters supported by a computing system depends on the encoding supported by the system. Different encoding supports different character ranges.
Different encoding are:
- ASCII
- UTF-8
- UTF-16
ASCII encoding has most characters in English while UTF has characters from different languages.
The following table illustrates the characters in ASCII code: 