165.85K

Category:

programming

Строки. Информатика

Строки в стиле C
Строка в стиле C - массив символов. Признаком
конца строки служит нулевой байт (символ конца
строки ‘\0’, 0x00).
Длина строки – число символов в строке за
исключением символа конца строки.
2

3.

Строки в стиле C
Массив символов может быть инициализирован
строковым литералом. При этом, как и для обычного
массива будет выполнена проверка размерности.
char str[10] = “qwerty”;
Размер массива должен быть не меньше числа
символов в строковом литерале + символа конца
строки. В данном примере размер массива должен
быть не менее 7 элементов.
3

4.

Строки в стиле C
Инициализация массива строковым литералом
аналогична инициализации массива классическим
образом (с использованием списка
инициализации):
char str[10] = “qwerty”;
==
char str[10] = {‘q’,‘w’,‘e’,‘r’,‘t’,‘y’,‘\0’};
4

5.

Строки в стиле C
При создании указателя на строковый литерал
char* str = (char*)“qwerty”;
в str записывается адрес региона глобальной
памяти, который содержит данный строковый
литерал и предназначен только для чтения.
5

6.

Строки в стиле C
char* str_ptr1 = (char*)“qwerty”;
char* str_ptr2 = (char*)“qwerty”;
0xAABBCCDD
0xAABBCCDD
Указатели str_ptr1 и str_ptr2 содержат одинаковые
адреса (0xAABBCCDD).
Важно не путать инициализацию указателя на
сроковый литерал и инициализацию массива
символами:
char str[10] = “qwerty”;
str=0x11223344
6

7.

Строки в стиле C
Строки в стиле C могут быть считаны с клавиатуры с
использованием функции scanf:
char str[16] = { 0 };
scanf(“%s”, str);
Вывод на экран может осуществляться с
использованием функции printf:
printf(“str = %s\n”, str);
7

8.

Строки в стиле C
Также ввод-вывод строк в стиле C может быть
осуществлен с использованием объектов стандартных
потоков ввода-вывода std::cin и std::cout:
char str[16] = { 0 };
std::cin >> str;
std::cout << “str = ” << str << std::endl;
8

9.

Строки в стиле C
При работе со строками в стиле C обычно
используются массивы символов (статические или
динамические) и функции работы со строками из
стандартной библиотеки языка C.
Основные функции работы со строками:
• strlen
• strcpy
• strcat
• strcmp
• strstr
• strchr
9

10.

Строки в стиле C
size_t strlen(const char* str);
Функция возвращает длину строки str. Длина
строки вычисляется как число символов между
началом строки, на которое указывает str, и
символом конца строки (‘\0’). Длина строки не
учитывает символ конца строки.
10

11.

Строки в стиле C
char str[10] = “qwerty”;
int len = strlen(str);
len = 6
char str2[10] = “qwe\0rty”;
len = strlen(str2);
len = 3
11

12.

Строки в стиле C
char* strcpy(char* dst, const char* src);
Функция копирует строку src с символом
завершения строки по адресу dst. При этом
размер dst должен быть таким, чтобы в него
поместилась вся строка src с завершающим
нулевым символом.
Возвращаемое значение – указатель на регион
памяти, в который было осуществлено
копирование, т. е. dst.
12

13.

Строки в стиле C
char* src_str = (char*)“qwerty”;
char* dst_str =
(char*)malloc(strlen(src_str)+1);
memset(dst_str, 0, strlen(src_str)+1);
strcpy(dst_str, src_str);
dst_str = “qwerty”
13

14.

Строки в стиле C
char str2[10];
memset(str2, 0, 10);
strcpy(str2, “qwerty”);
str2 = “qwerty”
14

15.

Строки в стиле C
char* ptr = (char*)malloc(10);
ptr = (char*)“qwerty”;
ptr=0xAABBCCDD
ptr=0x11223344
Адрес выделенной динамической памяти 0xAABBCCDD
утерян. Произошла утечка памяти.
ERROR
Динамический массив инициализировать с использованием
оператора = и строкового литерала нельзя. Поскольку в
указатель будет записан адрес строкового литерала в
глобальной области, предназначенной только для
чтения. А адрес выделенного региона памяти будет
потерян.
15

16.

Строки в стиле C
char* strcat(char* dst, const char* src);
Функция осуществляет конкатенацию (слияние)
строк dst и src. В конец dst добавляется копия
src. Символ завершения строки dst заменяется
первым символом строки src. В конец
результирующей строки добавляется символ
завершения строки.
Возвращаемое значение – конкатенированная
строка (dst).
16

17.

