Содержание

Введение в строки и символы

Что такое строка

В программировании строка — это последовательность символов, которую мы используем для хранения и обработки текстовой информации. Например, слова, предложения, даже числа можно представить как строки, если они рассматриваются как текст — например, «1234» — это строка из четырёх символов.

В языке C++ строки обычно записываются в двойных кавычках:

std::string text = "Привет!";

Строка может содержать буквы, цифры, пробелы, знаки препинания и другие символы.

Что такое символ (тип char)

Символ — это один отдельный знак, который занимает одну ячейку памяти. В C++ для работы с символами используется тип данных char.
Символы записываются в одинарных кавычках:

char letter = 'A';

Тип char может быть буквой, цифрой, знаком препинания или специальным символом.

Отличия между строкой и символом

Параметр	Символ (`char`)	Строка (`std::string`)
Что хранит	Один символ	Последовательность символов
Запись в коде	В одинарных кавычках: `'a'`	В двойных кавычках: `"пример"`
Использование	Обработка отдельных знаков	Хранение и работа с текстом
Примеры	`'X'`, `'1'`, `'#'`	`"Hello"`, `"123"`, `"Привет"`

Где используются строки и символы

Строки — активно применяются для хранения имен, сообщений, текстов, адресов и любых данных, состоящих из нескольких символов.

Символы — удобны, когда нужно анализировать текст по отдельным символам — например, для проверки первого символа слова, подсчёта букв, изменения регистра и т.д.

Задания

1. В каком из примеров записано строковое значение?
а) "Учиться C++ легко!"
б) 'B'
в) 12345
г) 'Программирование'

2. Приведите по одному примеру из жизни, где удобнее использовать строку, а где — символ.
Объясните свой выбор.

Основной тип для хранения строк

Что такое std::string

В C++ для удобной и безопасной работы с текстовыми строками используется стандартный тип данных std::string. Это класс, который хранит последовательность символов и предоставляет множество удобных функций для работы с ними.

В отличии от массивов символов (char[]), std::string автоматически управляет памятью, увеличивается при добавлении текста, умеет сравнивать, искать и изменять содержимое.

Как подключить std::string

Чтобы начать работать с этим типом, в начале программы нужно подключить заголовочный файл <string>:

#include <string>

Объявление и инициализация строк

Объявление пустой строки:

std::string s;

Инициализация строковым литералом:

std::string s = "Привет"; std::string greeting("Hello world");

Копирование из другой строки:

std::string copy = s;

Присваивание новой строки:

s = "Новый текст";

Особенности записи строковых литералов

Всегда использовать двойные кавычки " для строк.
Внутри строки можно использовать любые символы, включая пробелы и цифры.
Для символа (тип char) использовать одинарные кавычки — это не строка!

Пример работы с std::string

#include <iostream>
#include <string>

void main() {
    std::string name = "Имя";
    std::cout << "Привет, " << name << "!" << std::endl;
}

Данный код выведет: Привет, Имя!

Задания

3. Объявите строку с вашим именем и выведите её на экран.

4. Создайте строку с текстом «C++ это интересно». Измените её на «C++ — это очень интересно» путем присваивания нового значения переменной.

Символьный тип char — основы работы с символами

Что такое char

Тип данных char в C++ предназначен для хранения одного символа. Каждый символ занимает один байт памяти и может быть буквой, цифрой, знаком препинания или специальным символом.

Для создания переменной типа char нужно указать тип и имя переменной:

char letter;

Можно одновременно объявить и присвоить значение:

char letter = 'A';

Как записывать символы

Символы записываются в одинарных кавычках ' '. Например:

char ch = 'B';
char digit = '7';
char symbol = '#';

Если записать несколько символов в одинарных кавычках, например 'AB', это вызовет ошибку: в char можно хранить только один символ.

Особенности хранения символов

В компьютере символы представлены числами — кодами (например, код символа ‘A’ равен 65 в таблице ASCII).

Можно вывести числовой код символа с помощью приведения:

char ch = 'A';
std::cout << int(ch) << std::endl; // Выведет 65

Ввод и вывод символа

Для ввода используйте std::cin:

char ch;
std::cin >> ch;  // ввод одного символа

Для вывода:

std::cout << ch << std::endl;

Пример работы с символами

#include <iostream>

