C++

Если вам нужен массив фиксированного размера, известного на этапе компиляции, используйте std::array. Вот пример объявления array из трёх элементов:

#include <array>

int main() {

std::array<int, 3> point = {1, 2, -3};

}

std::array является обёрткой над низкоуровневым массивом T[N], предоставляя интерфейс стандартного контейнера: он знает свой размер, умеет присваиваться, предоставляет итераторы и т.д. Как и у вектора, элементы array располагаются в памяти непрерывно, но хранятся не в динамической памяти, а на стеке. Размер array должен быть задан на этапе компиляции и не может изменяться во время выполнения программы.

Контейнер std::deque

Deque расшифровывается как double-ended queue (двусторонняя очередь). В отличие от вектора, который размещает элементы в памяти непрерывно, std::deque размещает их кусочно-непрерывно, в отдельных страницах (непрерывных блоках) памяти фиксированного размера. Даже для одного элемента в деке будет выделена целая страница. Сами страницы не обязательно расположены в памяти подряд. Отдельно поддерживается список указателей на начала страниц. Размеры страниц зависят от sizeof(T) и от конкретной реализации дека.

Дек эффективно добавляет и удаляет элементы в начале и в конце без необходимости реаллокации и копирования старых элементов. Вставка по краям в деке эффективнее, чем в векторе. Однако вставка в середину и удаление из неё требуют сдвига элементов. Обращение к элементу по индексу происходит за O(1), но требует двух разыменований указателей, в то время как вектору достаточно одного.

Пример использования deque:

#include <deque>

#include <iostream>

int main() {

std::deque<int> d = {1, 2, 3, 4};

d.push_back(5); // добавление в конец

d.push_back(6);

d.pop_back(); // удаление из конца

d.push_front(0); // добавление в начало

d.push_front(-1);

d.pop_front(); // удаление из начала

for (size_t i = 0; i != d.size(); ++i) {

std::cout << d[i] << "\n";

}

for (int x : d) {

std::cout << x << "\n";

}

}

Контейнер std::list

Двусвязный список std::list хранит элементы в отдельных узлах, которые могут располагаться в разных местах памяти. Узлы содержат указатели на предыдущий и следующий узлы. Пройтись по списку можно только с помощью range-based for или итераторов.

Пример использования list:

#include <list>

#include <iostream>

int main() {

std::list<int> l = {10, 15, 20};

l.push_front(5);

l.push_front(0);

l.push_back(25);

l.push_back(30);

l.pop_front();

l.pop_back();

for (int x : l) {

std::cout << x << "\n"; // 5 10 15 20 25

}

}

Итераторы списка

Итераторы — это объекты для навигации по контейнеру. Они позволяют обращаться к текущему элементу и сдвигаться к соседним. Функция begin возвращает итератор, указывающий на начальный элемент контейнера.

Пример использования итераторов:

#include <list>

#include <iostream>

int main() {

std::list<int> l = {10, 15, 20};

auto iter = l.begin();

std::cout << *iter << "\n"; // печатаем начальный элемент

++iter; // сдвигаемся к следующему элементу

--iter; // возвращаемся назад

}

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

Пример прохода по списку:

#include <list>

#include <iostream>

int main() {

std::list<int> l = {10, 15, 20};

for (auto iter = l.begin(); iter != l.end(); ++iter) {

std::cout << *iter << "\n"; // печатаем элементы списка через итератор

}

for (auto iter = l.rbegin(); iter != l.rend(); ++iter) {

std::cout << *iter << "\n"; // проход по списку в обратном порядке

}

}

С итераторами можно вставлять или удалять элементы в любом месте списка.

Пример вставки и удаления элементов:

#include <list>

#include <iostream>

int main() {

std::list<int> l = {0, 10, 15, 20};

auto iter = l.begin();

++iter;

l.insert(iter, 5); // вставляем на эту позицию элемент

for (auto iter = l.begin(); iter != l.end(); ) {

if (*iter % 2 == 0) {

iter = l.erase(iter); // возвращается итератор на элемент, следующий за удалённым

} else {

++iter;

}

}

}

