forward_list

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

Добавление, удаление и перемещение элементов внутри списка или между несколькими списками не инвалидирует итераторы, которые в настоящее время ссылаются на другие элементы в списке. Однако итератор или ссылка, ссылающиеся на элемент, инвалидируются, когда соответствующий элемент удаляется (через erase_after) из списка.

В этом примере мы создаем forward_list с именем numbers, с помощью метода front() получаем первый элемент списка и выводим его на экран. Далее мы перебираем все элементы списка с помощью цикла for и выводим их на экран.

std::make_unique

std::make_unique — это функция шаблона, которая создает и возвращает std::unique_ptr, который управляет новым объектом типа T, созданным с помощью переданных аргументов.

std::make_unique может быть полезен в задачах, где требуется управление динамически выделенной памятью с помощью std::unique_ptr. Она обеспечивает безопасность исключений и удобство использования по сравнению с явным использованием new и delete.

В этом примере мы используем std::make_unique для создания std::unique_ptr, который управляет новым объектом типа Foo. Мы передаем аргумент 5 в конструктор Foo, чтобы инициализировать поле x этим значением. Затем мы используем оператор -> для доступа к полю x и выводим его значение на экран.

std::initializer_list

std::initializer_list — это легковесный прокси-объект, который предоставляет доступ к массиву объектов типа
const T.
Объект std::initializer_list автоматически создается, когда используется список инициализации в фигурных скобках для инициализации объекта, где соответствующий конструктор принимает параметр std::initializer_list.

Список инициализации в фигурных скобках используется как правый операнд присваивания или как аргумент функции, и соответствующий оператор присваивания/функция принимает параметр std::initializer_list. Список инициализации в фигурных скобках связывается с auto, включая цикл for с диапазоном 1.

std::bitset

std::bitset — это шаблон класса, который представляет собой последовательность битов фиксированного размера N. Битовые множества могут управляться стандартными логическими операторами и преобразовываться в строки и целые числа.

В этом примере мы создаем битовое множество b размером 8 бит и инициализируем его значением 42. Затем мы выводим его на экран. Результат работы этого кода: 00101010.

#вопросы_с_собеседований
Почему стоит использовать std::swap вместо прямого обмена значений?

Использование std::swap вместо прямого обмена значений может быть более эффективным, так как std::swap может быть специализирован для определенных типов данных.
Это означает, что для некоторых типов данных может существовать более эффективная реализация std::swap, которая будет использоваться вместо общей реализации.

Также использование std::swap улучшает читаемость кода и делает его более ясным для других разработчиков.

метод Mutator

Метод Mutator, также известный как метод Setter, используется для управления изменениями переменной. Он позволяет изменять значение закрытой переменной класса через публичный метод, который принимает желаемое новое значение в качестве параметра, опционально проверяет его и изменяет закрытую переменную.

Mutator может использоваться для решения различных задач, например, для проверки входных данных или для выполнения дополнительных действий при изменении значения переменной.

В этом примере Customer имеет закрытую переменную m_age, которая представляет возраст клиента. setAge является методом Mutator для этой переменной.
Он принимает новое значение в качестве параметра и проверяет, что оно неотрицательное, прежде чем изменить значение m_age. В функции main создается объект Customer и вызывается setAge для установки значения возраста.

Результатом работы этого кода будет создание объекта класса Customer с установленным значением возраста равным 25.

memmove

Функция memmove используется для копирования блока памяти из одного места в другое. Она объявлена в заголовочном файле <cstring>. Она принимает аргументы типа void * и const void *, что позволяет ей работать с любыми типами данных. Она просто копирует указанное количество байтов из исходного буфера в целевой.

memmove может обрабатывать перекрывающиеся буферы. В отличие от memcpy, которая просто копирует данные из одного места в другое, memmove может безопасно перемещать данные, даже если исходный и целевой буферы перекрываются.

Функция memmove может быть полезна для удаления элементов из массива. Например, если вы хотите удалить элемент из массива и сдвинуть оставшиеся элементы влево, вы можете использовать memmove для перемещения данных в массиве.

memcpy

Функция memcpy используется для копирования блока памяти из одного места в другое. Она объявлена в заголовочном файле <cstring>.