Строки в стиле C
char* str = (char*)malloc(25);
memset(str, 0, 25);
strcpy(str, “Hello, ”);
strcat(str, “World!”);
str = “Hello, World!”
17

18.

Строки в стиле C
int strcmp(const char* str1, const char* str2)
Функция сравнивает строки str1 и str2 пока не
будет найден первый несовпадающий символ или
пока не будет достигнут конец строки.
Осуществляется сравнение кодов символов.
Правила сравнения, специфичные для конкретных
языков, не используются.
18

19.

Строки в стиле C
Возвращаемое значение:
0 Строки str1 и str2 равны друг другу.
>0 Первый несовпадающий символ имеет
большее значение в строке str1, чем в
str2
<0 Первый несовпадающий символ имеет
меньшее значение в строке str1, чем в
str2
19

20.

Строки в стиле C
char* str1 = (char *)“qwerty”;
char* str2 = (char *)“qwgrty”;
int res = strcmp(str1, str2);
<0
20

21.

Строки в стиле C
Строки в стиле C НЕЛЬЗЯ сравнивать с использованием
оператора ==.
Поскольку при использовании оператора == будут
сравниваться адреса соответствующих регионов памяти,
а не значения, располагающиеся по этим адресам.
char* str1 = (char*)“qwerty”;
char str2[10] = “qwerty”;
if(str1 == str2) условие истинно, если адреса,
хранящиеся в str1 и str2 совпадают
21

22.

Строки в стиле C
char* strstr(char* str, const char* sub_str);
Функция ищет подстроку sub_str в строке str и
возвращает указатель на первое вхождение
sub_str в строку str. Если sub_str не является
подстрокой str возвращается нулевой указатель.
Ищется совпадение без учета символа конца
строки.
22

23.

Строки в стиле C
char str[10] = “qwerty”;
0xAABBCC00
char* sub1 = strstr(str, “er”); 0xAABBCC02
sub1 = “erty”
char* sub2 = strstr(str, “e”); 0xAABBCC02
sub2 = “erty”
char* sub3 = strstr(str, “\0”); 0xAABBCC00
sub3=“qwerty”
23

24.

Строки в стиле C
char* strchr(char* str, int chr);
Функция возвращает указатель на первое
вхождение символа chr в строку str. Если
символ chr не входит в str, то возвращается
нулевой указатель. Символ конца строки
рассматривается как часть строки.
24

25.

Строки в стиле C
char str[10] = “qwerty”;
0xAABBCC00
char* sub1 = strchr(str, ‘e’);
0xAABBCC02
sub1 = “erty”
0xAABBCC07
sub2=“”
char* sub2 = strchr(str, ‘\0’);
25

26.

Строки в стиле C
Строки в расширенной кодировке (wchar_t) имеют те
же свойства, что и строки в однобайтовой кодировке
(char).
При этом строковые литералы записываются с
префиксом L:
wchar_t wstr[10] = L“Qwerty”;
wchar_t* wstr2 = (wchar_t *)L“Abcde”;
Символом завершения строки является L‘\0’, 0x0000.26

27.

Строки в стиле C
Функции для работы со строками в расширенной
кодировке аналогичны рассмотренным функциям для
работы со строками в однобайтовой кодировке, но
вместо префикса str имеют префикс wcs.
• wcslen
• wcscpy
• wcscat
• wcscmp
• wcsstr
• wcschr
27

28.

Строки в стиле C
wchar_t* sub_str = (wchar_t*)L“World!”;
wchar_t* str = (wchar_t*)malloc(25*sizeof(wchar_t));
memset(str, 0, 25*sizeof(wchar_t));
wcscpy(str, L“Hello, ”);
wcscat(str, sub_str);
printf(“%ws\n”, str);
“Hello, World!”
28

29.

Строки в стиле C
Visual Studio поддерживает написание обобщенного
кода для работы со строками, которые в зависимости
от настроек проекта будут трактоваться как строки
в однобайтовой или в расширенной кодировке.
Для этого к проекту необходимо подключить
заголовочный файл tchar.h
#include <tchar.h>
29

30.

Строки в стиле C
Для написания обобщенного кода работы со строками используется тип
TCHAR, который в зависимости от настроек проекта будет char или
wchar_t.
Функции работы со строками имеют префикс _tcs.
• _tcslen
• _tcscpy
• _tcscat
• _tcscmp
• И т.д.
Строковые литералы объявляются с использованием макроса _TEXT.
30

31.

Строки в стиле C
Настройка используемой кодировки производится
в окне:
Проект -> Свойства -> Свойства конфигурации ->
Общие -> Набор символов
31