Контейнер std::forward_list

Односвязный список std::forward_list используется там, где требуется экономия памяти на хранении ссылок на предыдущий узел. По такому контейнеру можно пройтись только вперёд, а вставка разрешена только в начало или после указанного итератора.

Пример использования forward_list:

#include <forward_list>

#include <iostream>

int main() {

std::forward_list<int> fl = {3, 42, 5};

fl.push_front(2);

auto iter = std::next(fl.begin());

iter = fl.erase_after(iter);

fl.insert_after(iter, 4);

for (int x : fl) {

std::cout << x << "\n"; // 2 3 5 4

}

}

Инвалидация итераторов и ссылок

При изменении контейнера итераторы и ссылки на элементы могут стать невалидными. Например, если у вектора произошла реаллокация, все итераторы и ссылки инвалидируются. В std::array ничего вставить нельзя, его размер фиксирован. В std::deque инвалидируются итераторы, но не инвалидируются ссылки и указатели. В std::list и std::forward_list ни итераторы, ни ссылки не инвалидируются.

Пример инвалидации итераторов:

#include <vector>

#include <iostream>

int main() {

std::vector<int> v = {1, 2, 3, 4};

auto iter = v.begin(); // итератор

int* ptr = &v.front(); // указатель

int& ref = v.front(); // ссылка

std::cout << *iter << " " << *ptr << " " << ref << "\n"; // 1 1 1

v.push_back(5); // происходит реаллокация

// обращаться к старым итераторам, указателям и ссылкам больше нельзя:

std::cout << *iter << " " << *ptr << " " << ref << "\n"; // неопределённое поведение!

}

Ассоциативные контейнеры в C++

Ассоциативные контейнеры в C++ позволяют хранить данные в виде пар "ключ-значение". Они обеспечивают быстрый доступ к значениям по ключу. В стандартной библиотеке C++ есть два основных типа ассоциативных контейнеров:

1. Контейнеры на основе сбалансированных деревьев:

- `std::map` — хранит пары "ключ-значение" в отсортированном порядке.

- `std::set` — хранит только уникальные ключи в отсортированном порядке.

2. Контейнеры на основе хеш-таблиц:

- `std::unordered_map` — хранит пары "ключ-значение" без гарантии порядка.

- `std::unordered_set` — хранит только уникальные ключи без гарантии порядка.

Также существуют "мульти" версии этих контейнеров (`multimap`, `multiset`, `unordered_multimap`, `unordered_multiset`), которые позволяют хранить несколько значений для одного ключа.

---

Контейнер `std::map`

`std::map` — это ассоциативный контейнер, который хранит пары "ключ-значение" в отсортированном порядке. Он реализован как красно-чёрное дерево, что обеспечивает логарифмическое время выполнения операций поиска, вставки и удаления.

Пример использования `std::map`:

#include <iostream>

#include <map>

#include <string>

int main() {

std::map<std::string, int> years = {

{"Moscow", 1147},

{"Rome", -753},

{"London", 47},

};

// Добавление элемента

years["Paris"] = 52;

// Итерация по элементам

for (const auto& [city, year] : years) {

std::cout << city << ": " << year << "\n";

}

// Поиск элемента

if (auto it = years.find("Rome"); it != years.end()) {

std::cout << "Found: " << it->first << " -> " << it->second << "\n";

}

// Удаление элемента

years.erase("London");

}

Основные операции:

- Вставка: `years[key] = value` или `years.insert({key, value})`.

- Поиск: `years.find(key)`.

- Удаление: `years.erase(key)`.

Контейнер `std::unordered_map`

`std::unordered_map` — это ассоциативный контейнер, основанный на хеш-таблицах. Он обеспечивает среднее время выполнения операций O(1), но не гарантирует порядок элементов.

Пример использования `std::unordered_map`:

#include <iostream>

#include <unordered_map>

#include <string>

