Программирование C++

В чём практическое следствие того, что размер std::array является частью его типа?

Разберите ситуацию: алгоритм std::sort получает компаратор, который иногда считает a меньше b, а b меньше a — в зависимости от порядка предыдущих сравнений. Какое требование к компаратору нарушено и чем это опасно?

Каким образом требование сохранить относительный порядок равных элементов меняет ресурсы, необходимые алгоритму сортировки?

Сравните обход std::map и std::unordered_map: какой порядок элементов можно использовать как гарантированный результат программы?

По какому правилу std::set определяет, что два ключа эквивалентны?

Разберите механизм доступа к элементу: почему после присваивания x контейнер не меняется, а после y меняется?

#include <iostream>
#include <vector>

int main() {
    std::vector<bool> v{false};
    bool x = v[0];
    auto y = v[0];

    x = true;
    std::cout << v[0] << ' ';

    y = true;
    std::cout << v[0];
}

Представьте, что обращение к отсутствующему ключу в std::map неожиданно изменяет контейнер. Какой механизм вызвал это изменение?

Какая внутренняя организация позволяет std::priority_queue выполнять вставку за логарифмическое время?

Что происходит с итераторами std::unordered_map, когда вставка вызывает rehash?

Как различается сложность удаления элемента по уже полученному итератору в std::vector и std::list?

При переносе диапазона между разными контейнерами std::list через splice откуда берётся линейная сложность?

За счёт чего последовательное добавление элементов в std::vector имеет амортизированную константную сложность, хотя отдельная операция иногда занимает линейное время?

Как категория итератора определяет сложность std::distance?

В каких условиях поиск в std::unordered_map перестаёт иметь ожидаемую константную сложность?

В практической задаче определите вывод программы и объясните, почему два размера различаются:

#include <algorithm>
#include <iostream>
#include <vector>

int main() {
    std::vector<int> v{1, 2, 3, 2, 4};
    auto new_end = std::remove(v.begin(), v.end(), 2);
    std::cout << v.size() << ' ' << std::distance(v.begin(), new_end);
}

Рассмотрите добавление элемента в конец std::deque. Определите, является ли обращение после операции корректным, и объясните различие между итератором и ссылкой:

#include <deque>
#include <iostream>

int main() {
    std::deque<int> d{10, 20, 30};
    auto it = d.begin() + 1;
    int& ref = d[1];
    d.push_back(40);
    std::cout << *it << ' ' << ref << '
';
}

Объясните, почему применение std::lower_bound к std::list не делает поиск логарифмическим.

Найдите причину некорректности цикла удаления из std::unordered_map:

#include <string>
#include <unordered_map>

int main() {
    std::unordered_map<int, std::string> m{{1, "a"}, {2, "b"}, {3, "c"}};
    for (auto it = m.begin(); it != m.end(); ++it) {
        if (it->first % 2 == 1)
            m.erase(it);
    }
}

После вставки элемента в середину std::vector какие ранее полученные итераторы можно считать действительными?

Объясните механизм: почему std::sort принимает только итераторы произвольного доступа?