int main() {
    char letter = 'G';
    std::cout << "Символ: " << letter << std::endl;
    std::cout << "Код символа: " << int(letter) << std::endl;
    return 0;
}

Вывод:

Символ: G
Код символа: 71

Задания

5. Объявите переменную типа char и присвойте ей символ ‘Z’. Выведите на экран символ и его числовой код.

6. Напишите программу, которая принимает два символа с клавиатуры и выводит их посимвольно, а затем — их суммарный числовой код (сумму кодов обоих символов).

Основные операции со строками

Ввод и вывод строк

Для взаимодействия с пользователем в C++ используют:

Вывод строки:

std::string s = "Привет, мир!";
std::cout << s << std::endl;  // Вывод строки и перевод курсора

Ввод строки:

Оператор >> считывает одно слово (без пробелов):

std::string word;
std::cin >> word;

Функция std::getline считывает всю строку с пробелами до нажатия Enter:

std::string line;
std::getline(std::cin, line);

Методы `length()` и `size()`

Оба метода возвращают длину строки (число символов) и работают одинаково:

std::string s = "Hello";
st::cout << s.length() << std::endl;  // 5
std::cout << s.size() << std::endl;    // 5

Разница лишь в стилистике: size() — более универсальный для контейнеров, length() — привычен для строк.

Обращение к символам и изменение

Индексы символов начинаются с 0.
Доступ и изменение символа через []:

std::string s = "Hello";
char c = s[0];  // 'H'
s[1] = 'a';    // "Hallo"

Не выходите за границы строки: индекс должен быть >=0 и < длина строки.
Возможны различные сбои, аварийное завершение работы или необъяснимые ошибки.

Конкатенация

Конкатенация — это процесс объединения двух или более строк в одну длинную строку. В C++ для строкового типа std::string это делается очень просто с помощью специальных операторов и методов.

Оператор `+` для объединения строк

Этот оператор позволяет сложить две строки и получить новую строку, состоящую из первой и второй подряд.

std::string s1 = "Привет, ";
std::string s2 = "мир!";
std::string result = s1 + s2;  // Объединение строк
std::cout << result << std::endl;  // Вывод: "Привет, мир!"

Здесь мы создали новую строку result, которая состоит из содержимого s1 и s2. Исходные строки при этом не изменяются.

Оператор `+=` для добавления к существующей строке

Этот оператор позволяет добавить к уже существующей строке другую строку или символьный литерал прямо на месте, без создания новой переменной.

std::string s = "Hello";
s += " world";  // Добавили к строке " world"
std::cout << s << std::endl;  // Вывод: "Hello world"

Таким образом, s модифицируется и содержит теперь объединённый результат.

Задания

7. Объявите две строки: «Привет, » и «мир!». Объедините их с помощью оператора + и выведите результат.

8. Создайте строку «Hello» и добавьте к ней с помощью оператора += строку » world». Выведите итоговую строку.

Срезы и методы строк

substr(pos, len) возвращает подстроку длиной len начиная с позиции pos.

Если len не указать, получится подстрока от pos до конца.

Примеры:

std::string s = "Программирование";
std::string sub1 = s.substr(3, 5);  // "рамми"
std::string sub2 = s.substr(6);     // "стирование"

Если pos больше длины строки, программа может работать неправильно.

Извлечение первых N символов

Метод substr(pos, len) возвращает подстроку длиной len, начиная с позиции pos.

std::string s = "Пример строки";  // Исходная строка
std::string firstFive = s.substr(0, 5);  // Берём первые 5 символов
std::cout << firstFive << std::endl;  // Вывод: "Приме"

Мы создаём подстроку, начиная с нулевого индекса (pos = 0), длиной 5 символов. Метод substr не изменяет исходную строку, а возвращает новую.

Извлечение подстроки от позиции до конца

Если второй параметр не указан, подстрока берётся от позиции pos до конца строки.

std::string s = "Пример строки";
std::string tail = s.substr(7);  // Берём подстроку с 7-го символа
std::cout << tail << std::endl;  // Вывод: "строки"

Метод substr возвращает остаток строки, начиная с индекса 7 и до конца.

Получение последних N символов

Чтобы получить последние 3 символа, вычисляем с какого индекса начинать срез: длина строки минус 3.

std::string s = "Пример строки";
std::string lastThree = s.substr(s.length() - 3);  // Последние 3 символа
std::cout << lastThree << std::endl;  // Вывод: "ки"