int main() {

std::unordered_map<std::string, int> freqs;

std::string word;

// Подсчёт частот слов

while (std::cin >> word) {

++freqs[word];

}

// Вывод результатов

for (const auto& [word, freq] : freqs) {

std::cout << word << ": " << freq << "\n";

}

}

Основные операции:

- Вставка: `freqs[key] = value` или `freqs.insert({key, value})`.

- Поиск: `freqs.find(key)`.

- Удаление: `freqs.erase(key)`.

Контейнеры `std::set` и `std::unordered_set`

Эти контейнеры хранят только уникальные ключи. Они полезны, когда нужно проверить наличие элемента в коллекции.

Пример использования `std::set`:

#include <iostream>

#include <set>

#include <string>

int main() {

std::set<std::string> unique_words;

std::string word;

// Сбор уникальных слов

while (std::cin >> word) {

unique_words.insert(word);

}

// Вывод уникальных слов

for (const auto& word : unique_words) {

std::cout << word << "\n";

}

}

Мультиконтейнеры (`multimap`, `multiset`, `unordered_multimap`, `unordered_multiset`) позволяют хранить несколько значений для одного ключа.

Пример использования `std::multimap`:

#include <iostream>

#include <map>

#include <string>

int main() {

std::multimap<std::string, int> positions;

std::string word;

int position = 0;

// Сохранение позиций слов

while (std::cin >> word) {

positions.insert({word, position});

++position;

}

// Вывод всех позиций для слова "hello"

auto range = positions.equal_range("hello");

for (auto it = range.first; it != range.second; ++it) {

std::cout << "Position: " << it->second << "\n";

}

}

Итераторы ассоциативных контейнеров

Итераторы позволяют обходить элементы контейнера. Для `map` и `set` итераторы двусторонние, а для `unordered_map` и `unordered_set` — однонаправленные.

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

#include <iostream>

#include <map>

int main() {

std::map<int, std::string> numbers = {

{1, "one"},

{2, "two"},

{3, "three"},

};

auto it = numbers.find(2);

if (it != numbers.end()) {

std::cout << "Found: " << it->first << " -> " << it->second << "\n";

}

}

Ассоциативные контейнеры в C++ — это мощный инструмент для работы с данными, организованными по принципу "ключ-значение". Выбор между `map` и `unordered_map` зависит от требований к порядку элементов и производительности. Для хранения уникальных ключей используйте `set` или `unordered_set`, а для работы с дубликатами — мультиконтейнеры.

# Список исходных файлов

SRCS = $(wildcard *.cpp)

OBJS = $(SRCS:.cpp=.o)

# Основная цель

all: $(TARGET)

# Как собирать программу

$(TARGET): $(OBJS)

$(CXX) $(OBJS) $(LDFLAGS) -o $(TARGET)

# Правило для объектных файлов

%.o: %.cpp

$(CXX) $(CXXFLAGS) -c $< -o $@

# Очистка

clean:

rm -f $(OBJS) $(TARGET)

Здесь используется функция wildcard, которая автоматически находит все .cpp файлы в директории. Это делает Makefile более гибким.

3. Работа с зависимостями

3.1. Установка библиотек через пакетный менеджер

Это самый простой способ, но он имеет ограничения:

• Разные дистрибутивы Linux могут использовать разные пакетные менеджеры (apt, yum, pacman).

• Версии библиотек в репозиториях могут быть устаревшими.

Пример установки libcurl:

sudo apt-get install libcurl4-openssl-dev

3.2. Локальная компиляция библиотек

Если вы хотите избежать проблем с версиями библиотек, лучше скомпилировать их локально. Например, для libcurl:

wget https://curl.se/download/curl-8.11.1.tar.bz2

tar -jxf curl-8.11.1.tar.bz2

cd curl-8.11.1

./configure --with-openssl

make

Теперь используйте локальные пути при компиляции:

g++ curlexample.cpp -o curlexample \

-I ./curl-8.11.1/include \

-L ./curl-8.11.1/lib/.libs \

-l curl

4. Продвинутые инструменты сборки

4.1. CMake

