практикуму СТРОКИ по курсу ПРОГРАММИРОВАНИЕ 2010 МИНСК
Работа добавлена на сайт samzan.net:
БЕЛОРУССКИЙ ГОСУДАРСТВЕННЫЙ УНИВЕРСИТЕТ
факультет радиофизики и электроники
кафедра информатики
Н.В. Серикова
ПРАКТИЧЕСКОЕ РУКОВОДСТВО
к лабораторному практикуму
«СТРОКИ»
по курсу
«ПРОГРАММИРОВАНИЕ»
2010
МИНСК
Практическое руководство к лабораторному практикуму «СТРОКИ» по курсу «ПРОГРАММИРОВАНИЕ» предназначено для студентов, изучающих базовый курс программирования на языке С++, специальностей «Радиофизика», «Физическая электроника», «Компьютерная безопасность».
Руководство содержит некоторый справочный материал, примеры решения типовых задач с комментариями.
Все примеры протестированы в среде Microsoft Visual Studio 2005.
Автор будет признателен всем, кто поделится своими сообра же ниями по совершенствованию данного пособия.
Воз можные предложения и замечания можно присылать по адресу:
E-mail: Serikova@bsu.by,
ОГЛАВЛЕНИЕ
Строки
Строка – последовательность символов кодовой таблицы ПЭВМ, обрабатываемая как единая структура. Строка может включать буквы, цифры и разнообразные специальные символы.
Такая последовательность должна быть ограничена, то есть нужно знать, где она заканчивается. Есть два варианта связать со строкой ее размер: хранить его, либо ограничить строку специальным символом (элементом последовательности), дойдя до которого мы будем знать, что достигли конца.
Языки программирования имеют различные типы данных для представления строк и библиотеки функций для работы со строками.
Строки используются во многих приложениях для содержания текстовых данных, для организации интерфейса программы пользователя.
Элементом строки является символ.
Количество символов в строке определяет длину и размер строки.
Размер строки - общая длина строки, которая характеризует размер памяти, выделяемый строке при описании.
Длина строки - текущая длина строки (всегда меньше или равна размеру строки), которая показывает количество символов строки в каждый конкретный момент времени.
В каждом языке программирования существует функция для определения текущей длины строки. Размер строки всегда больше, чем длина строки. Это связано с тем, что в памяти, отводимой для строковой переменой, дополнительно хранится либо размер строки, либо нуль-символ.
Нуль-символ (\0) отмечает конец нуль-терминированной строки. Хотя нуль-символ записывается в виде двух символов, компилятор его интерпретирует как один символ, который может храниться в переменной символьного типа.
Строка, в которой нет символов, называется пустой. Длина пустой строки равна 0. Размер пустой строки равен 1. В языках программирования существует разница между символом и строкой длинны 1 символ.
При объявлении строковых переменных, как правило, необходимо указывать максимальную длину строки. В том случае, если длина строки не задана, для строковой переменной резервируется максимально возможный размер памяти, который отводится в данном языке программирования для строковых переменных.
Инициализация строковой переменной может происходить при объявлении или непосредственно в программе. Размер инициализирующей строки не должен превышать максимальной длины строковой переменной.
Операции сравнения выполняются над строками в лексикографическом порядке.
Лексикографический порядок – порядок сравнения строк, принятый во многих языках программирования.
При лексикографическом сравнении последовательно, начиная с первого символа, сравниваются коды символов строки. Те символы считаются больше, чьи коды больше, и наоборот. Сравнение происходит до первого несовпадения символов. Та строка считается большей, у которой код первого несовпадающего символа больше, и наоборот. Если начала строк совпадают, то более короткая строка считается меньше более длинной.
Кодировка (кодовая таблица) - это однозначное соответствие между целым число (кодом) и символом. Кодировки обычно составляют так, что символы следуют в алфавитном порядке и символ 'а' имеет наименьший код, а символ 'z' наибольший. Таким образом, выполняя лексикографическое сравнение строк можно разместить их в алфавитном порядке.
Строки символов в С++
Способы представления строк символов в C++
- в виде одномерного массива символов (строки, завершающиеся нулевым байтом) - С-строки;
- в виде объекта класса string;
- другие способы в зависимости от реализации.
С-Строки (завершающиеся нулевым байтом)
- Описываются как одномерный массив, каждый элемент которого имеет тип char.
- Символы строки последовательно располагаются в элементах массива, начиная с нулевого.
- В элемент массива, следующий за последним символом автоматически записывается элемент с ASCII кодом 0: ‘\0’
Описание строк, завершающихся нулевым байтом
- Строка описывается как обычный массив символов char
char s [] = “Hello”;
char s [6] = “ Hello”;
char s [6] = {‘H’, ‘e’, ‘l’, ‘l’, ‘o’, ‘\0’};
- Размер массива должен быть на 1 больше длины самой длинной строки, которую предполагается в этом массиве хранить
char s[10] = “Hello”;
Основные отличия строк, завершающих нулевым байтом, от массивов
- В процессе выполнения программы отслеживается текущая длина строки.
- Строка в целом может быть проинициализирована значением строкового литерала (а не только поэлементно символьными значениями).
- При помещении идентификатора символьного массива в поток cout выводится не адрес массива, а его содержимое от 0-го элемента до последнего перед завершающим символом \0.
Основные ограничения на действия со строками,
завершающимися нулевым байтом (С-строками)
- Строки, как и обычные массивы, нельзя присваивать друг другу, используя оператор присваивания (включая присвоение строке строкового литерала где-либо, кроме начальной инициализации).
- К строкам, как к обычным массивам, нельзя применять операции сравнения.
- Для строк нет перегруженных операций (например, + для операции конкатенации).
- Для выполнения операций копирования, конкатенации, сравнения строк и ряда других операций приходится использовать встроенные функции, описанные в заголовке <string.h>
.
Функции преобразования (С-строки)
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 в другую систему р.
- умножить исходную дробь в 10-ной системе счисления на основание р, выделить целую часть - она будет первой цифрой новой дроби;
- отбросить целую часть;
- для оставшейся дробной части операцию умножения с выделением целой и дробной части повторить, пока в дробной части не окажется 0 или не будет достигнута желаемая точность конечного числа;
- записать дробь в виде последовательности цифр после ноля с разделителем в порядке их появления.
Пример. Число 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 в другую систему р .
- умножить исходную дробь в 10-ной системе счисления на основание р, выделить целую часть - она будет первой цифрой новой дроби;
- отбросить целую часть;
- для оставшейся дробной части операцию умножения с выделением целой и дробной части повторить, пока в дробной части не окажется 0 или не будет достигнута желаемая точность конечного числа;
- записать дробь в виде последовательности цифр после ноля с разделителем в порядке их появления.
Пример. Число 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
2. реферату- Особливості вивчення іноземної мови в умовах двоязиччяРозділ- Журналістика Особливості вивчення
3. работник как субъект трудового права Правовой статус работника является составной частью правового стату
4. демографической группы
5. РЕФЕРАТдиссертации на соискание ученой степеникандидата политических наук Диссертационная ра
6. Потоки российских денег в иностранные банки
7. Развитие сельского хозяйства современного Алжира
8. Лабораторная работа 2 МЕТОДЫ РЕШЕНИЯ НЕЛИНЕЙНЫХ УРАВНЕНИЙ
9. Варианты ответа- 1 2 3 4 R2
10. Сегментирование потребителей услуг
11. Реферат- Деловое мышление
12. Оренбургский государственный университет Кафедра технической эксплуатации и ремонта автомобилей В
13. Регламентом проведения соревнований по группе дисциплин Дистанция ~ пешеходная далее Регламент
14. философия жизни ее представители также Фр
15. Иск и право на иск в гражданском процессе
16. бытовые производственные промышленные- загрязнённые и условно чистые и атмосферные дождевые и талые
17. Воскресенье
18. і Тэарэтычныя звесткі
19. 1Абиотические факторы ~ это комплекс условий неорганической среды влияющих на организмы
20. Курсовая работа- Разработка программных продуктов