s.length() возвращает длину строки, из неё вычитаем 3 — позиция старта подстроки. substr возвращает срез до конца.

Метод `push_back` для добавления одиночных символов

Чтобы добавить один символ в конец строки, используется метод push_back:

std::string s = "Привет";
s.push_back('!');  // Добавляем символ '!' в конец
std::cout << s << std::endl;  // "Привет!"

Это удобно для постепенного построения строки посимвольно.

Метод `append`

append — ещё один способ добавить строку в конец уже существующей:

std::string s = "Слово";
s.append(" дополнительно");
std::cout << s << std::endl;  // "Слово дополнительно"

Это аналог оператора +=, но в виде метода.

Вставка подстроки с помощью `insert`

Метод insert класса std::string позволяет вставлять дополнительные символы или подстроки в определённую позицию исходной строки. При этом существующие символы сдвигаются вправо, чтобы освободить место для вставки.

str.insert(pos, str_to_insert);

pos — индекс позиции в строке, куда вставляется новый текст.
str_to_insert — строка, которую нужно вставить.

Метод изменяет исходную строку и возвращает ссылку на неё.

Вставка строки в середину

std::string s = "Hello World!";
std::string t = "Amazing ";

s.insert(6, t);  // Вставляем t начиная с позиции 6
std::cout << s << std::endl;  // Вывод: "Hello Amazing World!"

Здесь после 6-го символа добавляется новая подстрока.

Пример 2: Вставка части строки из другой строки

std::string s1 = "C++ is great!";
std::string s2 = "really awesome and ";

s1.insert(7, s2, 7, 8);  // Вставляем часть s2 (8 символов начиная с 7) в позицию 7 строки s1
std::cout << s1 << std::endl;  // Вывод: "C++ is awesome great!"

Здесь мы вставляем не всю строку, а её часть, начиная с 7-го символа и длиной 8 символов.

Вставка нескольких одинаковых символов

std::string s = "aaa";
s.insert(2, 4, 'b');  // Вставляем 4 символа 'b' начиная с позиции 2
std::cout << s << std::endl;  // "aabbbbaa"

Метод вставляет несколько одинаковых символов подряд.

Важные особенности

Позиция pos может принимать значения от 0 до длины строки (включительно).
Если pos равна длине строки, вставка произойдёт в конец.
Согласно стандарту, если pos больше длины — это вызовет ошибку.
Метод изменяет существующую строку без создания новой.

Метод `find`

Ищет первое вхождение подстроки, символа или последовательности символов в строке.
Начинает поиск с указанной позиции (по умолчанию — с начала).
Возвращает индекс позиции первого символа найденного фрагмента.
Если элемент не найден, возвращает специальное значение std::string::npos.

std::string s = "Привет, мир!";

size_t pos1 = s.find("мир");        // ищем подстроку "мир" с начала
size_t pos2 = s.find('и');            // ищем символ 'и' с начала
size_t pos3 = s.find("ивет", 2);    // ищем "ивет" начиная с позиции 2

Что делают эти примеры

pos1 будет равна позиции, где начинается «мир» (в данном случае 8).
pos2 — позиция первого символа ‘и’ (например, в «Привет» это 3).
pos3 — поиск подстроки «ивет» начиная с индекса 2.

Метод `rfind`

Ищет последнее (самое правое) вхождение подстроки или символа.
Начинает поиск с указанной позиции с конца строки!
Если позиция не указана, ищет по всей строке с конца.
Возвращает индекс первого символа последнего найденного вхождения или std::string::npos, если не найдено.

std::string s = "привет, привет";

size_t pos1 = s.rfind("привет");       // ищет последнее вхождение "привет"
size_t pos2 = s.rfind('и');               // ищет последний символ 'и'
size_t pos3 = s.rfind("пр", 5);         // ищет вхождение "пр" начиная с позиции 5 и двигаясь влево

Что делают эти примеры

pos1 укажет на начало второго «привет» в строке.
pos2 вернёт позицию последнего символа ‘и’ в строке.
pos3 будет искать «пр» начиная со смещения 5 назад.

Метод replace

Метод replace класса std::string используется для замены части строки, начиная с заданной позиции, на другую строку или символы.

str.replace(start, count, new_str);