CMake — это мощный инструмент, который поддерживает кроссплатформенную сборку. Вот пример CMakeLists.txt для проекта с зависимостью от libcurl:

cmake_minimum_required(VERSION 3.10)

project(CurlExample LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)

set(CMAKE_CXX_STANDARD_REQUIRED ON)

find_package(CURL REQUIRED)

add_executable(CurlExample curlexample.cpp)

target_link_libraries(CurlExample PRIVATE CURL::libcurl)

Чтобы собрать проект:

mkdir build

cd build

cmake ..

make

4.2. Meson

Meson — это современный инструмент, который генерирует файлы для Ninja. Пример meson.build:

project('CurlExample', 'cpp')

# Поиск libcurl

dependency('libcurl')

executable('curlexample', 'curlexample.cpp', dependencies: ['libcurl'])

Сборка:

meson setup build

cd build

ninja

4.3. SCons

SCons использует Python для написания рецептов. Пример SConstruct:

env = Environment()

env.Append(LIBS=['curl'])

env.Program(target='curlexample', source='curlexample.cpp')

Сборка:

scons

5. Docker для изоляции сборки

Docker позволяет создавать изолированные контейнеры с нужной версией ОС и библиотек. Это особенно полезно для старых проектов или CI/CD.

Пример Dockerfile:

FROM ubuntu:20.04

RUN apt-get update && apt-get install -y \

build-essential cmake git libcurl4-openssl-dev

WORKDIR /app

COPY . .

RUN mkdir build && cd build && cmake .. && make

Сборка и запуск:

docker build -t myproject .

docker run -it --rm -v $(pwd):/app myproject

6. Советы по оптимизации сборки

1. Инкрементальная сборка: Не пересобирайте весь проект, если изменился только один файл. Инструменты вроде make и ninja поддерживают это "из коробки".

2. Параллельная сборка: Используйте флаг -j для ускорения сборки на многоядерных процессорах:

   make -j$(nproc)

3. Кэширование зависимостей: Если вы используете Docker, сохраняйте зависимости в кэше, чтобы не скачивать их заново при каждой сборке.

4. Статическая vs Динамическая линковка: Выбирайте подходящий метод в зависимости от ваших целей:

   • Статическая линковка создает автономный исполняемый файл, но увеличивает его размер.

   • Динамическая линковка делает файл меньше, но требует наличия библиотек на целевой системе.

7. Заключение

Настройка сборки проекта — это инвестиция в будущее. Чем раньше вы потратите время на её автоматизацию, тем проще будет развивать проект. Вот несколько рекомендаций:

• Для небольших проектов используйте Makefile.

• Для средних и больших проектов выбирайте CMake или Meson.

• Если вам нужно тестировать сборку в разных окружениях, используйте Docker.

• Всегда документируйте процесс сборки, чтобы другие разработчики могли легко подключиться к проекту.

Помните: хороший процесс сборки — это залог стабильности и успеха вашего проекта!

Red,

Orange,

Blue,

};

Теперь вы можете использовать эти значения через префикс Color:::

Color color = Color::Red;

По умолчанию значения перечислений хранятся как целые числа, начиная с нуля. Их можно преобразовать в числа и обратно с помощью static_cast:

int value = static_cast<int>(color); // Преобразование в число

Color color2 = static_cast<Color>(2); // Преобразование обратно

Структуры

Структуры позволяют объединять несколько переменных под одним именем. Например, если вы работаете с точками в трехмерном пространстве, можно создать структуру:

struct Point {

double x = 0.0;

double y = 0.0;

double z = 0.0;

Color color; // Цвет точки

};

Инициализировать структуру можно несколькими способами:

Point point1 = {1.4, -2.2, -3.98, Color::Red};

Point point2 = {.x = 1.4, .y = -2.2}; // C++20 и выше

Кортежи и пары

Для хранения нескольких значений можно использовать std::pair или std::tuple:

#include <tuple>

std::tuple<int, double, Color> t = {42, 3.14, Color::Orange};

std::cout << std::get<0>(t); // Выведет 42