32.

Строки в стиле C
TCHAR* sub_str = (TCHAR*)_TEXT(“World!”);
TCHAR* str = (TCHAR*)malloc(25*sizeof(TCHAR));
memset(str, 0, 25*sizeof(TCHAR));
_tcscpy(str, _TEXT(“Hello, ”));
_tcscat(str, sub_str);
32

33.

Строки в стиле C
Преобразование строки в число
В зависимости от используемой кодировки
осуществляется семейством функций atoi/atol/atof
или _wtoi/_wtol/_wtof, или их обобщенными
вариантами _ttoi/_ttol/_ttof и т.д.
int atoi(const char* str);
long int atol(const char* str);
double atof(const char* str);
где str – преобразуемая строка.
33

34.

Строки в стиле C
char* int_str
= (char*)“12345”;
char* float_str = (char*)“123.45”;
int res0 = atoi(int_str);
double res1 = atof(float_str);
12345
123.45
34

35.

Строки в стиле C
Преобразование числа в строку
В зависимости от используемой кодировки
осуществляется семейством функций itoa/ltoa или
_itow/_ltow, или их обобщенными вариантами
_itot/_ltot и т.д.
Данные функции не входят в стандартные библиотеки C
или C++, но поддерживаются некоторыми компиляторами.
В Visual Studio для их использования можно подключить
#include <stdlib.h>
35

36.

Строки в стиле C
char* itoa(int val, char* str, int base);
char* ltoa(long val, char* str, int base);
Функции преобразуют число val в систему
счисления с основанием base и сохраняет
результат в буфер str.
Возвращаемое значение – результирующая строка
(str).
36

37.

Строки в стиле C
TCHAR str[16] = {0};
_ltot(12345, str, 16);
str = 3039
37

38.

Строки в стиле C++
Работа со строками в стиле C++ осуществляется
с использованием классов string и wstring из
пространства имён std стандартной библиотеки
C++.
Для использования данных классов необходимо
подключить заголовочный файл string.
#include <string>
38

39.

Строки в стиле C++
Создание строк в стиле C++
std::string str0;
std::string str1 = “string 1”;
std::string str2 = std::string(“string 2”);
std::string str3(“string 3”);
std::string* str4 = new std::string(“string 4”);
39

40.

Строки в стиле C++
char str_c[10] = “qwerty”;
std::string str1 = str_c;
std::string str2 = std::string(str_c);
std::string str3(str_c);
std::string* str4 = new std::string(str_c);
40

41.

Строки в стиле C++
Строки в стиле C++ могут быть введены с клавиатуры, как и
переменные встроенных типов, с использованием объекта
стандартного потока ввода std::cin:
std::string str;
std:cin >> str;
Вывод строк на экран, как и встроенных типов данных может
осуществляться с использованием объекта стандартного потока
вывода std::cout:
std::cout << str << std::endl;
41

42.

Строки в стиле C++
Вычисление длины строки в стиле C++
Вычислить длину строки (число символов в
строке без учета символа конца строки) можно с
использованием методов length или size.
std::string str = “qwerty”;
int len = str.length();
len = str.size();
len = 6
len = 6
42

43.

Строки в стиле C++
Конкатенация строк в стиле C++
Конкатенация строк может осуществляться с
использованием операторов + и +=, а также
метода append.
43

44.

Строки в стиле C++
operator+ (lstr, rstr)
При использовании оператора + создается новый
объект типа std::string, значение которого
представляет собой конкатенацию lstr и rstr.
lstr и rstr могут быть строками в стиле C или
C++ или символами. При этом, хотя бы один из
них должен иметь тип строки в стиле C++.
44

45.

Строки в стиле C++
std::string str0 = “Hello, ”;
std::string str1 = “World!”;
std::string str2 = str0 + str1;
“Hello, World!”
std::string str3 = str0 + “Earth!”;
std::string str4 = “Hi, ” + str1;
“Hello, Earth!”
“Hi, World!”
std::string str5 = std::string(“Hi, ”) + ‘A’; “Hi, A”
std::string str6 = ‘A’ + std::string(“BC”);
“ABC”
45

46.

Строки в стиле C++
operator+= (str)
Оператор добавляет символы str в конец строки.
str может быть строкой в стиле C или C++ или
символом.
46

47.

Строки в стиле C++
std::string str0 = “Hello, ”;
std::string str1 = “World!”;
str0 += str1;
“Hello, World!”
std::string str2 = “Hi, ”;
str2 += “Earth!”;
“Hi, Earth!”
std::string str3 = “AB”;
str3 += ‘C’;
“ABC”
47