start — индекс позиции в исходной строке, с которой начинается замена.
count — количество символов, которые будут заменены.
new_str — строка или символ(ы), на которые происходит замена.

Метод изменяет исходную строку, заменяя count символов, начиная с start, на содержимое new_str.

Замена нескольких символов

std::string s = "Пример строки";
s.replace(0, 6, "Образец");
std::cout << s << std::endl;  // Вывод: Образец строки

Здесь мы заменили первые 6 символов с позиции 0 на слово «Образец».

Замена части строки внутри строки

std::string text = "Я люблю C++";
text.replace(7, 3, "Python");
std::cout << text << std::endl;  // Вывод: Я люблю Python

Здесь с позиции 7 заменили 3 символа («C++») на «Python».

Замена по подстроке

Для замены по подстроке можно сначала найти позицию с помощью find, а затем заменить нужный участок:

std::string s = "Старый текст";
size_t pos = s.find("Старый");
s.replace(pos, 6, "Новый");
std::cout << s << std::endl;  // Вывод: Новый текст

Здесь сначала нашли подстроку «Старый», потом заменили её на «Новый».

Замена символа

Можно заменить один символ, указав длину 1 и подставив строку из одного символа:

std::string s = "Кот";
s.replace(2, 1, "п");
std::cout << s << std::endl;  // Вывод: Коп

Важные особенности

Если count равен 0, то новый текст вставится без удаления текущих символов.
Если start выходит за длину строки, программа может вызвать ошибку или исключение.
Метод меняет исходную строку, не возвращает новую.

Метод `erase`

Метод erase класса std::string позволяет удалять части строки, короткими и понятными командами управлять её содержимым.

str.erase(pos, count);

pos — начальный индекс, с которого нужно начать удаление.
count — количество символов, которые нужно удалить, начиная с pos.

Метод изменяет исходную строку, без возврата новой.

Удаление одного символа

std::string s = "Пример строки";  // Исходная строка
s.erase(4, 1);                       // Удаляем символ с индеком 4 ('р')
std::cout << s << std::endl;          // Вывод: "Пимер строки"

Объяснение: Удаляется символ ‘р’, который стоит четвертым в строке (нумерация с 0).»

Удаление диапазона символов

std::string s = "Удалить часть этой строки";
s.erase(7, 5);                     // Удаляем 5 символов начиная с 7-й позиции
std::cout << s << std::endl;            // Вывод: "Удалить часть этой строки"

Объяснение: Удаляются символы с 7 по 11 (слово «часть»).

Удаление с конца строки

std::string s = "Удалить последний символ";
// Удаляем последний символ
s.erase(s.length() - 1, 1);
std::cout << s << std::endl;           // Вывод: "Удалить последний симво"

Объяснение: s.length() - 1 — индекс последнего символа, который удаляется.

Удаление всей строки

std::string s = "Полностью очищенная строка";
s.erase();                                // Удаляет всю строку
std::cout << "Длина строки: " << s.size() << std::endl;  // Вывод: 0

Объяснение: Вызов erase() без параметров полностью очищает строку.

Важные особенности

erase(pos, count) — удаляет count символов, начиная с pos.
Можно удалять отдельный символ или диапазон.
Вызов без параметров удаляет всю строку.
Метод изменяет исходную строку, не создаёт новую.

Функция `std::reverse()`

Функция std::reverse() — это встроенная функция из стандартной библиотеки C++, которая переворачивает порядок элементов в заданном диапазоне. Она находится в заголовочном файле <algorithm>.

Подключение библиотеки

Чтобы использовать std::reverse(), нужно подключить заголовочный файл:

#include <algorithm>

std::reverse(начало, конец);

начало — итератор на начало диапазона (обычно str.begin())

конец — итератор на конец диапазона (обычно str.end())

Функция меняет порядок элементов на месте, то есть изменяет исходную строку, а не создаёт новую.

Простой переворот строки

std::string s = "Привет";
std::reverse(s.begin(), s.end());
std::cout << s << std::endl;  // Вывод: "тевирП"

Что происходит:

Создаётся строка s со значением «Привет»
Вызывается std::reverse() с итераторами на начало и конец строки
Функция меняет порядок символов: первый становится последним, второй — предпоследним и так далее
Исходная строка изменяется

Переворот с сохранением оригинала

Если нужно сохранить исходную строку, сначала создайте копию:

std::string original = "Hello";
std::string copy = original;

std::reverse(copy.begin(), copy.end());

std::cout << "Оригинал: " << original << std::endl;  // Hello
std::cout << "Перевёрнутая: " << copy << std::endl;  // olleH

Что происходит:

Создаём оригинальную строку
Создаём её копию
Переворачиваем копию, оригинал остаётся нетронутым

Переворот части строки

Можно перевернуть только часть строки, указав другие границы:

std::string s = "Hello World";
std::reverse(s.begin(), s.begin() + 5);  // Переворачиваем первые 5 символов
std::cout << s << std::endl;  // Вывод: "olleH World"

Что происходит:

s.begin() — начало строки (индекс 0)
s.begin() + 5 — позиция после 5-го символа
Переворачиваются только символы с индекса 0 по 4 (слово «Hello»)

Переворот последних символов

std::string s = "Программирование";
std::reverse(s.begin() + 5, s.end());  // Переворачиваем всё, начиная с 5-го символа
std::cout << s << std::endl;  // "Прогеинавориммар"

Что происходит:

Первые 5 символов остаются на месте
Остальная часть строки переворачивается

Задания

В задачах использовать строки длиной не менее 10 символов

9. Создайте строку «Привет» и добавьте к ней символ '!' с помощью метода push_back. Выведите итог.

10. Создайте строку «Слово» и добавьте к ней с помощью метода append строку » дополнительно». Выведите итог.

11. Напишите программу, которая объединяет три строки: «C++», » —», » это невероятно!» используя оператор + для первых двух, а затем добавляет третью с помощью оператора +=. Выведите результат.

12. Есть строка «Программирование». Добавьте в её конец символ «!» с помощью push_back. Затем дополните строку фразой » интересно» через метод append. Выведите финальную строку.

13. Ввести две строки с клавиатуры и объединить их в одну с пробелом между ними с помощью + и +=. Вывести итоговую строку.

14. Ввести строку с помощью std::getline и вывести её длину.

15. Ввести строку и вывести первый и последний символ.

16. Ввести строку, заменить третий символ на ‘X’.

17. Ввести строку и вывести первые четыре символа.

18. Ввести строку и вывести подстроку с 5-го по 9-й символы включительно.

19. Ввести строку и вывести последние пять символов.

20. Ввести строку и вывести подстроку начиная с второго символа до конца.

21. Ввести строку и удалить 3 символа с позиции 2, вывести результат, используя метод erase.

22. Ввести строку, вставить «XYZ» в позицию 4, вывести результат.

23. Ввести строку и заменить первые 4 символа на «ABCD», вывести результат.

24. Ввести строку, найти подстроку «test» и вывести позицию.

25. Переверните строку «Hello World» полностью и выведите результат.

26. Создайте строку «Programming», переверните только первые 4 символа.

27. Переверните только последние 5 символов строки «Программирование».

28. Напишите программу, которая принимает строку и выводит её в перевёрнутом виде и в оригинальном.

Введение в строки и символы

Что такое строка

Что такое символ (тип char)

Где используются строки и символы

Задания

Основной тип для хранения строк

Что такое std::string

Как подключить std::string

Объявление и инициализация строк

Особенности записи строковых литералов

Пример работы с std::string

Задания

Символьный тип char — основы работы с символами

Что такое char

Как записывать символы

Особенности хранения символов

Ввод и вывод символа

Пример работы с символами

Задания

Основные операции со строками

Ввод и вывод строк

Методы length() и size()

Обращение к символам и изменение

Конкатенация

Оператор + для объединения строк

Оператор += для добавления к существующей строке

Задания

Срезы и методы строк

Извлечение первых N символов

Извлечение подстроки от позиции до конца

Получение последних N символов

Метод push_back для добавления одиночных символов

Метод append

Вставка подстроки с помощью insert

Важные особенности

Метод find

Метод rfind

Метод replace

Важные особенности

Метод erase

Важные особенности

Функция std::reverse()

Подключение библиотеки

Задания

Методы `length()` и `size()`

Оператор `+` для объединения строк

Оператор `+=` для добавления к существующей строке

Метод `push_back` для добавления одиночных символов

Метод `append`

Вставка подстроки с помощью `insert`

Метод `find`

Метод `rfind`

Метод `erase`

Функция `std::reverse()`