Выравнивание данных

Размер структуры может быть больше, чем сумма размеров её полей, из-за выравнивания данных . Например:

struct Point {

double x; // 8 байт

double y; // 8 байт

double z; // 8 байт

int color; // 4 байта

};

Размер этой структуры будет 32 байта, а не 28, потому что компилятор добавляет "пустые" байты для выравнивания.

2. Ссылки и указатели

Ссылки

Ссылка — это псевдоним для существующей переменной. Она должна быть инициализирована при объявлении:

int x = 42;

int& ref = x; // Теперь ref — это другое имя для x

ref = 10; // Изменит значение x

Ссылки удобны для работы с большими объектами, такими как строки или векторы, чтобы избежать копирования:

std::string s1 = "Hello";

std::string& s2 = s1; // s2 — это ссылка на s1

s2 += " World"; // Изменит s1

Указатели

Указатель хранит адрес переменной в памяти. Его можно получить с помощью оператора &:

int x = 42;

int* ptr = &x; // ptr хранит адрес x

std::cout << *ptr; // Разыменование: выведет 42

Указатели можно переназначать, а также использовать специальное значение nullptr, которое означает "пустой" указатель:

int* ptr = nullptr; // Пустой указатель

ptr = &x; // Теперь ptr указывает на x

Опасности указателей

Не обращайтесь к памяти, которая уже вышла из области видимости:

int* ptr = nullptr;

{

int x = 42;

ptr = &x;

}

// *ptr — неопределённое поведение!

3. Константность

Константы — это переменные, которые нельзя изменять после инициализации:

const int c = 42;

// c = 10; // Ошибка компиляции

Константность можно комбинировать со ссылками и указателями:

const int* ptr = &x; // Указатель на константу

int* const ptr = &x; // Константный указатель

4. Дополнительные темы

Динамическая память

Динамическая память используется, когда размер данных заранее неизвестен. Для этого применяются операторы new и delete:

int* arr = new int[10]; // Выделение памяти

delete[] arr; // Освобождение памяти

Умные указатели

Умные указатели (std::unique_ptr, std::shared_ptr) автоматически освобождают память, когда она больше не нужна:

#include <memory>

std::unique_ptr<int> ptr = std::make_unique<int>(42);

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

1. Используйте ссылки в циклах :

   for (const auto& item : vector) {

   std::cout << item;

   }

2. Избегайте "висячих" ссылок и указателей : Не обращайтесь к памяти, которая уже вышла из области видимости.

3. Проверяйте границы массивов : Используйте метод at() вместо оператора [], чтобы избежать ошибок доступа.

Задачи для практики

1. Перечисления: "Трафик-свет"

Описание:
Создайте программу, которая моделирует работу светофора. Используйте перечисление enum class TrafficLight с тремя состояниями: Red, Yellow, Green. Программа должна циклически переключать светофор каждую секунду (можно использовать std::this_thread::sleep_for для задержки).

Пример вывода:

Red

Yellow

Green

Red

...

2. Структуры: "Координаты точек"

Описание:
Создайте структуру Point3D, которая представляет точку в трехмерном пространстве. Добавьте метод distanceTo, который вычисляет расстояние между двумя точками.

Пример использования:

Point3D p1 = {1.0, 2.0, 3.0};

Point3D p2 = {4.0, 5.0, 6.0};

std::cout << p1.distanceTo(p2); // Выведет ~5.196

3. Кортежи и пары: "Анализ данных"

Описание:
Напишите программу, которая хранит информацию о студентах в виде кортежей. Каждый кортеж содержит имя студента (строка), возраст (целое число) и средний балл (число с плавающей точкой). Создайте вектор таких кортежей и найдите студента с максимальным средним баллом.

Пример данных:

std::vector<std::tuple<std::string, int, double>> students = {

{"Alice", 20, 4.5},

{"Bob", 22, 3.8},

{"Charlie", 21, 4.9}

};

Пример вывода:

Студент с максимальным баллом: Charlie, балл: 4.9

4. Указатели: "Менеджер памяти"