memcpy не проверяет на переполнение или наличие символа '\0'. Это означает, что стоит быть осторожным при использовании этой функции и убедиться, что размера целевого буфера достаточно для хранения копируемых данных.

memcpy может быть оптимизирована для конкретной архитектуры процессора и использовать специальные инструкции для копирования блоков данных.

V8

V8 — это движок JavaScript, написанный на C++, который используется в браузере Google Chrome и других приложениях. Он может быть использован для встраивания JavaScript в любое приложение на C++. Помимо этого он также Поддерживает последние стандарты JavaScript.

Свои функции V8 реализует, используя специальные классы, написанные на с++ и объявленные в namespace V8.

Этот код создает новый контекст V8, компилирует и выполняет строку с исходным кодом JavaScript 'Hello' + ', World!', а затем выводит результат в стандартный поток вывода.

WebKit

WebKit — это свободный движок для отображения веб-страниц, разработанный компанией Apple на основе кода библиотек KHTML и KJS, используемых в графической среде KDE.
Он может быть использован для встраивания веб-браузера в любое приложение на C++.

Этот код использует библиотеки GTK и WebKit для создания нового окна и загрузки страницы Google.

std::lock_guard

Класс std::lock_guard является оберткой мьютекса, который предоставляет удобный механизм в стиле RAII для владения мьютексом на время действия блока с областью действия. Когда объект lock_guard создан, он пытается завладеть предоставленным ему мьютексом. Когда элемент управления покидает область, в которой был создан объект lock_guard, lock_guard разрушается и мьютекс освобождается.

В этом примере функция safe_increment использует std::lock_guard для блокировки мьютекса g_i_mutex, который защищает доступ к переменной g_i. Это гарантирует, что только один поток может изменять значение g_i в любой момент времени. Когда элемент управления покидает область действия объекта lock, мьютекс автоматически освобождается.

С другой стороны, функция unsafe_increment не использует мьютекс для защиты доступа к переменной g_i, что может привести к состоянию гонки (race condition) и непредсказуемым результатам.

std::piecewise_construct

std::piecewise_construct — это константа типа std::piecewise_construct_t, которая используется для разрешения перегрузок функций, которые принимают два аргумента типа tuple. Она позволяет создавать пары из двух tuple-объектов.

В этом примере мы создаем объект foo, который является парой из строки и вектора целых чисел. Мы передаем константу std::piecewise_construct в качестве первого аргумента конструктора пары, чтобы указать, что мы хотим создать пару из двух tuple-объектов. Затем мы передаем два tuple-объекта в качестве второго и третьего аргументов конструктора пары и выводим значения объекта foo.

std::unique_lock

std::unique_lock — это объект блокировки, который управляет блокировкой мьютекса. Он обеспечивает более гибкое управление блокировкой, чем std::lock_guard, поскольку позволяет заблокировать и разблокировать мьютекс несколько раз.
std::unique_lock использует шаблон RAII (Resource Acquisition Is Initialization), это означает, что при создании объекта std::unique_lock он автоматически блокирует мьютекс, а при уничтожении объекта - автоматически разблокирует его.

В этом примере MyFunction использует std::unique_lock, чтобы заблокировать мьютекс, затем выполняет некоторые операции, разблокирует мьютекс и уведомляет condition. MyOtherFunction также использует std::unique_lock, чтобы заблокировать мьютекс, затем ждет уведомления от MyFunction с помощью метода wait условной переменной condition, и после этого разблокирует мьютекс.

Этот код демонстрирует использование std::unique_lock для синхронизации доступа к общим данным и для взаимодействия между потоками с помощью условных переменных.

std::forward_as_tuple

std::forward_as_tuple — это функция, которая создает кортеж ссылок на аргументы, передаваемые в нее. Этот кортеж подходит для передачи в качестве аргумента в функцию. Кортеж содержит ссылки rvalue, когда в качестве аргументов используются rvalue, и в противном случае содержит ссылки lvalue.

std::forward_as_tuple полезен в тех случаях, когда необходимо передать аргументы функции в виде кортежа ссылок, например при использовании std::map::emplace или std::apply. Он позволяет избежать создания ненужных копий объектов и обеспечивает правильную передачу rvalue и lvalue аргументов.

