Если у вас возникли сложности с курсовой, контрольной, дипломной, рефератом, отчетом по практике, научно-исследовательской и любой другой работой - мы готовы помочь.
Предоплата всего
Подписываем
БЕЛОРУССКИЙ ГОСУДАРСТВЕННЫЙ УНИВЕРСИТЕТ
факультет радиофизики и электроники
кафедра информатики
Н.В. Серикова
ПРАКТИЧЕСКОЕ РУКОВОДСТВО
к лабораторному практикуму
«СТРОКИ»
по курсу
«ПРОГРАММИРОВАНИЕ»
2010
МИНСК
Практическое руководство к лабораторному практикуму «СТРОКИ» по курсу «ПРОГРАММИРОВАНИЕ» предназначено для студентов, изучающих базовый курс программирования на языке С++, специальностей «Радиофизика», «Физическая электроника», «Компьютерная безопасность».
Руководство содержит некоторый справочный материал, примеры решения типовых задач с комментариями.
Все примеры протестированы в среде Microsoft Visual Studio 2005.
Автор будет признателен всем, кто поделится своими сообра же ниями по совершенствованию данного пособия.
Воз можные предложения и замечания можно присылать по адресу:
E-mail: Serikova@bsu.by,
ОГЛАВЛЕНИЕ
Строки
Строка – последовательность символов кодовой таблицы ПЭВМ, обрабатываемая как единая структура. Строка может включать буквы, цифры и разнообразные специальные символы.
Такая последовательность должна быть ограничена, то есть нужно знать, где она заканчивается. Есть два варианта связать со строкой ее размер: хранить его, либо ограничить строку специальным символом (элементом последовательности), дойдя до которого мы будем знать, что достигли конца.
Языки программирования имеют различные типы данных для представления строк и библиотеки функций для работы со строками.
Строки используются во многих приложениях для содержания текстовых данных, для организации интерфейса программы пользователя.
Элементом строки является символ.
Количество символов в строке определяет длину и размер строки.
Размер строки - общая длина строки, которая характеризует размер памяти, выделяемый строке при описании.
Длина строки - текущая длина строки (всегда меньше или равна размеру строки), которая показывает количество символов строки в каждый конкретный момент времени.
В каждом языке программирования существует функция для определения текущей длины строки. Размер строки всегда больше, чем длина строки. Это связано с тем, что в памяти, отводимой для строковой переменой, дополнительно хранится либо размер строки, либо нуль-символ.
Нуль-символ (\0) отмечает конец нуль-терминированной строки. Хотя нуль-символ записывается в виде двух символов, компилятор его интерпретирует как один символ, который может храниться в переменной символьного типа.
Строка, в которой нет символов, называется пустой. Длина пустой строки равна 0. Размер пустой строки равен 1. В языках программирования существует разница между символом и строкой длинны 1 символ.
При объявлении строковых переменных, как правило, необходимо указывать максимальную длину строки. В том случае, если длина строки не задана, для строковой переменной резервируется максимально возможный размер памяти, который отводится в данном языке программирования для строковых переменных.
Инициализация строковой переменной может происходить при объявлении или непосредственно в программе. Размер инициализирующей строки не должен превышать максимальной длины строковой переменной.
Операции сравнения выполняются над строками в лексикографическом порядке.
Лексикографический порядок – порядок сравнения строк, принятый во многих языках программирования.
При лексикографическом сравнении последовательно, начиная с первого символа, сравниваются коды символов строки. Те символы считаются больше, чьи коды больше, и наоборот. Сравнение происходит до первого несовпадения символов. Та строка считается большей, у которой код первого несовпадающего символа больше, и наоборот. Если начала строк совпадают, то более короткая строка считается меньше более длинной.
Кодировка (кодовая таблица) - это однозначное соответствие между целым число (кодом) и символом. Кодировки обычно составляют так, что символы следуют в алфавитном порядке и символ 'а' имеет наименьший код, а символ 'z' наибольший. Таким образом, выполняя лексикографическое сравнение строк можно разместить их в алфавитном порядке.
Строки символов в С++
Способы представления строк символов в C++
С-Строки (завершающиеся нулевым байтом)
char s [] = “Hello”;
char s [6] = “ Hello”;
char s [6] = {‘H’, ‘e’, ‘l’, ‘l’, ‘o’, ‘\0’};
char s[10] = “Hello”;
Основные отличия строк, завершающих нулевым байтом, от массивов
Основные ограничения на действия со строками,
завершающимися нулевым байтом (С-строками)
.
Функции преобразования (С-строки)
STDLIB.H
|
ИМЯ ФУНКЦИИ |
ЗАПИСЬ |
ОПИСАНИЕ |
|
|
1 |
аtof |
double atof(char *str) |
Преобразует строку str в вещественное число |
|
2 |
atoi |
int atoi(char *str) |
Преобразует строку str в десятичное число |
|
3 |
аtol |
long atol (char *str) |
Преобразует строку str в длинное десятичное число |
|
4 |
fcvt _fcvt_s |
char* fcvt (double value, int count, int *dec, int *sign )
errno_t _fcvt_s ( char* buffer, size_t sizeInBytes, double value, int count, int *dec, int *sign ) |
Преобразует число с плавающей точкой типа value в строку. результат – строка, содержащая результат конвертации. value – число для конвертации. count – число цифр после запятой. dec – количество цифр целой части. sign – знак числа (0 или 1) Преобразует число с плавающей точкой типа value в строку buffer. В случае успеха – возвращает значение 0. buffer – строка, содержащая результат конвертации. sizeInBytes – размер строки buffer в байтах. value – число для конвертации. count – число цифр после запятой. dec – количество цифр целой части. sign – знак числа (0 или 1) |
|
5 |
itoa _itoa_s |
char * itoa (int v, char *str, int baz) char * _itoa_s (int v, char *str, int baz) |
Преобразует целое v в строку str. baz – основание системы счисления 2<=baz<=36. |
|
6 |
ltoa _ltoa_s |
char * ltoa (long v, char *str, int baz) char * _ltoa_s (long v, char *str, int baz) |
Преобразует длинное целое v в строку str . baz – основание системы счисления 2<=baz<=36. |
|
7 |
strtod |
double strtod (char *str1, char **str2) |
Преобразует строку str1 в вещественное число, параметр str2 возвращает указатель на первый символ, который не может быть интерпретирован как часть числа (= NULL, если преобразование выполнено корректно). |
|
8 |
strtol |
long strtol (char *str1, char **str2, int base) |
Преобразует строку str1 в десятичное целое по основанию base, параметр str2 возвращает указатель на первый символ, который не может быть интерпретирован как часть числа (= NULL, если преобразование выполнено корректно). |
|
9 |
ultoa _ultoa_s |
сhar *ultoa(unsigned long v, char *str, int baz) сhar *_ultoa_s(unsigned long v, char *str, int baz) |
Преобразует беззнаковое длинное целое v в строку str . baz – основание системы счисления 2<=baz<=36. |
Функции для работы с С-строками
STRING.H
|
ИМЯ ФУНКЦИИ |
ЗАПИСЬ |
ОПИСАНИЕ |
|
|
1 |
strcat |
char* strcat (char *str1, char *str2) |
Выполняет конкатенацию (объединение) строк, записывая результат по адресу первого аргумента. |
|
strcat_s |
errno_t strcat_s (char *str1, size_t n, char *str2) |
Выполняет конкатенацию (объединение) строк, записывая результат по адресу первого аргумента. n - размер строки str1. |
|
|
2 |
strchr |
char * strchr (char *str, char c) |
Находит в строке str первое вхождение символа c. Если его нет, то возвращает NULL. |
|
3 |
strcmp |
int strcmp (char *str1, char *str2) |
Сравнивает строки str1 и str2. Результат <0, если str1<str2, =0 если str1=str2, >0, если str1>str2 |
|
4 |
strcpy strcpy_s |
char * strcpy(char *str1, char *str2) char* strcpy_s (char *str1, size_t n, char *str2) |
Копирует строку str2 в строку str1 Копирует строку str2 в строку str1. n - размер строки str1. |
|
5 |
strcspn |
int strcspn( char *str1, char *str2) |
Определяет длину первого сегмента строки str1, содержащего символы, не входящие во множество символов строки str2. Если его нет, то возвращает NULL. |
|
6 |
strdup _strdup |
char* strdup (char *str) char* _strdup (char *str) |
Дублирование строки str с выделением ей памяти |
|
7 |
strlen |
unsigned int strlen ( char *str) |
Вычисляет длину строки str , не включая нуль-символ. |
|
8 |
strlwr _strlwr_s |
char* strlwr (char *str) char* _strlwr_s (char *str, size_t n) |
Преобразует буквы верхнего регистра в строке str в буквы нижнего регистра Преобразует буквы верхнего регистра в строке str в буквы нижнего регистра. n - размер строки str. |
|
9 |
strncat strncat_s |
char * strncat( char *str1, char *str2, int kol) errno_t strncat_s( char *str1, size_t n, char *str2, int kol) |
Приписывает kol символов строки str2 к строке str1. Приписывает kol символов строки str2 к строке str1. n - размер строки str1. |
|
10 |
strncmp |
int strncmp(char *str1, char *str2, unsigned int kol) |
Сравнивает строки str1 и str2., причем рассматриваются только первые kol символов. Результат <0, если str1<str2, =0 если str1=str2, >0, если str1>str2 |
|
11 |
strncpy |
char * strncpy (char *str1, char *str2, unsigned int kol) |
Копирует kol символов строки str2 в строку str1. Функция не выполняет ни усечения, ни заполнение строки. |
|
12 |
strpbrk |
char * strpbrk (char *str1, char *str2) |
Находит в строке str1 первое появление любого из множества символов, входящих в строку str2. Если его нет, то возвращает NULL. |
|
13 |
strrchr |
char * strrchr( char *str, char c) |
Находит в строке str последнее вхождение символа c. Если его нет, то возвращает NULL. |
|
14 |
strrev |
char * strrev( char *str) |
Инвертирование (реверс) строки str |
|
15 |
strspn |
int strspn( char *str1, char *str2) |
Определяет длину первого сегмента строки str1, содержащего символы, входящие во множество символов строки str2. Если его нет, то возвращает NULL. |
|
16 |
strstr |
char *strstr (char *str1, char *str2) |
Определяет адрес первого вхождения в строку str1 подстроки str2. Если подстрока не найдена, то возвращается указатель NULL. |
|
17 |
strtok |
char * strtok(char *str1, char *str2) |
Функция разбивает переданную ей строку (первый аргумент вызова) на лексемы в соответствии с заданным набором разделителей (второй аргумент). Функция возвращает указатель на первую из найденных лексических единиц или значение NULL, если таких единиц в строке-аргументе нет. После выделения лексической единицы из аргумента str1 непосредственно за ней размещается символ с нулевым кодом. Функция изменяет разбиваемую на лексемы строку. |
|
strtok_s |
char * strtok_s (char *str1, char *str2, char** sm) |
Функция разбивает переданную ей строку (первый аргумент вызова) на лексемы в соответствии с заданным набором разделителей (второй аргумент). Функция возвращает указатель на первую из найденных лексических единиц или значение NULL, если таких единиц в строке-аргументе нет. После выделения лексической единицы из аргумента str1 непосредственно за ней размещается символ с нулевым кодом. Функция изменяет разбиваемую на лексемы строку. sm – используется для хранения информации во время вызова функции. (Указатель на ячейку памяти) |
|
|
18 |
strupr _strupr_s |
char* strupr (char *str) char* _strupr_s (char *str, size_t n) |
Преобразует буквы нижнего регистра в строке str в буквы верхнего регистра Преобразует буквы нижнего регистра в строке str в буквы верхнего регистра. n - размер строки str. |
Функции для работы со строками
Для строк не определена операция присваивания, поскольку строка является не основным типом данных, а массивом. Присваивание выполняется с помощью функций стандартной библиотеки strcpy или strncpy или посимвольно «вручную».
Функция strcpy (char *s1, char *s2) копирует все символы строки, указанной вторым параметром, включая завершающий 0, в строку, указанную первым параметром.
Функция strncpy (char *s1, char *s2, n) выполняет то же самое, но не более n символов. Если нуль-символ встретился в исходной строке раньше, то копирование прекращается, а оставшиеся до n символы строки s2 заполняются нуль-символами. В противном случае (если n меньше или равно длине строки s1) завершающий нуль-символ в s2 не добавляется.
Функция strlen(char *s) возвращает фактическую длину строки s, не включая нуль-символ.
Функции strcat и strncat используются для объединения строк.
Функция strcat (char *s1, char*s2) добавляет копию строки s2, включая завершающий нуль-символ, в конец строки s1. Первый символ строки s2 размещается в байте, в котором был записан нуль-символ строки s1. Если строка s1 заполнена, а s2 – не нулевая строка, то вызов strcat (s1, s2); перезапишет конец строки. Следите за длиной результирующей строки при конкатенации строк при вызове функции strcat (. . .).
Функция strncat(char *s1, char *s2, n) позволяет добавить не более чем n символов строки s2 в конец строки s1.
Функция strcmp (char *s1, char *s2) позволяет сравнить 2 строки. Функция возвращает 0, если строки равны, отрицательное значение, если первая строка меньше, чем вторая, и положительное значение, если первая строка больше, чем вторая. Функция strncmp (char *s1, char *s2, n) проводит сравнение только первых n символов двух строк.
Функции stricmp и strnicmp позволяют сравнивать строки без учета регистра, т.е. без различия между прописными и строчными буквами.
Функция strchr (const char *s, int c) реализует поиск одиночного символа в строке. Она возвращает значение NULL, если символ-аргумент в строке не найден, иначе возвращает указатель на этот символ.
Функция strcspn (char *s1, char *s2) - определяет и возвращает длину начальной части строки s1, состоящей из символов, не содержащихся в строке s2.
Функция strspn (const char *s1, const char *s2) - определяет и возвращает длину начальной части строки s1, состоящей только из символов, содержащихся в строке s2.
Функция strpbrk (char *s1, char *s2) - определяет позицию первого вхождения в строку s1 любого из символов строки s2. Если символ не найден, то возвращается указатель NULL.
Функция strstr (char *s1, char *s2) - определяет позицию первого вхождения в строку s1 подстроки s2. Если подстрока не найдена, то возвращается указатель NULL.
Функция char* strtok (char *s1, const char *s2) интерпретирует строку s1 как последовательность лексических единиц (слов), разделенных ограничителями, которые заданы в строке-аргументе, соответствующей параметру s2. Функция возвращает указатель на первую из найденных лексических единиц или значение NULL, если таких единиц в строке-аргументе нет. После выделения лексической единицы из аргумента s1 непосредственно за ней размещается символ с нулевым кодом. Таким образом, функция разбивает переданную ей строку (первый аргумент вызова) на лексемы в соответствии с заданным набором разделителей (второй аргумент). Эту функцию можно использовать для выделения в строке лексем-слов. Функция изменяет разбиваемую на лексемы строку, поэтому необходимо позаботиться о предварительном сохранении строки.
Функции для работы со строками
для Microsoft Visual Studio 2005
Функции
strcpy_s (char *s1, size_t n, char* s2)
strcat_s (char *s1, size_t n, char* s2)
strncat_s (char *s1, size_t n, char *s2, k)
_strlwr_s ( char *s1, size_t n)
_strupr_s( char *s1, size_t n)
аналогичны предыдущим функциям, n – размер строки s1. Как правило возвращают 0, если функция выполняется корректно.
Функция strtok_s (char *s1, const char *s2, char** sm) аналогична функции strtok. Причем sm – содержит начало следующей лексемы строки.
Ввод С-строк
При вводе строки с клавиатуры (помещение в поток cin) следует контролировать длину вводимой строки (чтобы она не превышала длину массива, где будет храниться строка
const int MAX=100;
char str[MAX];
cin >> setw (MAX) >> str; // Ввод до MAX-1 символов
При помещении строки в поток cin пробелы и символы новой строки конвертируются в завершающий нулевой байт
const int MAX=100;
char str [MAX];
cin >> setw (MAX) >> str;
// Введем строку "Good Morning"
cout << str; // Получим "Good"
Чтобы ввести строку, содержащую пробелы, необходимо вызвать встроенную функцию getline для потока cin:
char str [MAX];
cin.getline (str, MAX);
или можно задать свой разделитель строк:
char str [MAX];
char SEP = '$';
// Задаем свой разделитель строк
cin.getline (str, MAX, SEP);
Строки стандартного класса string
Язык С++ включает в себя новый класс, называемый string. Этот класс во многом улучшает традиционный строковый тип, позволяет обрабатывать строки также как данные других типов, а именно с помощью операторов. Он более эффективен и безопасен в использовании, не нужно заботиться о создании массива нужного размера для строковой переменной, класс string берет на себя ответственность за управлением памятью.
Если при создании приложения скорость выполнения не является доминирующим фактором, класс string предоставляет безопасный и удобный способ обработки строк.
Для работы со строками класса string существует множество методов и операций.
Объявление и инициализация строк string.
//создаем пустую строку
//вызов конструктора без аргументов
string s1;
// создаем строку из C-строки
//вызов конструктора с одним аргументом
string s2("aaaa");
// string s2 = "aaaa"; // или так
// создаем строку из C-строки 10 символов
//вызов конструктора с двумя аргументами
string s3("abcdefghijklmnopqrstuvwxyz",10);
// создаем строку из 5 одинаковых символов
string s4(5,’!’);
// создаем строку-копию из строки s3
string s5(s3);
// создаем строку-копию из строки s3
// начиная с индекса 5 не более 3 символов
string s6(s3,5,3);
Методы для работы со строками класса string
|
МЕТОД |
ЗАПИСЬ |
ОПИСАНИЕ |
|
|
1 |
at |
at (unsigned n) |
доступ к n-му элементу строки |
|
2 |
append |
append (string &str) |
добавляет строку str к концу вызывающей строки (тоже, что оператор + ) |
|
append (string &str, unsigned pos, unsigned n); |
добавляет к вызывающей строке n символов строки str, начиная с позиции pos |
||
|
append ( char *sr, unsigned n); |
добавляет к вызывающей строке n символов С-строки s |
||
|
3 |
assign |
assign (string &str) |
присваивает строку str вызывающей строке (тоже, что s2=s1) |
|
assign ( string &str, unsigned pos, unsigned n); |
присваивает вызывающей строке n символов строки str, начиная с позиции pos |
||
|
assign ( char *sr, unsigned n); |
присваивает вызывающей строке n символов C-строки s |
||
|
4 |
capacity |
unsigned int capacity (); |
возвращает объем памяти, занимаемый строкой |
|
5 |
compare |
int compare (string &str); |
сравнение двух строк, возвращает значение <0, если вызывающая строка лексикографически меньше str, =0, если строки равны и >0, если вызывающая строка больше |
|
int compare (string &str, unsigned pos, unsigned n); |
сравнение со строкой str n символов вызывающей строки, начиная с позиции pos; возвращает значение <0, если вызывающая строка лексикографически меньше str, =0, если строки равны и >0, если вызывающая строка больше |
||
|
int compare (unsigned pos1, unsigned n1, string &str, unsigned pos2, unsigned n2); |
n1 символов вызывающей строки, начиная с позиции pos1, сравниваются с подстрокой строки str длиной n2 символов, начиная с позиции pos2; возвращает значение <0, если вызывающая строка лексикографически меньше str, =0, если строки равны и >0, если вызывающая строка больше |
||
|
6 |
copy |
unsigned int copy (char *s, unsigned n, unsigned pos = 0); |
копирует в символьный массив s n элементов вызывающей строки, начиная с позиции pos; нуль-символ в результирующий массив не заносится; метод возвращает количество скопированных элементов |
|
7 |
c_str |
char * c_str() |
возвращает указатель на С-строку, содержащую копию вызываемой строки; полученную С-строку нельзя изменить |
|
8 |
empty |
bool empty(); |
возвращает истину, если строка пустая |
|
9 |
erase |
erase (unsigned pos = 0, unsigned n = npos); |
удаляет n элементов, начиная с позиции pos (если n не задано, то удаляется весь остаток строки) npos-самое большое число >0 типа unsigned |
|
10 |
find |
unsigned int find (string &str, unsigned pos = 0); |
ищет самое левое вхождение строки str в вызывающей строке, начиная с позиции pos; возвращает позицию вхождения, или npos(самое большое число >0 типа unsigned , если вхождение не найдено |
|
unsigned find (char c, unsigned pos = 0); |
ищет самое левое вхождение символа с в вызывающей строке, начиная с позиции pos; возвращает позицию вхождения, или npos(самое большое число >0 типа unsigned, если вхождение не найдено |
||
|
unsigned rfind (char c, unsigned pos = 0); |
ищет самое правое вхождение символа с в вызывающей строке, начиная с позиции pos; возвращает позицию вхождения, или npos(самое большое число >0 типа unsigned, если вхождение не найдено |
||
|
11 |
find_last_of |
unsigned find_last_of (string &str, unsigned pos = 0); |
ищет самое правое вхождение любого символа строки str в вызывающей строке, начиная с позиции pos; возвращает позицию вхождения, или npos(самое большое число >0 типа unsigned, если вхождение не найдено |
|
12 |
insert |
insert (unsigned pos, string &str); |
вставляет строку str в вызывающую строку, начиная с позиции pos |
|
insert (unsigned pos1, string &str, unsigned pos2, unsigned n); |
вставляет в вызывающую строку, начиная с позиции pos1 n символов строки str, начиная с позиции pos2 |
||
|
insert (unsigned pos, char * sr, unsigned n); |
вставляет в вызывающую строку n символов C-строки s, начиная с позиции pos |
||
|
13 |
length |
unsigned length (); |
возвращает размер строки |
|
14 |
max_size |
unsigned max_size(); |
возвращает максимальную длину строки |
|
15 |
replace |
replace (unsigned pos, unsigned n, string &str); |
заменяет n элементов, начиная с позиции pos вызывающей строки, элементами строки str |
|
replace (unsigned pos1, unsigned n1, string &str, unsigned pos2, unsigned n2); |
заменяет n1 элементов, начиная с позиции pos1 вызывающей строки, n2 элементами строки str, начиная с позиции pos2 |
||
|
replace (unsigned pos, unsigned n1, char *s, unsigned n2); |
заменяет n1 элементов, начиная с позиции pos вызывающей строки, n2 элементами C-строки s |
||
|
16 |
size |
unsigned size(); |
возвращает размер строки |
|
17 |
substr |
string substr(unsigned pos = 0, unsigned n = npos); |
выделяет подстроку длиной n из исходной строки, начиная с позиции pos |
|
18 |
swap |
swap (string &str) |
обменивает содержимое вызывающей строки и строки str |
Операции для работы со строками класса string
|
оператор |
ЗАПИСЬ string s1,s2,s3; |
ОПИСАНИЕ |
|
|
1 |
+ |
s3 = s1+ s2; |
конкатенация (сцепление) строк, можно присоединить единичный символ к строке |
|
2 |
+= |
s1 += s2; |
конкатенация (сцепление) строк с присвоением результата |
|
3 |
= |
s2 = s1; |
присваивание |
|
4 |
== |
s2 == s1 |
лексикографическое сравнение на равенство строк |
|
5 |
!= |
s2 != s1 |
лексикографическое сравнение на неравенство строк |
|
6 |
> |
s2 > s1 |
лексикографическое сравнение строк на > |
|
7 |
>= |
s2 >= s1 |
лексикографическое сравнение строк на >= |
|
8 |
< |
s2 < s1 |
лексикографическое сравнение строк на < |
|
9 |
<= |
s2 <= s1 |
лексикографическое сравнение строк на <= |
|
10 |
[] |
s1[i] |
индексация (обращение к элементу строки) |
|
11 |
>> |
cin >> s1; |
ввод строки (лучше метод getline) |
|
12 |
<< |
cout << s2; |
вывод строки |
ПРИМЕР 1. Инициализация С-строки
#include <iostream> // for cin cout
using namespace std;
void main()
{
const int MAX = 8;
//нулевой символ добавляется к концу строки автоматически
char str1[MAX] = "stroka1";
//нулевой символ добавляется к концу строки автоматически
char str2[] = "stroka2";
// нет \0
char str3[] = {'s', 't', 'r', 'o', 'k', 'a', '3'};
char str4[] = {'s','t','r','o','k','a','4','\0'};
char str5[MAX];
char *str6 = "stroka6";
cout << " 1 " << str1 << endl;
cout << " 2 " << str2 << endl;
cout << " 3 " << str3 << endl;
cout << " 4 " << str4 << endl;
// !!! нельзя константный указатель
str5 = "stroka5";
cout << " 5 " << str5 << endl;
cout << " 6 " << str6 << endl;
// !!! можно !!!
str6 = "stroka";
cout << " 6 " << str6 << endl;
}
ПРИМЕР 2. Ввод С-строки. Инструкция cin
#include <iostream> // for cin cout
using namespace std;
void main()
{
const int MAX = 80;
char str[MAX];
cout << " Enter a string: ";
//ввод выполняется до первого пробельного символа
cin >> str;
cout << "You entered: " << str << endl;
}
ПРИМЕР 3. Ввод С-строки. Функция gets
#include <stdio.h> // for gets puts
#include <iostream> // for cin cout
using namespace std;
void main()
{
const int n = 80;
char s[n];
cout << " Enter a string: ";
gets(s); // gets_s(s);
cout << "You entered: ";
puts(s); // puts_s (s);
}
ПРИМЕР 4. Ввод С-строки. Метод get
#include <iostream> // for cin cout
using namespace std;
void main()
{
const int MAX = 80;
char str [MAX];
char c;
cout << " 1 Enter a string: ";
// символ перевода строки '\n' остается в потоке
// в строковую переменную добавляется '\0'
cin.get (str, MAX);
cout << " 1 You entered: " << str << endl;
cin.get(); // удаление из потока символа ‘\n’.
cout << "\n 2 Enter a string:\n";
// свой разделитель для ввода строки
cin.get(str, MAX, '$');
cout << " You entered:\n" << str << endl;
c = cin.get(); // удаление из потока символа ‘$’.
cout<<c<<endl;
c = cin.get(); // удаление из потока символа ‘\n’.
cout<<int(c)<<endl;
cout << "\n 3 Enter a string: ";
//символ перевода строки '\n' остается в потоке
//в строковую переменную добавляется '\0'
cin.get (str, MAX);
cout << "3 You entered: " << str << endl;
cin.get(); // удаление из потока символа ‘\n’.
}
ПРИМЕР 5. Ввод С-строки. Метод getline
#include <iostream> // for cin cout
using namespace std;
void main()
{
const int MAX = 80;
char str [MAX];
cout << "\n 1 Enter a string: ";
//при этом '\n' также считывается (удаляется) из потока
//и вместо него в строковую переменную записывается '\0'
cin.getline (str, MAX);
cout << "1 You entered: " << str << endl;
cout << "\n 2 Enter a string: ";
//свой разделитель для ввода строки
//при этом '\n' также считывается (удаляется) из потока
//и вместо него в строковую переменную записывается '\0'
cin.getline (str, MAX, '&');
cout << "2 You entered: " << str << endl;
}
ПРИМЕР 6. Ввод С-строки с русскими буквами
#include <windows.h>
#include <iostream> // cin cout
using namespace std;
void main()
{
char buff[80];
cin.getline(buff,80); // "русский текст"
cout << "Моя программа"<< endl;
// на экране набор знаков
cout << buff << endl;
// на экране : "русский текст"
setlocale(LC_ALL, "rus");
cout << "Моя программа"<< endl;
// на экране: "Моя программа"
cout << buff << endl;
// на экране набор знаков
OemToAnsi(buff, buff);
cout << "Моя программа"<< endl;
// на экране: "Моя программа"
cout << buff << endl;
// на экране : "русский текст"
}
ПРИМЕР 7. Ввод С-строк. Метод getline
#include <string.h>
#include <iostream> // for cin cout
using namespace std;
void main()
{
const int n = 80;
char s[n];
// выход из цикла – конец файла – Ctrl+z
while (cin.getline(s, n))
{
if (! strcmp(s,""))
break;
cout << s << endl;
// .......... обработка строки
}
}
ПРИМЕР 8. Преобразование двоичного числа в десятичное.
#include <string.h>
#include <iostream> // for cin cout
using namespace std;
void main ()
{
char str[80];
long int dec;
int i, v = 1;
// двоичное число задаем в виде строки
cout << " Enter number v 2 ss ";
cin.getline (str, 80);
dec = 0;
for (i = strlen(str)-1; i >= 0; i--)
{ // значение элемента строки 0 или 1
if (str[i] == '1' )
{
dec += v; // добавляем к результату
cout<<v<<" ";
}
v *= 2; // вес следующего разряда
}
cout<<endl<<" result v 10 ss =" <<dec<<endl;
}
ПРИМЕР 9. Преобразование десятичного числа в двоичное.
#include <iostream> // for cin cout
using namespace std;
void main ()
{
char str[80];
int n, r;
cout<<" vvedite number v 10 ss"<<endl;
cin>>n;
int i = 0;
do
{
r = n % 2; //остаток от деления на основание с/с
n = n / 2; // частное от деления на основание с/с
str[i] = char('0' + r);
i++;
}
while (n > 0);
// цифры результата в строке str в обратном порядке
for(int j = 0; j < i / 2; j++)
// меняем порядок цифр на обратный
{ int c = str[j];
str[j] = str[i – j – 1];
str[i – j – 1] = c;
}
// конец строки i – номер позиции
str[i] = '\0';
cout<<" result v 2 ss= " <<str<<endl;
}
ПРИМЕР 10. Работа с символами С-строки
Задана строка символов. Получить новую строку из исходной, удалив символы ‘*’ и удвоив букву A (а).
#include <string.h>
#include <iostream> // for cin cout
using namespace std;
void main()
{
const int MAX = 80;
char str1 [MAX], str2 [MAX];
unsigned int i, k = 0;
cout << " Enter a string: ";
cin.getline (str1, MAX);
for (i = 0; str1[i]; i++)
{
if (str1[i] == '*') // если * пропускаем
continue;
// если А или а удваиваем
if (str1[i] == 'A'|| str1[i] == 'a')
str2[k++] = str1[i];
// в остальных случаях записываем в результирующую строку
str2[k++] = str1[i];
}
str2[k] = '\0'; // конец строки
cout << " Rezult = " << str2<< endl;
}
ПРИМЕР 11. Копирование С-строк. Функции strcpy, strcpy_s
#include <string.h>
#include <iostream> // for cin cout
using namespace std;
void main()
{
char st [20] = "*******************"; // 19 '*'
int i, err;
for (i = 0; i <= 19; i++)
cout << st[i];
cout << endl<< st << " " << strlen (st) << endl;
strcpy(st, "Good Morning");
for (i = 0; i <= 19; i++)
cout << st[i];
cout << endl<< st << " " << strlen (st) << endl;
err = strcpy_s(st, 20, "Hello World");
if (!err)
for (i = 0; i <= 19; i++)
cout << st[i];
cout << endl<< st << " " << strlen (st) << endl;
strcpy(st, "Hello");
for (i = 0; i <= 19; i++)
cout << st[i];
cout << endl<< st << " " << strlen (st) << endl;
cout << endl;
}
ПРИМЕР 12. Сравнение С-строк. Функции strcmp и strlen
#include <string.h>
#include <iostream> // for cin cout
using namespace std;
void main()
{
const int MAX = 80;
char buffer[MAX] = "";
int count = 0;
while (true)
{
cout << "Enter a string of less than 80
characters:\n";
cin.getline(buffer, MAX);
if (! strcmp(buffer, ""))
break;
for (count=0; buffer[count] != '\0'; count++);
cout << count << " " << strlen(buffer) <<endl;
}
}
ПРИМЕР 13. Объединение С-строк. Функции strcat, strncat, strcat_s, strcncat_s
#include <string.h> // for strcat strncat
#include <iostream> // for cin cout
using namespace std;
void main()
{ const int MAX = 80;
char s1[MAX] = "1", s2[MAX] = "22222", s3[MAX] = "333";
char* s4;
int err;
cout<<" 1 "<<endl;
cout<<" str1="<< s1<<endl;
cout<<" str2="<< s2<<endl;
cout<<" 2 "<<endl;
cout<<"str1+str2="<< strcat(s1, s2)<<endl;
cout<<" str1="<< s1<<endl;
cout<<" 3 "<<endl;
cout<<" str1="<< s1<<endl;
s4 = strcat(s1, s2);
cout<<" str1="<< s1<<endl;
cout<<"s4=str1+str2="<< s4<<endl;
cout<<" 4 "<<endl;
err = strcat_s(s1, MAX, s2);
if (!err) cout<<"str1+str2="<< s1<<endl;
cout<<" 5 "<<endl;
cout<<" str3="<< s3<<endl;
cout<<"str3+str2 ="<<strncat(s3, s2, 2)<<endl;
cout<<" str3="<< s3<<endl;
cout<<" 6 "<<endl;
s4 = strncat(s3, s2, 2);
cout<<" str3="<< s3<<endl;
cout<<"str4=str3+str2="<< s4<<endl;
cout<<" 7 "<<endl;
err = strncat_s(s3, MAX, s2, 2);
if (!err) cout<<"str1+str2="<< s3<<endl;
}
ПРИМЕР 14. Вхождение символа в С-строку. Функция strchr
#include <string.h>
#include <iostream> // for cin cout
using namespace std;
void main()
{
const int MAX = 80;
char s[MAX] = "1234567890abcdefghABCDEFGH";
char c;
char* str;
int n;
cout<<" c = "<<endl;
cin>>c;
while(c != '!')
{
str = strchr(s, c);
if (str != NULL)
{ // определение позиции найденного символа
n = int (str – s) ;
cout<<" simvol ="<<c<< " v"<<n<<"pozicii"<< endl;
}
else
cout<<" simvola ="<<c<< " net "<<endl;
cout<<" c= "<<endl;
cin>>c;
}
}
ПРИМЕР 15. Вхождение С-подстроки в С-строку. Функция strstr
#include <string.h>
#include <iostream> // for cin cout
using namespace std;
void main()
{
const int MAX = 80;
char s1[MAX], s2[MAX];
char* str;
int n;
cout << " s1= \n";
cin.getline(s1, MAX);
while(true)
{
cout << " s2= \n";
cin.getline(s2, MAX);
if (! strcmp(s2, ""))
break;
str=strstr(s1, s2);
if (str != NULL)
{
// определение позиции найденной подстроки
n = int (str - s1);
cout<<" s2 v s1 c ="<<n<<"pozicii"<<endl;
}
else
cout<<" s2 no s1"<<endl;
}
}
ПРИМЕР 16. Вхождение символов в С-строку. Функции strspn, strcspn
#include <string.h>
#include <iostream> // for cin cout
using namespace std;
void main()
{
const int MAX = 80;
char s1[MAX], s2[MAX];
int n1, n2;
cout << " s1= \n";
cin.getline(s1, MAX);
while(true)
{
cout << " s2= \n";
cin.getline(s2, MAX);
if (! strcmp(s2,""))
break;
n1 = strspn(s1, s2);
cout<<" dlina first part s1 only iz simvolov
s2 = "<< n1<<endl;
n2 = strcspn(s1, s2);
cout<<endl<<" dlina first part no simvolov
s2 = "<< n2<<endl;
}
}
ПРИМЕР 17. Определение С-подстроки из С-строки. Функция strpbrk
#include <string.h>
#include <iostream> // for cin cout
using namespace std;
void main()
{
const int MAX = 80;
char s1[MAX], s2[MAX];
char* str;
cout << " s1= \n";
cin.getline(s1, MAX);
while(true)
{
cout << " s2= \n";
cin.getline(s2, MAX);
if (! strcmp(s2,""))
break;
str = strpbrk(s1,s2);
if (str != NULL)
cout<<" podstroka s1 "<<str<<endl;
else
cout<<" v s1 net simvolov iz s2 "<<endl;
}
}
ПРИМЕР 18. Замена символов в С-строке из нижнего регистра в верхний. Функции strupr, _strupr_s
#include <string.h>
#include <iostream> // for cin cout
using namespace std;
void main()
{
const int MAX = 80;
char str[MAX];
char *s;
int err;
cout << " str= ";
cin.getline(str, MAX);
s = strupr(str);
cout<<str<<" rezult = "<< s <<endl;
cout << " str= ";
cin.getline(str, MAX);
err = _strupr_s(str, MAX);
if (!err)
cout<<" rezult = "<< str <<endl;
}
ПРИМЕР 19. Замена символов в С-строке из верхнего регистра в нижний. Функции strlwr,_strlwr_s
#include <string.h>
#include <iostream> // for cin cout
using namespace std;
void main()
{
const int MAX = 80;
char str [MAX];
char * s;
int err;
cout << " str= ";
cin.getline(str, MAX);
s = strlwr(str);
cout<<str<<" rezult = "<<s<<endl;
cout << " str= ";
cin.getline(str, MAX);
err = _strlwr_s (str, MAX);
if (!err)
cout<<" rezult = "<< str <<endl;
}
ПРИМЕР 20. Преобразование С-строки в число. Функции atoi, atof
#include <string.h> // for strcmp
#include <stdlib.h> // for atoi atof
#include <iostream> // for cin cout
using namespace std;
void main()
{
const int MAX = 80;
char str[MAX] = "abcd";
int i;
double f;
i = atoi(str);
cout<<i<<endl;
while (true)
{
cout << "1 Enter a string \n";
cin.getline(str, MAX);
if (! strcmp(str,""))
break;
i = atoi(str);
cout<<i<<endl;
}
while (true)
{
cout<<"2 Enter a string \n";
cin.getline(str, MAX);
if (! strcmp(str,""))
break;
f = atof(str);
cout<<f<<endl;
}
}
ПРИМЕР 21. Преобразование С-строки в число. Функция strtol
#include <string.h> // for strcmp
#include <stdlib.h> // for strtol
#include <iostream> // for cin cout
using namespace std;
void main()
{
const int MAX = 80;
char str[MAX] = "abcd";
char *err;
long l;
int base;
cout<< " 1 " <<endl;
l = strtol(str, &err, 10);
cout<<l<<endl; // полученное число в 10-ой с/с
cout<<err<<endl;
// строка, содержащая ошибочное значение, если
// перевод выполнен некорректно
// = NULL, если перевод выполнен корректно
cout<< " 2 " <<endl;
l = strtol(str, &err, 16);
cout<<l<<endl; // полученное число в 16-ой с/с
cout<<err<<endl;
while (true)
{
cout << "1 Enter a string \n";
cin.getline(str, MAX);
if (! strcmp(str,""))
break;
cout << endl<< " Enter a base \n" ;
cin >> base;
// число по основанию base
l = strtol(str, &err, base);
cout<<l<<endl;
cout<<err<<endl;
}
}
ПРИМЕР 22. Преобразование С-строки в число. Функция strtod
#include <string.h> // for strcmp
#include <stdlib.h> // for strtol
#include <iostream> // for cin cout
using namespace std;
void main()
{
const int MAX = 80;
char *str, *err;
double d;
cout<< " 1 " <<endl;
str = "1.1";
d = strtod(str, &err);
cout<<d<<endl; // полученное число
cout<<err<<endl;
// = NULL, если перевод выполнен корректно
cout<< " 2 " <<endl;
str = "1,1";
d = strtod(str, &err);
cout<<d<<endl; // полученное число
cout<<err<<endl;
// строка, содержащая ошибочное значение, если
// перевод выполнен некорректно
cout<< " 3 " <<endl;
str = "1e-3";
d = strtod(str, &err);
cout<<d<<endl; // полученное число
cout<<err<<endl;
// = NULL, если перевод выполнен корректно
cout<< " 4 " <<endl;
str = "e-3";
d = strtod(str, &err);
cout<<d<<endl; // полученное число
cout<<err<<endl;
// строка, содержащая ошибочное значение, если
// перевод выполнен некорректно
}
ПРИМЕР 23. Преобразование числа в С-строку. Функции itoa, _itoa_s, ltoa, _ltoa_s, utoa, _utoa_s
#include <string.h>
#include <stdlib.h>
#include <iostream> // for cin cout
using namespace std;
void main()
{ const int MAX = 80;
char str[MAX] = "";
int a;
// преобразование целого числа в строку
// функции
// char* itoa(int value,char *string,int radix);
// char* ltoa(long value, char *string, int radix );
// char* ultoa(unsigned long val,char *str,int radix );
// 2<=radix<=36 - основание с/с в которой получим число
cout << "Enter number \n";
cin>>a;
itoa(a, str, 2);
// _itoa_s(a, str, 2);
cout<<" number in 2 s/s ="<<str<<endl;
ltoa(a, str, 10);
// _ltoa_s(a, str, 10);
cout<<" number in 10 s/s ="<<str<<endl;
ultoa(a, str, 16);
// _ultoa_s(a, str, 16);
cout<<" number in 16 s/s ="<<str<<endl;
itoa(a, str, 22);
// _itoa_s(a, str, 22);
cout<<" number in 22 s/s ="<<str<<endl;
}
ПРИМЕР 24. Преобразование числа в С-строку. Функция fcvt, _fcvt_s
#include <string.h>
#include <stdlib.h>
#include <iostream> // for cin cout
using namespace std;
void main()
{
// преобразование вещественного числа в строку
//char* fcvt(double value,int count,int *dec,int *sign );
// count - число цифр дробной части
// dec - количество цифр целой части
// sign - знак числа (0 или 1)
const int MAX = 80;
int decimal, sign, err;
char *buffer;
double source;
cout << "Enter number \n";
cin>>source;
buffer = fcvt(source, 7, &decimal, &sign);
// результат в buffer
cout<<source<<" "<<buffer<<" "<<decimal<<" "<<sign<<endl;
err = _fcvt_s(buffer, MAX, source, 7, &decimal, &sign);
// результат в buffer
// вслучае успеха возвращает 0 в err
if (err != 0)
{
cout<<"error"<<err<<endl;
}
else
cout<<source<<" "<<buffer<<" "<<decimal<<" "<<sign<<endl;
}
ПРИМЕР 25. Выделение лексем. Функции strtok, strtok_s
#include <string.h>
#include <iostream> // for cin cout
using namespace std;
void main()
{
char str[80];
//строка из разделителей
const char razd[] = " ,?!;-.";
char *Ptr, *Ntr;
cout << " Enter a string: ";
cin.getline (str, 80);
// первый вызов функции первый параметр – строка,
// второй – строка из разделителей лексем
Ptr = strtok (str, razd);
// Ptr = strtok_s(str, razd, &Ntr);
int i = 0;
while (Ptr != NULL)
{
cout << Ptr << endl; // очередная лексема
i++; // количество лексем
// вызов функции для выделения следующей лексемы
// первый параметр NULL !!!
Ptr = strtok(NULL, razd);
// Ptr = strtok_s(NULL, razd, &Ntr);
}
cout<<" vvedeno "<<i<<" lecsem"<<endl;
cout<<str<<endl;
// изменилась ли исходная строка ???
}
ПРИМЕР 26. Указатели и С-строки
#include <string.h>
#include <iostream> // for cin cout
using namespace std;
void main()
{
char str1[] = "stroka - array";
char *str2 = "stroka - pointer";
char *p;
int i;
cout << str1 << endl;
cout << str2 << endl;
// вычисление значения функции strlen
// на каждой итерации цикла
for (i = 0; i < strlen (str1); i++)
cout << str1[i]; // вывод посимвольно
cout<<endl;
// вычисление значения функции strlen
// на каждой итерации цикла
for (i = 0; i < strlen (str2); i++)
cout << str2[i]; // вывод посимвольно
cout<<endl;
// вывод посимвольно через указатель !!!
// эффективнее предыдущего
for (p = str1; *p; p++)
cout << *p;
cout<<endl;
// вывод посимвольно через указатель !!!
// эффективнее предыдущего
for (p = str2; *p; p++)
cout << *p;
cout<<endl;
// str1++; // !!! нельзя константный указатель
str2++; // !!! можно
cout << str2 << endl; // строка без первого символа
str2 = "new stroka - pointer"; // !!! можно
cout << str2 << endl;
// !!! нельзя константный указатель
// str1 = "new stroka - array";
}
ПРИМЕР 27. Массивы С-строк
#include <iostream> // for cin cout
using namespace std;
void main()
{
char* pointer[ ] =
{"11111", "22222222", "33333333333","44444444444"};
char array [ ][12] =
{"11111", "22222222", "33333333333", "44444444444"};
int i;
for ( i = 0; i < 4; i++)
cout<<pointer[i]<<endl;
cout<<endl;
for ( i = 0; i < 4; i++)
cout<<array[i]<<endl;
cout<<endl;
for ( i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
cout<<pointer[i][j];
cout<<endl;
}
cout<<endl;
for ( i = 0; i < 4; i++)
{
for ( int j = 0; j < 4; j++)
cout<<array[i][j];
cout<<endl;
}
}
ПРИМЕР 28. *** Массивы С-строк
Запустите программу и объясните результаты.
#include <iostream> // for cin cout
using namespace std;
void main()
{
char *c[ ] =
{"11111", "22222222", "333333333333", "444444444444"};
char **cp[] = {c+3,c+2,c+1,c};
char ***cpp = cp;
int i;
cout <<" 1 "<<endl;
cout <<" &cpp= " << &cpp<<endl;
cout <<" cpp= " << cpp<<endl;
cout <<" *cpp= " << *cpp<<endl;
cout <<" **cpp= " << **cpp<<endl;
cout <<"***cpp= " << ***cpp<<endl;
cout<<endl<<" 2 "<<endl;
for ( i = 0; i < 4; i++)
{
cout<<" i= "<<i<<endl;
cout<<" *cpp[i]= " << *cpp[i] <<endl;
cout<<" **cpp[i]= " << **cpp[i] <<endl;
cout<<" *cp[i]= " << *cp[i] <<endl;
cout<<" **cp[i]= " << **cp[i] <<endl;
cout<<" c[i]= " << c[i] <<endl;
cout<<" *c[i]= " << *c[i] <<endl<<endl;
}
cout<<endl<<" 3 "<<endl;
for ( i = 0; i < 4; i++)
{
cout <<" i= "<<i<<endl;
cout<<" **(cpp+i)= " << **(cpp+i) <<endl;
cout<<" ***(cpp+i)= " << ***(cpp+i) <<endl;
cout<<" **(cp+i)= " << **(cp+i) <<endl;
cout<<" ***(cp+i)= " << ***(cp+i) <<endl;
cout<<" *(c+i)= " << *(c+i) <<endl;
cout<<" **(c+i)= " << **(c+i) <<endl;
}
}
ПРИМЕР 29. Объявление и инициализация строки string
#include <iostream>
#include <string> // строковый класс
using namespace std;
void main()
{
string s1; //создаем пустую строку
string s2("aaaa"); // создаем строку из C-строки
// создаем строку из C-строки 10 символов
string s3("abcdefghijklmnopqrstuvwxyz",10);
// создаем строку из 5 одинаковых символов
string s4(5,’!’);
// создаем строку-копию из строки s3
string s5(s3);
// создаем строку-копию из строки s3
// начиная с индекса 5 не более 3 символов
string s6(s3,5,3);
cout<<"s1= "<<s1<<endl;
cout<<"s2= "<<s2<<endl;
cout<<"s3= "<<s3<<endl;
cout<<"s4= "<<s4<<endl;
cout<<"s5= "<<s5<<endl;
cout<<"s6= "<<s6<<endl;
}
ПРИМЕР 30. Инициализация строки string. Оператор =. Метод assign
#include <iostream>
#include <string> // строковый класс
using namespace std;
void main()
{
string s1, s2, s3;
// в классе string определены три оператора присваивания:
// string & operator = (const string& str);
// string & operator = (const char* s);
// string & operator = (char c);
s1 = '1';
s2 = "bbbbbb";
s3 = s2;
cout<<"s1= "<<s1<<endl;
cout<<"s2= "<<s2<<endl;
cout<<"s3= "<<s3<<endl;
// метод assign
s2.assign("ccccccc"); // s2=”cccccccc”
s3.assign(s2); // s3=s2
cout<<"s1 = "<<s1<<endl;
cout<<"s2 = "<<s2<<endl;
cout<<"s3 = "<<s3<<endl;
s2.assign("1234"); // s2=”1234”
// в s3 из s2 3 символа, начиная с 1 позиции
s3.assign(s2,1,3);
cout<<"s2= "<<s2<<endl;
cout<<"s3= "<<s3<<endl;
char s[]="56789";
// присваивает s3 3 символа С-строки
s3.assign(s,3);
cout<<"s= "<<s<<endl;
cout<<"s3= "<<s3<<endl;
}
ПРИМЕР 31. Ввод строки string. Оператор >>
#include <iostream>
#include <string>
using namespace std;
void main()
{
string s1;
cout << " Enter a string: ";
//ввод выполняется до первого пробельного символа
cin >> s1;
cout << "You entered: " << s1 << endl;
}
ПРИМЕР 32. Ввод строки string. Метод getline
#include <iostream>
#include <string>
using namespace std;
void main()
{
string s1;
cout << "Enter a string: ";
getline(cin,s1); //ввод строки
cout << "You entered: " << s1 << endl;
cin.get(); // удаление из потока символа ‘\n’.
cout << " Enter a string: ";
// свой разделитель для ввода строки
getline(cin,s1,'&');
cout << "You entered: " << s1 << endl;
cin.get(); // удаление из потока символа ‘&’.
}
ПРИМЕР 33. Длина строки string. Методы length, size
#include <iostream>
#include <string>
using namespace std;
void main()
{
string st("*******************");
cout << " " << st.length()<< " " << st.size() <<
" "<<st.max_size()<<endl;
st = "Good Morning";
cout << " " << st.length()<< " " << st.size() <<
" "<<st.max_size()<<endl;
st = "Hello";
cout << " " << st.length()<< " " << st.size() <<
" "<<st.max_size()<<endl;
}
ПРИМЕР 34. Доступ к элементу строки string. Оператор []. Метод at
#include <iostream>
#include <string>
using namespace std;
void main()
{
string st("*******************");
int i;
for (i = 0; i < st.length(); i++)
cout << st[i];
// если i выходит за пределы строки,
// то поведение не определено
st = "Good Morning";
for (i = 0; i < st.length(); i++)
cout << st.at(i);
// если i выходит за пределы строки,
// метод возвращает исключение типа out_of_rang
st = "Hello";
for (i = 0; i < st.length(); i++)
cout << st[i];
}
ПРИМЕР 35. Сравнение строк. Операторы сравнения
Вводим строки в цикле, выход – ввод “пустой” сроки.
Вывод на экран результатов сравнения двух строк.
#include <iostream>
#include <string>
using namespace std;
void main()
{
string st1, st2;
cout << "Enter a string \n";
getline(cin,st1); // ввод 1 строки
while (true)
{
cout << "Enter a string \n";
getline(cin,st2); // ввод 2 строки
cin.get();
if ( st2 == "")
break; // выход из цикла
cout << endl<< st2 ;
// операторы лексикографического сравнения строк
if (st2 == st1)
cout << " = ";
else
if (st2 < st1)
cout <<" < ";
else
cout << " > ";
cout << st1<<endl ;
st1 = st2;
}
}
ПРИМЕР 36. Сравнение строк. Метод compare
Вводим строки в цикле, выход – ввод “пустой” сроки.
Вывод на экран результатов сравнения двух строк.
#include <iostream>
#include <string>
using namespace std;
void main()
{
string st1, st2;
cout << "Enter a string \n";
getline(cin,st1); // ввод 1 строки
while (true)
{
cout << "Enter a string \n";
cin.get();
getline(cin,st2); // ввод 2 строки
if ( !st2.compare("")) break; // выход из цикла
cout << endl<< st2 ;
// лексикографическое сравнение строк
if (!st2.compare(st1)) cout <<" = ";
else
if (st2.compare(st1)<0) cout <<" < ";
else cout << " > ";
cout << st1<<endl ;
cout << endl <<st2[1]<<st2[2];
// лексикографическое сравнение подстрок
if (!st2.compare(1,2,st1,2,3))
cout <<" = ";
else
if (st2.compare(1,2,st1,2,3)<0)
cout <<" < ";
else
cout << " > ";
cout << st1[2]<<st1[3]<<st1[4]<<endl ;
st1 = st2;
}
}
ПРИМЕР 37. Объединение строк. Оператор +. Метод append
#include <iostream>
#include <string>
using namespace std;
void main()
{
string s1("11");;
string s2("2222");
string s3 ("333333");
string s4("44444444");
s1 += s2; // добавить s2 к s1
cout<<"s1 = s1 + s2 = "<<s1<<endl;
s4 = s1 + s2; // добавить s1 к s2
cout<<"s4 = s1 + s2 = "<<s4<<endl;
s4 = s4 + '!'; // добавить s1 к s2
cout<<"s4 = s4 + ! = "<<s4<<endl;
s2.append(s1); // добавить s1 к s2
cout<<"s2 + s1 = "<< s2<<endl;
// добавить к s3 2 символа строки s1 со 1 позиции
s3.append(s4,1,2);
cout<<"s3 + s4 = "<< s3<<endl;
char s[] = "56789";
// добавить к s3 2 символа С-строки s
s3.append(s,2);
cout<<"s3 + s = "<< s3<<endl;
}
ПРИМЕР 38. Вставка строки (подстроки) в строку. Метод insert
#include <iostream>
#include <string>
using namespace std;
void main()
{
string s1("1111111");;
string s2("23456789");
s1.insert(3,s2); // вставить s2 в s1 с 3 позиции
cout<<"s1="<< s1<<endl;
s1 = "1111111";
s2 = "23456789";
// вставить 4 символа s2 со 2 позиции в s1 с 3 позиции
s1.insert(3,s2,2,4);
cout<<"s1="<< s1<<endl;
s1 = "1111111";
char s[] = "23456789";
// вставить 4 символа s в s1 с 3 позиции
s1.insert(3,s,4);
cout<<"s1 = "<< s1<<endl;
}
ПРИМЕР 39. Замена строки (подстроки) в строке. Метод replace
#include <iostream>
#include <string>
using namespace std;
void main()
{
string s1("1111111");;
string s2("23456789");
// замена 2 символов в s1 с 3 позиции элементами s2
s1.replace(3,2,s2);
cout<<"s1="<< s1<<endl;
s1 = "1111111";
s2 = "23456789";
// замена 2 символов в s1 с 3 позиции 1 символом
// из 4 позиции строки s2
s1.replace(3,2,s2,4,1);
cout<<"s1="<< s1<<endl;
s1 = "1111111";
char s[] = "23456789";
// замена 2 символов в s1 с 3 позиции 4 символами s
s1.replace(3,2,s,4);
cout<<"s1="<< s1<<endl;
}
ПРИМЕР 40. Удаление подстроки в строке. Метод erase
#include <iostream>
#include <string>
using namespace std;
void main()
{
string s1("123456789");
// удаление 2 символов в s1 с 3 позиции
s1.erase(3,2);
cout<<"s1="<< s1<<endl;
// удаление всех символов в s1 с 3 позиции
s1 = "123456789";
s1.erase(3);
cout<<"s1="<< s1<<endl;
s1 = "123456789";
s1.erase(); // удаление всех символов s1
cout<<"s1="<< s1<<endl;
}
ПРИМЕР 41. Выделение подстроки в строке. Метод substr
#include <iostream>
#include <string>
using namespace std;
void main()
{
string s1("123456789");
string s2;
// s2 – подстрока s1 из 2 символов с 3 позиции
s2 = s1.substr(3,2);
cout<<"s2="<< s2<<endl;
s1 = "123456789";
// s2 – подстрока s1 всех символов с 3 позиции
s2 = s1.substr(3);
cout<<"s2="<< s2<<endl;
s1 = "123456789";
s2 = s1.substr(); // s2=s1
cout<<"s2="<< s2<<endl;
}
ПРИМЕР 42. Обмен содержимого строк. Метод swap
#include <iostream>
#include <string>
using namespace std;
void main()
{
string s1("123456789");
string s2("abcdef");
s1.swap(s2);
cout<<"s1="<< s1<<endl;
cout<<"s2="<< s2<<endl;
}
ПРИМЕР 43. Поиск подстроки в строке. Метод find
#include <iostream>
#include <string>
using namespace std;
void main()
{
string s1("123123123");
string s2("12");
unsigned k;
// поиск подстроки s2 в строке s1 с 4 позиции
k = s1.find(s2,4);
cout<<" "<< k<<endl;
// поиск подстроки s2 в строке s1 с 7позиции
k = s1.find(s2,7);
cout<<" "<< k<<endl;
// поиск символа '1' в строке s1 с 4 позиции
k = s1.find('1',4);
cout<<" "<< k<<endl;
// поиск символа '1' в строке s1 с 4 позиции
k = s1.rfind('1',4);
cout<<" "<< k<<endl;
}
ПРИМЕР 44. Строки С и С++. Методы copy, c_str
#include <iostream>
#include <string>
using namespace std;
void main()
{
string str("1234567890");
char s[80];
int k;
// копируем 3 символа str c 5 позиции в s
k = str.copy(s,3,5);
cout<<s<<" "<<k<<endl;
// копируем 3 символа str c 5 позиции в s
k = str.copy(s,3,5);
s[3]='\0';
cout<<s<<" "<<k<<endl;
cout<<str.c_str()<<endl;
}
Правила перевода чисел из одной системы счисления в другую
1. 2 10
Для перевода двоичного числа в десятичное необходимо его записать в виде многочлена, состоящего из произведений цифр числа и соответствующей степени числа 2, и вычислить по правилам десятичной арифметики:
Степени числа 2
|
n (степень) |
0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
|
2 n |
1 |
2 |
4 |
8 |
16 |
32 |
64 |
128 |
256 |
512 |
1024 |
Пример. Число 11101000.012 перевести в десятичную систему счисления.
2. 16 10
Для перевода шестнадцатеричного числа в десятичное необходимо его записать в виде многочлена, состоящего из произведений цифр числа и соответствующей степени числа 16, и вычислить по правилам десятичной арифметики:
Степени числа 16
|
n (степень) |
0 |
1 |
2 |
3 |
4 |
5 |
6 |
|
16 n |
1 |
16 |
256 |
4096 |
65536 |
1048576 |
16777216 |
Пример . Число FDA116 перевести в десятичную систему счисления.
3. 10 2
Вещественное число, в общем случае содержит целую и дробную часть, всегда можно представить в виде суммы целого числа и правильной дроби.
Для перевода целого десятичного числа в двоичную систему его необходимо последовательно делить на 2 до тех пор, пока не останется остаток, меньший или равный 1. Число в двоичной системе записывается как последовательность последнего результата деления и остатков от деления в обратном порядке.
Пример. Число 2210 перевести в двоичную систему счисления.
2210=101102
Алгоритм перевода правильных дробей из 10 в другую систему р.
Пример. Число 0.310 перевести в двоичную систему счисления.
0.310 = 0.010011...2
0.3*2=0.6 0
0.6*2=1.2 1
0.2*2=0.4 0
0.4*2=0.8 0
0.8*2=1.6 1
0.6*2=1.2 1
...
4. 10 16
Для перевода целого десятичного числа в шестнадцатеричную систему его необходимо последовательно делить на 16 до тех пор, пока не останется остаток, меньший или равный 15. Число в шестнадцатеричной системе записывается как последовательность цифр последнего результата деления и остатков от деления в обратном порядке.
Пример. Число 746710 перевести в шестнадцатеричную систему счисления.
746710=1D2B16
Алгоритм перевода правильных дробей из 10 в другую систему р .
Пример. Число 0.12510 перевести в шестнадцатеричную систему счисления.
0.12510 = 0.216
0.125*16=2 2
5. 2 16
Чтобы перевести целое число из двоичной системы в шестнадцатеричную, его нужно разбить на тетрады (четверки цифр), начиная с младшего разряда, в случае необходимости дополнив старшую тетраду нулями, и каждую тетраду заменить соответствующей шестнадцатиричной цифрой.
Чтобы перевести дробную часть числа из двоичной системы в шестнадцатеричную, его нужно разбить на тетрады (четверки цифр), начиная со старшего разряда, в случае необходимости дополнив младшую тетраду нулями, и каждую тетраду заменить соответствующей шестнадцатиричной цифрой.
Пример. Число перевести в шестнадцатеричную систему счисления.
6. 16 2
Для перевода шестнадцатеричного числа в двоичное необходимо каждую цифру заменить эквивалентной ей двоичной тетрадой.
Пример. Число перевести в двоичную систему счисления.
Значения двоичных кодов для шестнадцатеричных цифр
|
цифра |
код |
цифра |
Код |
|
0 |
0000 |
8 |
1000 |
|
1 |
0001 |
9 |
1001 |
|
2 |
0010 |
A |
1010 |
|
3 |
0011 |
B |
1011 |
|
4 |
0100 |
C |
1100 |
|
5 |
0101 |
D |
1101 |
|
6 |
0110 |
E |
1110 |
|
7 |
0111 |
F |
1111 |
Словарь понятий, используемых в заданиях
Текст – непустая последовательность символов.
Слово – непустая последовательность любых символов, кроме символов-разделителей.
Предложение – последовательность слов, разделенных одним или несколькими символами-разделителями.
Символы-разделители: «пробел», «.», «,», «:», «;», «!», «?», «-», «’», «(», «)».
Подслово – непустая подпоследовательность слова.
Обращение слова – слово, получающееся из исходного за писью его букв в обратном порядке. Слово называется симметричным, если оно совпадает со своим обращением.
Вхождением слова (последовательности) v в слово (после довательность) w называется любая часть слова (последователь ности) w, которая является подсловом (подпоследовательностью) v слова (последовательности) w.
Слова-серии – слова, составленные из повторяющихся подслов. Например, 123123123 – слово-серия.
9
8
7
6
5
4
3
2
1
0
s
\0
0
l
l
e
H