Описание:
Напишите программу, которая динамически выделяет память под массив целых чисел, заполняет его случайными значениями и выводит их на экран. После этого освободите память.

Дополнительно:
Добавьте проверку на утечку памяти (например, используя инструменты, такие как Valgrind или AddressSanitizer).

5. Константность: "Защита данных"

Описание:
Создайте функцию printVector, которая принимает константную ссылку на вектор и выводит его элементы. Убедитесь, что внутри функции нельзя изменить содержимое вектора.

Пример использования:

std::vector<int> nums = {1, 2, 3, 4, 5};

printVector(nums);

Пример вывода:

1 2 3 4 5

6. Умные указатели: "Управление ресурсами"

Описание:
Создайте класс FileHandler, который управляет открытием и закрытием файла. Используйте std::unique_ptr для автоматического управления ресурсами.

Пример использования:

FileHandler file("example.txt");

file.write("Hello, world!");

7. Ссылки в циклах: "Фильтрация данных"

Описание:
Напишите программу, которая фильтрует строки из вектора, оставляя только те, которые начинаются с заглавной буквы. Используйте ссылки в цикле for для эффективной работы с данными.

Пример данных:

std::vector<std::string> words = {"Apple", "banana", "Cherry", "date"};

Пример вывода:

Apple

Cherry

8. Выравнивание данных: "Размер структуры"

Описание:
Создайте структуру с полями разных типов (например, char, int, double) и выведите её размер с помощью sizeof. Затем измените порядок полей так, чтобы минимизировать размер структуры за счет выравнивания.

Пример структуры:

struct Example {

char c;

double d;

int i;

};

Пример вывода:

Исходный размер: 24 байта

Оптимизированный размер: 16 байт

9. "Висячие" ссылки: "Безопасное обращение"

Описание:
Напишите программу, которая демонстрирует проблему "висячих" ссылок. Создайте ссылку на локальную переменную внутри блока и попробуйте использовать её после выхода из блока. Объясните, почему это приводит к неопределенному поведению.

Пример кода:

int* ptr = nullptr;

{

int x = 42;

ptr = &x;

}

std::cout << *ptr; // Неопределенное поведение!

10. Комбинированная задача: "Управление библиотекой"

Описание:
Создайте программу для управления библиотекой книг. Каждая книга описывается структурой Book с полями: название, автор, год издания. Реализуйте следующие функции:

1. Добавление книги в библиотеку.

2. Поиск книги по названию.

3. Удаление книги из библиотеки.

Используйте std::vector для хранения книг и умные указатели для управления памятью.

Пример использования:

Library lib;

lib.addBook({"The C++ Programming Language", "Bjarne Stroustrup", 1985});

lib.findBook("The C++ Programming Language");

lib.removeBook("The C++ Programming Language");

Заключение

Теперь вы знаете основы работы с составными типами данных, ссылками, указателями и константностью в C++. Эти инструменты — фундамент для написания эффективного кода. Продолжайте практиковаться, и скоро вы сможете создавать сложные программы!

• Фигурные скобки {} можно не ставить, если внутри одна строка. Но лучше ставить всегда — так меньше ошибок.

• Условия можно комбинировать через && (и), || (или), ! (не).

Пример сложного условия:

if ((age >= 18 && age <= 65) || hasSpecialPermission) {

// Условие читается как:

// "Если возраст от 18 до 65 ИЛИ есть специальное разрешение"

}

1.2. Оператор switch

Идеален для выбора из множества вариантов:

switch (operation) {

case '+':

result = a + b;

break;

case '-':

result = a - b;

break;

default:

result = 0; // если ни один case не подошел

}

Важно:

• Не забудьте break, иначе выполнение «провалится» в следующий case.

• switch работает только с целыми числами и символами. Со строками — нельзя!

1.3. goto — зло?

Да, его лучше не использовать. Но для примера:

again:

std::cout << "Введите возраст: ";

int age;

std::cin >> age;

if (age < 0) goto again; // прыжок на метку again

