9. Приведение типа в С++: static_cast, dynamic_cast, const_cast, reinterpret_cast.

«Умные указатели» в С++: unique_ptr, shared_ptr, weak_ptr. Контейнерные классы и итераторы. Работа с итераторами. Цикл for для работы с контейнерными объектами.

Приведение типа в C++

Основные типы приведения

static_cast
- Используется для явного приведения типов. Безопасен при корректном использовании, но не проверяет типы во время выполнения.
- Применим для приведения между базовым и производным классами (если гарантирована правильность приведения).
```
double a = 10.5;
int b = static_cast<int>(a);  // b = 10
```
dynamic_cast
- Используется для безопасного приведения между указателями или ссылками в иерархии классов с виртуальными методами.
- Проверяет тип во время выполнения и возвращает nullptr (для указателей) или выбрасывает исключение std::bad_cast (для ссылок), если приведение неудачно.
```
class Base {
    virtual void foo() {}
};

class Derived : public Base {};

Base* b = new Derived();
Derived* d = dynamic_cast<Derived*>(b);  // Успешное приведение
```
const_cast
- Используется для добавления или удаления квалификатора const из переменной.
- Безопасен, если используется для снятия const с переменной, которая изначально не была const.
```
const int a = 10;
int* b = const_cast<int*>(&a);
*b = 20;  // Поведение неопределено, поскольку `a` изначально `const`
```
reinterpret_cast
- Используется для низкоуровневого приведения типов.
- Применяется для приведения указателей к несовместимым типам, но может быть небезопасным.
```
int a = 10;
void* ptr = &a;
int* intPtr = reinterpret_cast<int*>(ptr);  // Приведение void* обратно к int*
```

«Умные указатели» в C++

Умные указатели из стандартной библиотеки C++ (C++11 и выше) помогают управлять динамическими ресурсами и предотвращать утечки памяти.

unique_ptr
- Управляет уникальным владением ресурсом. Ресурс освобождается при уничтожении unique_ptr.
- Нельзя копировать unique_ptr, но можно перемещать.
```
std::unique_ptr<int> ptr1(new int(10));
std::unique_ptr<int> ptr2 = std::move(ptr1);  // ptr1 больше не владеет ресурсом
```
shared_ptr
- Управляет совместным владением ресурсом. Ресурс освобождается, когда последний shared_ptr перестает им владеть.
- Поддерживает подсчет ссылок для отслеживания количества владельцев ресурса.
```
std::shared_ptr<int> ptr1(new int(20));
std::shared_ptr<int> ptr2 = ptr1;  // ptr1 и ptr2 владеют одним и тем же ресурсом
```
weak_ptr
- Отслеживает ресурс, управляемый shared_ptr, но не влияет на его срок жизни.
- Используется для устранения циклических зависимостей между shared_ptr.
```
std::shared_ptr<int> sharedPtr = std::make_shared<int>(30);
std::weak_ptr<int> weakPtr = sharedPtr;  // weakPtr отслеживает ресурс, но не владеет им
```

Контейнерные классы и итераторы

Основные контейнеры STL

std::vector
- Динамически изменяемый массив.
```
std::vector<int> vec = {1, 2, 3, 4, 5};
```
std::list
- Двусвязный список.
```
std::list<int> lst = {1, 2, 3, 4, 5};
```
std::set
- Множество, содержащие уникальные элементы, упорядоченные по значению.
```
std::set<int> s = {3, 1, 4, 1, 5, 9};  // Элементы будут {1, 3, 4, 5, 9}
```
std::map
- Ассоциативный массив (словарь), хранящий пары ключ-значение.
```
std::map<int, std::string> m;
m[1] = "one";
m[2] = "two";
```

Итераторы

Основные типы итераторов
- InputIterator: Поддерживает чтение из последовательности.
- OutputIterator: Поддерживает запись в последовательность.
- ForwardIterator: Поддерживает однонаправленное перемещение.
- BidirectionalIterator: Поддерживает движение вперед и назад.
- RandomAccessIterator: Поддерживает произвольный доступ, аналогично указателям.
```
std::vector<int> vec = {1, 2, 3, 4, 5};
for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it) {
    std::cout << *it << " ";
}
```
Использование итераторов
- Итераторы позволяют абстрагироваться от конкретного контейнера и работать с элементами в стандартной манере.
```
std::vector<int> vec = {1, 2, 3, 4, 5};
auto it = vec.begin();
std::advance(it, 2);  // Переход на два элемента вперед
std::cout << *it << std::endl;  // Вывод: 3
```
Цикл for для контейнерных объектов (range-based for)
- Упрощает итерацию по контейнерам, введенный в C++11.
```
std::vector<int> vec = {1, 2, 3, 4, 5};
for (int n : vec) {
    std::cout << n << " ";
}
```

Previous8. Шаблоны функций и классов в С++.Next10. Структурное программирование.

Last updated 7 months ago