Папиллярные узоры пальцев рук - маркер спортивных способностей: дерматоглифические признаки формируются на 3-5 месяце беременности, не изменяются в течение жизни...
Архитектура электронного правительства: Единая архитектура – это методологический подход при создании системы управления государства, который строится...
Топ:
Теоретическая значимость работы: Описание теоретической значимости (ценности) результатов исследования должно присутствовать во введении...
Особенности труда и отдыха в условиях низких температур: К работам при низких температурах на открытом воздухе и в не отапливаемых помещениях допускаются лица не моложе 18 лет, прошедшие...
Организация стока поверхностных вод: Наибольшее количество влаги на земном шаре испаряется с поверхности морей и океанов...
Интересное:
Берегоукрепление оползневых склонов: На прибрежных склонах основной причиной развития оползневых процессов является подмыв водами рек естественных склонов...
Наиболее распространенные виды рака: Раковая опухоль — это самостоятельное новообразование, которое может возникнуть и от повышенного давления...
Финансовый рынок и его значение в управлении денежными потоками на современном этапе: любому предприятию для расширения производства и увеличения прибыли нужны...
Дисциплины:
 2020-08-21 |
 151 |
из
5.00
|
Заказать работу |
|
|
|
|
Лекция 13
Строки
Основные понятия. 2
Определение С-строк. 3
строка как массив символов. 3
строка как указатель на char 3
строка как элемент массива строк. 3
строка как элемент массива указателей на char 3
особенности работы с С-строками в С++. 3
Операции со строками. 4
Инициализация строки. 4
Возможные ошибки при работе со строками. 5
Ввод-вывод строк. 6
преобразование значения базового типа в С-строку. 10
ввод ограниченного числа символов строки. 10
функция вывода строки. 10
особенности посимвольного вывода строки. 11
Копирование строк. 11
Оптимизация текста программы на примере функции копирования. 12
Функции для работы с С-строками. 13
Определение длины строки. 13
Копирование строк. 13
Объединение строк. 15
Сравнение строк. 16
Поиск символа в строке. 17
Проверка принадлежности символа некоторому множеству. 17
Поиск строки в строке. 18
Преобразование и заполнение строк. 19
преобразование строки в число. 19
преобразование числа в строку. 20
преобразование строчных символов строки в прописные и наоборот. 21
реверс строки. 22
заполнение строки символом.. 23
пример применения функций преобразования. 23
Выделение лексем.. 23
Динамические строки. 24
Копирование строки в динамическую строку. 24
Передача строки в функцию в качестве параметра. 25
Пример_1: в main()– строка-массив; в функции – строка-указатель. 25
Пример_2: в main() – строка-указатель; в функции – строка-указатель. 27
Передача в функцию массива строк. 27
Примеры работы со строками. 27
Определение длины строки с помощью функции пользователя. 27
Реверс строки ( перегрузка функций ) 28
Удаление начальных пробелов из строки. 28
Проверка, является ли строка целым числом.. 29
|
|
Проверка, является ли строка 16-ичным целым числом.. 29
Проверка, является ли строка дробным числом без знака. 29
Перевод двоичного числа в десятичное. 30
Перевод шестнадцатеричного числа в десятичное. 30
Перевод десятичного числа в двоичное. 30
Перевод десятичного числа в с/с от 2-х до 10. 31
Перевод десятичного числа в шестнадцатеричное. 31
Определение количества слов в фразе. 32
Выделение слов в тексте по нажатию произвольной клавиши. 32
Сортировка вводимых с клавиатуры строк *. 33
Сортировка строк в зависимости от признака, передаваемого функции main() через аргумент argv *. 34
Инвертирование строки с помощью рекурсивной функции. 34
Основные понятия
В С отсутствует специальный строковый тип и поэтому используются массивы элементов типа char, всегда содержащие в конце последовательности значащих символов код ’\0’, (концевой символ строки, иначе – ее терминальный символ). Этот тип называют также char*-строками, так как он может быть представлен в виде указателя на char.
В С++ сохранены те же возможности и разрешено использовать все библиотечные функции языка С для работы со строками (будем называть их С-строки). Для подключения этих библиотечных средств к программам используются заголовки <cstring> и <string.h>.
Применение С-строк в ряде случаев неудобно: во-первых, С-строка всегда ограничена тем массивом с элементами типа char, который выделен для ее представления; во-вторых, в функциях для работы с С-строками нет контроля за их границами. Поэтому в стандартную библиотеку языка С++ введено несколько классов, позволяющих определять строковые переменные в виде объектов и выполнять над ними ряд операций (например, строку как объект класса string будем рассматривать во 2-ом семестре).
Тем не менее, свое знакомство со строками мы начнем с С-строк.
Как и другие типы данных, строки могут быть: переменными и константами.
Напомним, некоторые особенности использования строковых констант.
· В строковый литерал можно включать непечатаемые символы:
|
|
”abc \ n def” //символы будут напечатаны в две строки
”abc \\ n def” //будет выдано abc\ndef
· Длинный строковый литерал предполагает запись:
”abc \
def” // напечатает abcdef; т.к. \ – символ продолжения строки
НО ”abc<enter>
def” // error!!!
· Строка ”abc\000def” будет обрабатываться как abc (‘\0’ – означает конец строки).
· В строковом литерале возможно использование нескольких строк:
"текст1""текст2""текст3";
Оператор
cout << "abc\\ndef" "aaa" "mmm"<< endl;
выведет строку abc\ndefaaammm.
Строку-константу можно задать с помощью директивы препроцессора и с помощью модификатора const:
#define OTVET1 "odin" //препроцессорная строка-константа
const char str[3] ="dwa"; // типизированная строка-константа
Определение С-строк
Строка как массив символов
const int n=10;
char st [n]; //строка-массив
char empty_str [ ]= ""; //нулевая (пустая) строка;
Равносильныопределения строк:
char st1 [] = "Minsk"; //' \0 ' добавляется в конец строки автоматически
char st2 [6] = "Minsk";
char st3 [6] = {'M', 'i', 'n', 's', 'k', ' \0 '};
Операции со строками
Для работы с С-строками используются библиотечные функции языка С, описанные в заголовках <string.h> и <сstring>, однако надо учитывать, что в этих функциях нет контроля за границами строк.
Инициализация строки
Строка-массив может быть проинициализирована символьными значениями поэлементно. Чтобы символьный массив был представлен как строка, в его конец необходимо поместить завершающий символ ‘\0’– признак конца строки. В этом случае в процессе выполнения программы отслеживается текущая длина строки, а при выводе (помещении в поток cout идентификатора массива) – выводится его содержимое, а не адрес (как для обычного массива).
char stroka[6] = {'M', 'i', 'n', 's', 'k', '\0'};
char stroka1[ ] = {'M', 'i', 'n', 's', 'k', '\0'};
char stroka2[6] = "Minsk"; // ’ \0 ’ добавляется в конец строки автоматически
char stroka3 [ ] = "Minsk"; // ’ \0 ’ добавляется в конец строки автоматически
char *string1 = "Minsk"; // ’ \0 ’ добавляется в конец строки автоматически
|
|
//пример_3
int main()
{
const int MAX = 80; //максимальный размер строки
char str [MAX]; //определение строки как символьного массива
cin >> str; //ввод строки, количество символов < 80
// один символ оставляем для нуль-символа ’\0’
char s[ ] = "abc"; //определение и инициализация строки s строковым литералом
//символ ’ \0 ’ добавляется в конец строки автоматически
// размер строки равен 4: 3 символа +’ \0 ’, длина строки равна 3
char m[ ] = {'a', 'b', 'c'}; // определение и инициализация массива символов m
// размер массива равен 3, нет символа ’\0’
cout << m << endl; // результаты вывода –???, до случайно встреченного ’\0’
char ss[ ] = {'a', 'b', 'c', ' \0 '}; //определение и инициализация строки ss
// размер строки ss равен 4, длина строки равна 3
char str1[] = "Minsk"; // строка-массив, проинициализирована строковым литералом,
// размер str1 равен 6, длина str1 равна 5
//символ ’ \0 ’ добавляется в конец строки автоматически
_getch();
return 0;
}
Строка-указатель инициализируется строковым литералом, который в формате С-строки располагается в сегменте данных загрузочного модуля программы. Имя строки становится синонимом адреса первого символа литерала.
Важно осознать, что в данном случае при выполнении операции присваивания в ячейку памяти, отведенную для указателя, пересылается не строка, а только указатель на ее начало, т.е. адрес первого символа литерала.
Однако, если литерал используется в выражении в тех местах, где разрешается применять указатель, компилятор подставляет в выражение вместо литерала адрес первого символа. Например:
char *st = "Literal"; // '\0'добавляется в конец литерала автоматически
cout << st << endl; // Literal
cout << *st << endl; // L
НО!!!
cout << sizeof (st) << endl; // размер указателя: 4
cout << sizeof(*st) << endl; // размер одного символа: 1
cout << strlen (st) << endl; // длина строки: 7, без ‘\0’
//прототип функции strlen () в <string.h>
|
|
Если строка инициализируется литералом, идентичным ранее записанному, то используется ссылка на уже имеющийся литерал.
Ввод-вывод строк
Для ввода-вывода С-строк используются функции printf (),scanf (),gets() и puts(), унаследованные из библиотеки С. Функция gets(s) читает символы с клавиатуры, в том числе и пробелы (до символа новой строки), и помещает их в строку, завершая ее 0-символом; функция puts(s) выводит строку, заменяя 0-символ символом новой строки.
// С-ввод строки до первого пробельного символа
int main()
{
const int MAX = 80;
char str[MAX]; // строка-массив
printf ("Enter a string: ");
scanf ("%s", str); //odin_dwa адрес переменной здесь не указываем
printf ("%s", str); //odin_dwa
printf ( "%3s\n", str); //3 – минимальный размер поля вывода: odin_dwa
printf ( "%10.2s\n", str); // od выравнивание вправо и 2 символа
printf ( "%-10.2s\n", str); //od выравнивание влево и 2 символа
printf ( "string?\n" );
scanf ( "%s", str); //вводим: odin dwa, но вводится только odin (до пробела)
printf ( "%s\n", str); //в буфере ввода остался «хвост» dwa
// fflush (stdin); // для корректной дальнейшей работы scanf ()
// требуется очистка буфера ввода: fflush (stdin);
printf ( "string?\n" );
scanf ( "%s", str);
printf (" %s\n", str);
_getch();
return 0;
}
// С-ввод строки с пробелами
int main()
{
const int MAX = 10;
char str[MAX]; // строка-массив
printf ("Enter a string: ");
gets(str); //ввод строки: odin dwa
puts(str); //вывод строки: odin dwa
_getch();
return 0;
}
// посимвольный ввод строки в стиле С
int main()
{
const int MAX = 10;
char str[MAX]; // строка-массив
printf ("Enter a string: ");
for (int i=0; i<MAX; i++)
scanf ("% c ", & str[i]); //ввод символов 12345678 9 9
str[MAX-1]='\0';
printf ("%s", str); //вывод строки 12345678 9
int i=0;
printf ("\nEnter a string: ");
while ((str[i] = _getch())!=13) // или!= ‘\r’ посимвольный ввод
_putch (str[i++]); // посимвольный вывод
str[i] = '\0'; // завершение строки
_putch ('\n'); _putch ('o'); _putch ('k');
printf ("\n%s", str); //вывод строки
_getch();
return 0;
}
Для ввода-вывода С-строк в стиле С++ используются известные нам объекты cin и cout.
//ввод строки до первого пробельного символа
int main()
{
const int MAX = 80;
char str[MAX]; // строка-массив
cout << "Enter a string: ";
cin >> str; //ввод строки
cout << "You entered: " << str << endl; //вывод строки
_getch();
return 0;
}
// посимвольный ввод строки
int main()
{
const int MAX = 10;
char str[MAX]; // строка-массив
|
|
cout << "Enter a string: ";
for (int i=0; i< MAX-1; i++)
cin >> str[i]; //ввод символов 123456789 9
str[MAX-1]='\0';
cout << "You entered: " << str << endl; //вывод строки: 123456789
_getch();
return 0;
}
Для ввода любых символов, включая пробельные, используются методы get() и get(c) класса istream, объектом которого является cin:
char c, d, e;
c=cin.get(); //возвращается код извлеченного из потока символа или EOF
cin.get(d); //извлеченный из потока символ записывается в переменную-аргумент
cin.get(e);
// посимвольный ввод строки с использованием метода get()
int main()
{
const int MAX = 10;
char str[MAX]; // строка-массив
cout << "Enter a string: ";
for (int i=0; i< MAX-1; i++)
cin. get (str [ i ]); //ввод без пробелов символов 12345 9
str[MAX-1]='\0';
cout << "You entered: " << str << endl; //вывод строки 12345 9
_getch();
return 0;
}
Для ввода строки из нескольких слов используются методы getline () или get () объекта cin:
// ввод строки из нескольких слов с использованием метода getline()
int main()
{
const int MAX = 80;
char str[MAX];
cout << "\nEnter a string: ";
cin.getline (str, MAX); //ввод строки в str
//символ ‘\n’ считывается (удаляется) из потока ввода
//и вместо него в строковую переменную записывается ‘\0’
cout << "You entered: " << str << endl;
cin.get (str, MAX); // ввод строки в str
//символ ‘\n’ остается в потоке
//в строковую переменную добавляется ‘\0’
cout << "You entered: " << str << endl;
_getch();
return 0;
}
// ввод нескольких строк, завершающихся < enter >, в качестве одной строки
const int MAX = 2000;
char str[MAX];
int main()
{
cout << "\nEnter a string:\n";
cin.get (str, MAX, ' $ '); //ввод всех строк завершается символом $
cout << "You entered:\n" << str << endl;
_getch();
return 0;
}
В этом случае можно ввести несколько строк, завершающихся <enter>, и только затем набрать символ $ (все строки будут восприняты как одна строка):
Enter a string:
qwert
12345
qwert $
You entered:
qwert
12345
qwert
Обратите внимание на «плохую» работу метода get() при вызове его с двумя аргументами два раза подряд:
char s[10];
int n=5;
cin.get (s, n); //1 вводим 123<enter>,‘\n’остается в потоке ввода
cout << s << endl; //2 выводит 123
cin.get (s, n); //3 считывает пустую строку
cout << s << endl; //4 выводит пустую строку
cin.get (s, n); //5 считывает пустую строку
cout << s << endl; //6 выводит пустую строку
cout << "end" << endl; //7 выполняется!!!
Результат работы:
123
123
end
За выводом в операторе //2 сразу последует сообщение “end”, выведенное оператором //7. Это происходит из-за символа ‘\n’, оставленного в потоке ввода первым вызовом метода get(), т.е. оператором //1. Поэтому операторами //3 и //5 будут считаны (и, соответственно) выведены на экран пустые строки.
Удалить символ ‘\n’ из входного потока можно путем вызова метода get() без параметров cin. get():
char s[10];
int n=5;
cin. get (s, n); //1 вводим 123<enter>,‘\n’остается в потоке ввода
cout << s << endl; //2 выводит 123
cin.get (); //удаляем ‘\n’ из входного потока
cin. get (s, n); //3 вводим 234<enter>,‘\n’остается в потоке ввода
cout << s << endl; //4 выводит 234
cin.get (); //удаляем ‘\n’ из входного потока
cin.get (s, n); //5
cout << s << endl; //6
cout << "end" << endl; //7
Результат работы:
123
123
234
234
345
345
end
Еще лучше – использовать в таких случаях метод getline().
Следующий цикл обеспечивает ввод символов до нажатия ctrl + z – признака конца файла
char c;
while ((c=cin.get())!=EOF) { //ввод символов, выход из цикла – ctrl + z – признак конца файла
cout << c;
}
Для ввода нескольких С-строк можно использовать метод getline() в заголовке цикла:
int main()
{
const int n = 80;
char s[n];
while (cin.getline(s, n)) { //ввод строки в s, выход из цикла – ctrl+z – признак конца файла
cout << s << endl; //вывод строки
//………. обработка строки
}
_getch();
return 0;
}
преобразование значения базового типа в С-строку
Функция С sprintf() аналогична printf(), однако выводит данные в строку-буфер.
char buf[20];
int i=22222;
sprintf_s(buf, "% 7d ", i); //вывод переменной i типа int в строку-буфер buf,
cout << buf<< endl; //длина которой равна 7: ” 22222”
sprintf_s(buf, "% 5 d ", i); //вывод переменной i типа int в строку-буфер buf,
cout << buf<< endl; // длина которой равна 5: ”22222”
char c='a';
sprintf_s(buf, "% 7 c ", c); //вывод переменной c типа char в строку-буфер buf,
cout << buf<< endl; // длина которой равна 7: ” a”
sprintf_s(buf, "% c ", c); //вывод переменной c типа char в строку-буфер buf,
cout << buf<< endl; // длина которой равна 1: ”a”
double d=1.23;
sprintf_s(buf, "% 5 f ", d); //вывод переменной d типа double, длина которой
cout << buf<< endl; // равна 8: ”1.230000”, в строку-буфер buf
sprintf_s(buf, "% 9 f ", d); //вывод переменной d типа double (длина 8)в строку-буфер
cout << buf<< endl; // buf длины 9:” 1.230000”
sprintf_s(buf, "% 11f ", d); //вывод переменной d типа double в строку-буфер buf
cout << buf<< endl; // длины 11: ” 1.230000”
Или
scanf (“% k s”, name); где k – количество символов строки, которое необходимо ввести.
Функция вывода строки
void dispstr (char *); //прототип функции вывода строки
int main()
{
char str[] = "Idle people have the least leisure.";
// или char *str = "Idle people have the least leisure.";
dispstr(str); //вызов функции вывода строки
_getch();
return 0;
}
//--------------------------------------------------------------
void dispstr(char* ps) //функция вывода строки
{
while(*ps)
cout << *ps++;
cout << endl;
}
Или
//--------------------------------------------------------------
void dispstr(char ps[]) //функция вывода строки
{int i=0;
while(ps[i]!='\0')
cout << ps[i++];
cout << endl;
}
Копирование строк
Для С-строк (исключая инициализацию) не определена операция присваивания, поскольку строка не является базовым типом данных. Копирование строк выполняется с помощью функций стандартной библиотеки или посимвольно «вручную».
Копирование строк «вручную»:
#include <cstring> //for strlen()
int main()
{ char str1[] = "Oh, Captain, my Captain! "
"our fearful trip is done";
const int MAX = 80;
char str2[MAX];
unsigned j;
for(j=0; j<strlen(str1); j++)
str2[j] = str1[j];
str2[j] = '\0';
cout << str2 << endl;
_getch();
return 0;
}
или, как и для массивов,!!!
#include <сstring>
char s[9];
char hello[] = "motor";
memcpy (s, hello, sizeof (hello)); //копирование области памяти указанного размера
cout<< s<< endl; // motor
Обратите внимание, что в результате операции sizeof (hello) получим значение размера строки 6 =5+1(завершающий ‘ \ 0’). Если же определять длину строки с помощью функции strlen(hello), то получим значение, равное 5 ( без учета последнего ‘ \ 0’ ).
Копирование строк с помощью функции пользователя:
//прототипы функций
void vvodstr (char*, const int); //ввод строки
void vyvodstr (char*); //вывод строки
void copystr (char*, const char*); //копирование строки
Int main()
{ const int MAX=80;
char str1[MAX];
char str2[MAX];
vvodstr (str1, MAX);
vyvodstr (str1);
copystr(str2, str1);
cout << "new ";
vyvodstr (str2);
_getch();
return 0;
}
//--------------------------------------------------------------
void vvodstr(char* st, int n)
{ cout << "string? " << endl;
cin.getline(st, n);
}
//--------------------------------------------------------------
void vyvodstr(char* st)
{cout << "string: " << endl;
cout << st << endl;
}
//--------------------------------------------------------------
void copystr(char* dest, const char* src)
{
while(*src) //пока не нуль-символ
*dest++ = *src++; //копировать символ из src в dest
*dest = '\0'; //завершить строку dest нуль-символом
}
Оптимизация текста программы на примере функции копирования
Проследим возможности Си++ по «оптимизации» текста на примере функции копирования:
void scpy (char*, char*); //prototype
int main()
{
char* str1 = " Press any key!";
char str2[80];
scpy (str2, str1); //copy str1 to str2
cout << str2 << endl; //display str2
_getch();
return 0;
}
//--------------------------------------------------------------
void scpy (char s[], char t[])
{
int i=0;
while ((s[i] = t[i])!='\0')
i++;
}
Или
void scpy (char *s, char *t)
{
while ((*s =*t)!='\0')
{s++; t++;}
}
Или
void scpy (char *s, char *t)
{
while ((*s++ = *t++)!='\0');
}
Или
void scpy (char *s, char *t)
{ while (*s++ =*t++);
}
Определение длины строки
Функция size_t strlen (const char *str)
возвращает количество символов в строке str (длину строки), не включая 0-символ.
const int MAX = 80;
char s1[MAX] = "abcdef";
cout << strlen(s1) << endl; // 6
Копирование строк
Функция char* strcpy (char *strDest, const char *source)
копирует все символы строки source, включая завершающий 0-символ, в строку strDestи возвращает указатель на ее начало. В строке strDest должно быть не менее strlen(source) + 1 байтов.
const int MAX = 80;
char s1[MAX]="abcdef", s2[MAX]="cd";
strcpy (s1, s2); // cd warning C4996 'strcpy' was declared deprecated
Функция errno_t strcpy_s (char *strDest, size_t sizeInBytes_strDest, const char *strSource)
возвращает 0 при успешном завершении и код ошибки – в противном случае: EINVAL (22) – Invalid argument или ERANGE () – Result too large.
Функция strcpy_s копирует содержимое strSource, включая пустой символ завершения, в strDest. Строка должна быть достаточно большой для хранения исходной строки, включая завершающий нулевой символ. Поведение strcpy_s не определено, если исходная и целевая строки накладываются.
const int MAX = 80;
char s1[MAX]="abcdef", s2[MAX]="cd";
strcpy_s (s1, MAX, s2); // cd
cout << s1 << endl;
Шаблонная функция (только в С++)
template <size_t size>
errno_t strcpy_s (char (&strDest)[size], const char *strSource);
позволяет вызывать функцию в привычном виде:
strcpy_s (s1,s2); // cd
Функция char* strncpy (char * strDest, const char * strSource, size_t count)
копирует не более count символов строки strSource, включая 0-символ, в строку strDest и возвращает указатель на начало строки strDest. Если 0-символ встретился в исходной строке strSource раньше, то копирование прекращается, а оставшиеся до count символы строки strDest заполняются 0-символами. В противном случае (если count меньше или равно длине строки strSource) 0-символ в strDest не добавляется.
const int MAX = 80;
char s1[MAX]="abcdef", s2[MAX]="cd";
strncpy(s1, s2, 1); //cbcdef warning C4996: 'strncpy' was declared deprecated
strncpy(s1, s2, 4); //cd warning C4996
char ss1[MAX]="cd",ss2[MAX]="abcdef";
strncpy(ss1, ss2, 1); //ad warning C4996: 'strncpy' was declared deprecated
strncpy(ss1, ss2, 4); //abcd warning C4996
strncpy(ss1, ss2, 6); //abcdef warning C4996
Функция errno_t strncpy_s (char *strDest, size_t sizeInBytes_strDest, const char *strSource, size_t count);
возвращает 0 при успешном завершении и код ошибки – в противном случае;
Функция пытается скопировать первые D символов strSource в strDest, где D является меньшим значением из количества элементов count и длины строки strSource. Если эти D символов вписываются в strDest (как sizeInBytes) и еще остается место для нулевого символа, то символы копируются, и добавляется завершающий нулевой символ, иначе strDest[0] устанавливается на нулевой символ и возвращается значение EINVAL (22) – Invalid argument.
const int MAX = 80;
int count= 9;
char s1[MAX]="abcdef", s2[MAX]="cdefghjklmn";
strncpy_s (s1, MAX, s2, count);
cout << s1 << endl; //cdefghjkl
Шаблонная функция (только в С++)
template <size_t size>
errno_t strncpy_s (char (&strDest)[size], const char *strSource, size_t count);
позволяет вызывать функцию в привычном виде:
const int MAX = 80;
int count=2;
char s1[MAX]="abcdef", s2[MAX]="cdefghj\0klmn";
strncpy_s (s1,s2,count);
cout << s1 << " " << count << endl; //cd
Объединение строк
Функция char* strcat (char* strDest, const char* source)
добавляет копию строки source, включая 0-символ, в конец строки strDest. Начальный символ строки source записывается поверх 0-символа в конце строки strDest. Функция возвращает указатель на начало результирующей строки strDest, которая заканчивается 0-символом и должна иметь размер не менее strlen(strDest) + strlen(source) + 1 байтов.
const int MAX = 80;
char s1[MAX] = "a";
char s2[MAX] = "b";
cout << strcat(s1,s2) << endl; //ab warning C4996: 'strcat' was declared deprecated
cout << s1 << endl; //ab
char* s;
cout << (s= strcat(s1, s2))<< endl;//abb warning C4996
Функция errno_t strcat_s (char *strDest, size_t sizeInBytes_strDest, const char *strSource);
возвращает 0 при успешном завершении и код ошибки – в противном случае.
Функция добавляет strSource к strDest и возвращает в результате строку с нулевым символом. 0-символ strSource заменяет 0-символ strDest. Поведение strcat_s не определено, если исходная и целевая строки накладываются.
код ошибки: EINVAL (22) – Invalid argument или ERANGE () – Result too large.
char buf[16];
strcpy_s (buf, 16, "Start");
strcat_s (buf, 16, " End");
cout << buf << endl; // Start End
const int MAX = 80;
char s1[MAX] = "a";
char s2[MAX] = "b";
strcat_s (s1, MAX, s2);
cout << s1<< endl; //ab
Шаблонная функция (только в С++)
template <size_t size>
errno_t strcat_s (char (& strDes)[size], const char * source);
позволяет вызывать функцию в привычном виде:
const int MAX = 80;
char s1[MAX] = "a";
char s2[MAX] = "b";
strcat_s (s1,s2);
cout << s1 << endl; //ab
Функция char* strncat (char* strDest, const char* source, size_t count)
позволяет добавить не более чем count символов строки source в конец строки strDest ивозвращает указатель наstrDest. В строке strDest должно быть не менее strlen(strDest) + strlen(source) + 1 байтов.
int count =2;
const int MAX = 80;
char s1[MAX] = "aaa";
char s2[MAX] = "bb";
strncat(s1,s2,count); // warning C4996: 'strncat' was declared deprecated
cout << s1 << endl; //aaabb
char *s_res = strncat(s1,s2,count);
cout << s_res << endl; //aaabbbb
Функция errno_t strncat_s (char *strDest, size_t sizeInBytes_strDest, const char *strSource, size_t count)
возвращает 0 при успешном завершении и код ошибки – в противном случае.
Функция добавляет strSource к strDest и возвращает в результате строку с нулевым символом. Первоначальный 0-символ strSource перезаписывает завершающий 0-символ strDest. Поведение strcat_s не определено, если исходная и целевая строки накладываются.
код ошибки: EINVAL (22) – Invalid argument или ERANGE () – Result too large.
const int MAX = 80;
int count =2;
char s1[MAX] = "a";
char s2[MAX] = "bbb";
strncat_s(s1, MAX, s2, count);
cout << s1<< endl; //abb
Шаблонная функция (только в С++)
template <size_t size>
errno_t strncat_s (char (& strDest)[size], const char * source, size_t count);
позволяет вызывать функцию в привычном виде:
int count=2;
const int MAX = 80;
char s1[MAX] = "aaa";
char s2[MAX] = "bbb";
strncat_s (s1,s2, count);
cout << s1 << endl; //aaabb
Сравнение строк
Функция int strcmp (char *s1, const char *s2)
сравнивает 2 строки в лексикографическом (т.е. упорядоченном по алфавиту) порядке с учетом различия прописных и строчных букв (рассматриваются первые символы, если они одинаковы, то рассматриваются вторые символы, третьи и т.д.). Функция возвращает 0, если строки равны; возвращает значение < 0, если первая строка меньше, чем вторая; и возвращает значение > 0, если первая строка больше, чем вторая.
cout << strcmp("abc", "ABC")<< endl; // возвращает 1
cout << strcmp("ABC", "ABC")<< endl; // возвращает 0
cout << strcmp("ABB", "ABC")<< endl; // возвращает -1
Функция int strncmp (char *s1, const char *s2, size_t n)
проводит сравнение только первых n символов двух строк: функция возвращает 0, если подстроки равны; возвращает значение < 0, если первая подстрока меньше, чем вторая; и возвращает значение > 0, если первая подстрока больше, чем вторая.
int count=2;
cout << strncmp("abc", "ABC", count)<< endl; // возвращает значение > 0
cout << strncmp("ABC", "abc", count)<< endl; // возвращает значение < 0
cout << strncmp("ABB", "ABC", count)<< endl; // возвращает 0
Функция int stricmp (char *s1, const char *s2)
позволяет сравнивать строки без учета регистра, т.е. без различия между прописными и строчными буквами.Она преобразует все буквы строк s1 и s2 в строчные буквы и сравнивает затем строки в лексикографическом порядке.
cout << stricmp("abc", "ABC")<< endl; // возвращает 0
// warning C4996: 'stricmp' was declared deprecated
cout << stricmp("ABC", "ABC")<< endl; // возвращает 0
// warning C4996
cout << stricmp("Ab", "ABC")<< endl; // возвращает значение < 0
// warning C4996
cout << stricmp("ABd", "abc")<< endl; // возвращает значение > 0
// warning C4996
Функция int _ stricmp (const char *s1, const char *s2) работает аналогично, но уже не выдает предупреждений:
cout << _ stricmp ("abc", "ABC")<< endl; // возвращает 0
cout << _ stricmp ("ABC", "ABC")<< endl; // возвращает 0
cout << _ stricmp ("Ab", "ABC")<< endl; // возвращает значение < 0
cout << _ stricmp ("ABd", "abc")<< endl; // возвращает значение > 0
Функция int strnicmp (char *s1, const char *s2, size_t n)
проводит сравнение только первых n символов двух строк без учета регистра, т.е. без различия между прописными и строчными буквами.
cout << strnicmp("abc", "ABC", 2)<< endl; // возвращает 0
// warning C4996: 'strnicmp' was declared deprecated
cout << strnicmp("ABC", "AaC", 2)<< endl; // возвращает значение > 0
// warning C4996
cout << strnicmp("Ab", "ABC", 2)<< endl; // возвращает 0
// warning C4996
cout << strnicmp("ABd","acc",2)<< endl; //возвращает значение < 0
// warning C4996
Функция int _ strnicmp (const char * s 1, const char * s 2, size_t count) работает аналогично, но уже не выдает предупреждений:
cout << _ strnicmp ("abc", "ABC", 2)<< endl; // возвращает 0
cout << _ strnicmp ("ABC", "AaC", 2)<< endl; // возвращает значение > 0
cout << _ strnicmp ("Ab", "ABC", 2)<< endl; // возвращает 0
cout << _ strnicmp ("ABd","acc",2)<< endl; //возвращает значение < 0
Поиск символа в строке
Функция char * strchr (const char *s, int c)
выполняет поиск символа с кодом c в строке s слева направо и возвращает указатель на позицию его первого вхождения в строку s. Если символа нет, то возвращается указатель NULL. 0-символ также включается в поиск, поэтому функция может использоваться для поиска в строке позиции 0-символа.
const int MAX = 80;
char c='\0';
char s1[MAX]="ab\0cdef";
char * s = strchr(s1, c); //указатель на символ
if (s) cout<<" n =" << int(s-s1) << endl; //n=2 - позиция символа
Функция char * strrchr (const char *s, int c)
выполняет поиск символа с кодом c в строке s справа налево и возвращает указатель на позицию его последнего вхождения в строку s. Если символа нет, то возвращается указатель NULL. 0-символ также включается в поиск, поэтому функция может использоваться для поиска в строке позиции 0-символа.
const int MAX = 80;
char c='\0';
char s1[MAX]="ab\0cdef";
char * s = strrchr(s1, c); //указатель на символ
if (s) cout<<" n =" << int(s-s1) << endl; //n=2 - позиция символа
Поиск строки в строке
Функция char * strstr (char *s1, const char *search)
выполняет поиск строки search в строке s1 и возвращает указатель на первое вхождение search в строку s1. Если строка не обнаружена, то возвращается указатель NULL.
const int MAX = 80;
char s1[MAX]="abcdef", s2[MAX]="cd";
char * s = strstr(s1, s2);
if (s) cout<<" n =" << int(s-s1) << endl; //n=2 - позиция строки
Функция size_t strspn (const char *s1, const char * charSet)
определяет и возвращает длину начальной части строки s1, состоящей только из символов, содержащихся в строке charSet. 0-символ в сравнении не участвует.
const int MAX = 80;
char s1[MAX]="abcdef", s2[MAX]="aabb";
size_t n = strspn(s1, s2); //2
Функция size_t strcspn (char *s1, const char *charSet)
определяет и возвращает длину начальной части строки s1, состоящей из символов, не содержащихся в строке charSet. 0-символ в сравнении не участвует. Если строка s1 начинается с символа, встречающегося в строке charSet, возвращается нуль. Если строка s1 не содержит ни одного символа строки charSet, возвращаемое значение совпадает с длиной строки s1.
const int MAX = 80;
char s1[MAX]="abcdef", s2[MAX]="aabb";
size_t n = strcspn(s1, s2); //0
Функция char * strpbrk (char *s1, const char *s2)
возвращает указатель на символ, являющийся первым вхождением любого из символов строки s2 в строку s1. Если символ не найден, то возвращается указатель NULL.
const int MAX = 80;
char s1[MAX]="abcdef", s2[MAX]="cf";
char *s= strpbrk(s1, s2);
cout << int(s-s1) << endl; //2
Преобразование и заполнение строк
(< stdlib. h>, <с stdlib>)
преобразование строки в число
Преобразуемая в число строка может содержать:
· последовательность цифр;
· запись вещественного числа в форме с фиксированной точкой или в экспоненциальной форме (с наличием десятичной точки, цифр порядка и символов е или Е, например, 12.345Е- 2);
· символы
|
|
|
История развития хранилищ для нефти: Первые склады нефти появились в XVII веке. Они представляли собой землянные ямы-амбара глубиной 4…5 м...
Общие условия выбора системы дренажа: Система дренажа выбирается в зависимости от характера защищаемого...
Опора деревянной одностоечной и способы укрепление угловых опор: Опоры ВЛ - конструкции, предназначенные для поддерживания проводов на необходимой высоте над землей, водой...
Автоматическое растормаживание колес: Тормозные устройства колес предназначены для уменьшения длины пробега и улучшения маневрирования ВС при...
© cyberpedia.su 2017-2024 - Не является автором материалов. Исключительное право сохранено за автором текста.
Если вы не хотите, чтобы данный материал был у нас на сайте, перейдите по ссылке: Нарушение авторских прав. Мы поможем в написании вашей работы!