Совет: Вместо goto используйте циклы. Они читабельнее и безопаснее.

2. Циклы: повторяем, пока не надоест

Циклы нужны, чтобы выполнять код много раз. В C++ их три вида: while, do-while, for.

2.1. Цикл while

Проверяет условие перед итерацией:

int n = 1;

while (n <= 10) {

std::cout << n << " ";

++n;

}

// Вывод: 1 2 3 ... 10

2.2. Цикл for

Идеален для перебора элементов:

for (int i = 1; i <= 10; ++i) {

std::cout << i << " ";

}

Фишка: Можно использовать range-based for для контейнеров:

std::string line = "Hello";

for (char c : line) {

std::cout << c << " "; // H e l l o

}

2.3. break и continue

• break — досрочный выход из цикла.

• continue — переход к следующей итерации.

Пример:

while (true) {

int x;

std::cin >> x;

if (x == 0) break; // выход при вводе 0

if (x < 0) continue; // пропуск отрицательных

std::cout << x << " ";

}

3. Векторы: динамические массивы

std::vector — это массив, который умеет расти. Подключаем через <vector>.

3.1. Создание и доступ

std::vector<int> nums = {1, 2, 3};

nums.push_back(4); // добавляем 4 в конец

std::cout << nums[0]; // 1 (первый элемент)

std::cout << nums.size(); // 4 (размер вектора)

Важно:

• Обращение по неверному индексу (nums[10]) — неопределенное поведение.

• Используйте at() для проверки границ: nums.at(10) выбросит исключение.

3.2. Дополнительные методы

std::vector<int> v = {1, 2, 3};

v.empty(); // проверка на пустоту

v.clear(); // очистка вектора

v.reserve(100); // резервирование места для 100 элементов

v.capacity(); // текущая ёмкость

3.3. Сортировка вектора

#include <algorithm>

std::vector<int> data = {3, 1, 4};

std::sort(data.begin(), data.end()); // 1, 3, 4

4. Строки: не просто символы

std::string — это вектор символов с дополнительными функциями. Подключаем через <string>.

4.1. Основные операции

std::string s = "Hello";

s += " World!"; // "Hello World!"

std::cout << s.substr(6, 5); // "World" (подстрока)

size_t pos = s.find("World"); // позиция = 6

4.2. Дополнительные методы

std::string s = "Hello";

s.size(); // длина строки

s.empty(); // проверка на пустоту

s.append(" World"); // добавление

s.erase(0, 1); // удаление символа по индексу

s.replace(0, 5, "Hi"); // замена подстроки

s.find_first_of("aeiou"); // поиск первой гласной

4.3. Палиндром? Легко!

#include <algorithm>

std::string word = "радар";

std::string reversed = word;

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

if (word == reversed) {

std::cout << "Это палиндром!\n";

}

Практика: 5 задач для закрепления

Задача 1: «Сумматор»

Описание: Напишите программу, которая суммирует все числа, введенные пользователем, пока не будет введен 0. Пример:

Введите числа: 5 3 -2 0

Сумма: 6

Задача 2: «Поиск максимума»

Описание: Создайте вектор из 10 случайных чисел (от 1 до 100). Найдите максимальный элемент. Подсказка: Используйте rand() % 100 + 1 для генерации чисел.

Задача 3: «Шифратор»

Описание: Напишите программу, которая заменяет все гласные буквы в строке на символ '*'. Пример:

Введите строку: Hello

Результат: H*ll*

Задача 4: «Калькулятор»

Описание: Реализуйте простой калькулятор, который принимает два числа и операцию (+, -, *, /). Используйте switch для обработки операций.

Задача 5: «Удаление пробелов»

Описание: Напишите программу, которая удаляет все пробелы из введенной строки. Пример:

Введите строку: Hello World

Результат: HelloWorld

Заключение

Теперь вы знаете основы ветвлений, циклов, работы с векторами и строками. Это как Lego: из этих блоков можно собрать что угодно. Дальше — больше: функции, классы, шаблоны... Но это уже в следующих статьях.