В этом примере std::forward_as_tuple используется для создания кортежей аргументов для передачи в метод emplace контейнера std::map. Метод emplace принимает пару кортежей, первый из которых содержит аргументы для ключа, а второй — для значения. В этом случае ключ — это число 10, а значение — строка из 20 символов "a".

std::unordered_set

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

std::unordered_set может быть более эффективным, чем std::set, который использует бинарное дерево поиска для хранения элементов.

В этом примере создается std::unordered_set целых чисел и инициализируется пятью значениями. Затем содержимое множества выводится на экран с помощью цикла for-each. Обратите внимание, что порядок элементов в множестве не соответствует порядку их добавления.

Также в этом примере демонстрируется использование методов bucket_count, begin и end для доступа к отдельным корзинам хэш-таблицы и вывода их содержимого.

std::atomic_thread_fence

std::atomic_thread_fence — это функция, которая устанавливает порядок синхронизации памяти для не атомарных и расслабленных атомарных доступов, как указано в аргументе order, без связанной атомарной операции.

std::atomic_thread_fence может использоваться для обеспечения правильного порядка чтения и записи в многопоточных программах.

В этом примере два потока выполняют функции write_x_then_y и read_y_then_x:

- write_x_then_y устанавливает значение атомарной переменной x равным 1, затем вызывает std::atomic_thread_fence с аргументом std::memory_order_release и устанавливает значение атомарной переменной y равным 1.

- read_y_then_x считывает значение атомарной переменной y, затем вызывает std::atomic_thread_fence с аргументом std::memory_order_acquire и считывает значение атомарной переменной x.

std::map::emplace

std::map::emplace — это функция-член контейнера std::map, которая вставляет новый элемент в контейнер, используя аргументы для конструирования элемента на месте.

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

В этом примере мы создаем std::map с ключами типа std::string и значениями типа int. Затем мы используем emplace для вставки трех пар ключ-значение. В конце мы выводим содержимое map на экран.

std::apply

std::apply — это функция, которая принимает в качестве аргументов вызываемый объект и кортеж аргументов, а затем вызывает этот объект с элементами кортежа в качестве аргументов. Это позволяет удобно вызывать функции с аргументами, хранящимися в кортеже.

В этом примере мы создаем кортеж args, содержащий два аргумента для функции add. Затем мы используем std::apply для вызова функции add с этими аргументами. В конце мы выводим результат на экран.

std::midpoint

std::midpoint — это функция, которая вычисляет среднюю точку между двумя целыми числами, числами с плавающей точкой или указателями. Она возвращает половину суммы a и b, при этом не происходит переполнения.

Если a и b имеют целочисленный тип и сумма является нечетной, то результат округляется в сторону a. Если a и b имеют тип с плавающей точкой, то происходит не более одной неточной операции.

std::atomic_signal_fence

std::atomic_signal_fence — это функция, которая устанавливает порядок синхронизации памяти для неатомарных и расслабленных атомарных доступов между потоком и обработчиком сигнала, выполняемым в том же потоке. Функция эквивалентна std::atomic_thread_fence, за исключением того, что инструкции процессора для упорядочивания памяти не выполняются.

В этом примере мы используем std::atomic_signal_fence для установления порядка синхронизации памяти между двумя потоками. В конце мы выводим значение переменной b на экран. Результат работы этого кода всегда будет 1.

Дана строка s, найдите длину самой длинной подстроки без повторяющихся символов.

В решении мы используем charSet для отслеживания уникальных символов в текущей подстроке; левый и правый указатели используются для обозначения границ текущей подстроки; maxLength отслеживает длину самой длинной подстроки, встреченной на данный момент.

Используя правый указатель выполняем итерацию по строке, если текущего символа нет в charSet, то вставляем символ в набор и при необходимости обновляем maxLength. Если символ уже присутствует в наборе, то мы перемещаем левый указатель вперед, удаляя символы из набора, пока повторяющийся символ не исчезнет. Затем вставляем текущий символ в набор и продолжаем итерацию.
В результате возвращаем maxLength как длину самой длинной подстроки без повторяющихся символов.

#разбор_кода