48.

Строки в стиле C++
Метод append для строк в стиле C++ работает
аналогично оператору +=, но имеет
дополнительные возможности по добавлению
заданного числа символов.
std::string str = “Hello, ”;
str.append(“World”);
str.append(3, ‘!’);
“Hello, World!!!”
48

49.

Строки в стиле C++
Сравнение строк в стиле C++
Для сравнения строк в стиле C++ могут
использоваться операторы сравнения или метод
compare.
49

50.

Строки в стиле C++
Тип возвращаемого значения операторов сравнения
строк – bool.
Операторы == и != проверяют, является ли
содержимое сравниваемых строк одинаковым.
Операторы <, >, <=, >= сравнивают строки
лексикографически.
std::string str0 = “qwerty”;
std::string str1 = std::string(“qwerty”);
bool res = (str0 == str1);
res = true
50

51.

Строки в стиле C++
Метод compare работает аналогично функции
strcmp.
0
>0
<0
Текущая строка (для которой вызван метод) и
сравниваемая равны друг другу.
Первый несовпадающий символ имеет большее значение
в текущей строке, чем в сравниваемой
Первый несовпадающий символ имеет меньшее значение
в текущей строке, чем в сравниваемой
51

52.

Строки в стиле C++
str0 – текущая строка, str1 – сравниваемая.
std::string str0 = “qwerty”;
std::string str1 = std::string(“qwgrty”);
int res = str0.compare(str1);
<0
52

53.

Строки в стиле C++
Метод find производит поиск в текущей строке
заданной подстроки или символа и возвращает
позицию первого символа найденной подстроки
или специальное значение npos, если подстрока
не найдена.
std::string str = “qwerty”;
size_t pos = str.find(“er”);
pos = 2
53

54.

Строки в стиле C++
Преобразование строки в число и числа в строку
Преобразование строки в целое число со знаком
осуществляется функциями stoi, stol, stoll.
В целое число без знака – stoul и stoull.
В число с плавающей точкой – stof, stod,
stold.
54

55.

Строки в стиле C++
std::string int_str = “12345”;
std::string float_str = “123.45”;
int res0 = std::stoi(int_str);
12345
unsigned long long res1
= std::stoull(int_str);
12345
float res2 = std::stof(float_str);
123.449997…55

56.

Строки в стиле C++
Обратное преобразование (т. е. из числа в
строку) осуществляется функциями to_string и
to_wstring соответственно.
56

57.

Строки в стиле C++
int val0 = 12345;
unsigned long long val1 = 1234567;
float val2 = 123.45;
std::string str0 = std::to_string(val0);
“12345”
std::string str1 = std::to_string(val1);
“1234567”
std::string str2 = std::to_string(val2);
“123.449997”
57

58.

Строки в стиле C++
Доступ к элементам строки
Доступ к элементам строки осуществляется с
помощью метода at или оператора [].
58

59.

Строки в стиле C++
Метод at возвращает ссылку на элемент в
запрошенной позиции. При этом производится
проверка выхода за границы строки. При
обращении за границу строки генерируется
исключение.
std::string str = “qwerty”;
char ch = str.at(3);
str.at(2) = ‘g’;
ch = ‘r’
str = “qwgrty”
59

60.

Строки в стиле C++
Оператор [] возвращает ссылку на элемент в
запрошенной позиции. При этом проверки выхода
за границы строки не производится.
std::string str = “qwerty”;
char ch = str[3];
ch = ‘r’
str[2] = ‘g’;
str = “qwgrty”
60

61.

Строки в стиле C++
Связь строк в стиле C++ со строками в стиле C
Метод c_str классов std::string/std::wstring
позволяет получить строку в стиле C,
содержащую данные, идентичные тем, которые
хранятся в строке.
Запись в массив символов, полученный с помощью
c_str вызовет неопределенное поведение.
61

62.

Строки в стиле C++
std::string str = “qwerty”;
const char* c_str = str.c_str();
printf(“%s\n”, str);
“qwerty”
62

63.

Строки в стиле C++
Классы std::string/std::wstring также содержат
ряд полезных методов:
• Вставка символов insert
• Удаление символов erase
• Получение подстроки substr
63

64.

Строки в стиле C++
std::string str = “qty”;
//insert(idx, s) – вставляет строку s в позицию,
заданную idx
str.insert(1, “we”);
“qwety”
//insert(idx, cnt, chr) – вставляет cnt символов
chr начиная с позиции, заданной idx
str.insert(3, 1, ‘r’);
“qwerty”
64