Какие знаешь проблемы std::vector?

Какие знаешь проблемы std::vector

std::vector — это один из самых часто используемых контейнеров в C++, но он имеет несколько подводных камней, которые знание которых отличает опытного программиста от новичка.

Проблема 1: Инвалидация итераторов после реаллокации

Когда вектор расширяется, он перевыделяет память, что инвалидирует все существующие итераторы:

std::vector<int> v;
v.push_back(1);
v.push_back(2);

auto it = v.begin();  // Указывает на первый элемент

v.push_back(3);       // Реаллокация! it теперь неправильный

std::cout << *it;     // UNDEFINED BEHAVIOR

Хорошая практика: резервирование места

std::vector<int> v;
v.reserve(1000);  // Предварительное выделение памяти

for (int i = 0; i < 1000; ++i) {
    v.push_back(i);  // Нет реаллокаций, итераторы остаются валидны
}

Реальная ошибка: удаление элементов во время итерации

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

// НЕПРАВИЛЬНО
for (auto it = v.begin(); it != v.end(); ++it) {
    if (*it == 3) {
        v.erase(it);  // it теперь неправильный!
        // it++ может привести к крашу
    }
}

// ПРАВИЛЬНО
for (auto it = v.begin(); it != v.end();) {
    if (*it == 3) {
        it = v.erase(it);  // erase возвращает следующий валидный итератор
    } else {
        ++it;
    }
}

// ИЛИ с C++20 ranges
auto it = std::remove(v.begin(), v.end(), 3);
v.erase(it, v.end());

Проблема 2: Копирование при передаче в функции

Передача вектора по значению создаёт копию, что дорого по производительности:

// ПЛОХО: копирование всего вектора
void processVector(std::vector<int> v) {
    for (int x : v) {
        std::cout << x << " ";
    }
}

std::vector<int> data(1000000);
processVector(data);  // Копируется 1 миллион элементов

// ХОРОШО: передача по константной ссылке
void processVector(const std::vector<int>& v) {  // Нет копирования
    for (int x : v) {
        std::cout << x << " ";
    }
}

// ХОРОШО: передача по ссылке если нужно модифицировать
void modifyVector(std::vector<int>& v) {
    v[0] = 42;
}

// C++11: move semantика
void processVector(std::vector<int>&& v) {  // Принимает r-value
    // v переместится, исходный вектор опустеет
}

Проблема 3: Чрезмерное использование памяти (capacity vs size)

std::vector<int> v;

for (int i = 0; i < 100; ++i) {
    v.push_back(i);
}

std::cout << "Size: " << v.size() << "\n";        // 100
std::cout << "Capacity: " << v.capacity() << "\n";  // Может быть 200+

// vector содержит 100 элементов, но выделена память на 200+
// Это может быть проблемой если памяти мало

// Решение: shrink_to_fit
v.shrink_to_fit();  // Освобождает неиспользуемую память

Проблема 4: Операция типа bool[] для vector<bool>

std::vector<bool> — это специализация, которая хранит биты вместо байтов. Это вызывает неожиданное поведение:

std::vector<bool> vb = {true, false, true};

// Проблема: operator[] возвращает временный объект proxy
auto ref = vb[0];  // Возвращает std::vector<bool>::reference (не bool&)

bool* ptr = &vb[0];  // ОШИБКА! Не компилируется

// Проблема: итератор работает странно
auto it = vb.begin();
*it = true;
++it;
*it = false;

// Решение: использовать std::deque или std::vector<char>
std::deque<bool> db = {true, false, true};
bool* ptr = &db[0];  // OK

std::vector<char> vc = {1, 0, 1};
bool* ptr2 = &vc[0];  // OK

Проблема 5: Исключения при доступе

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

// operator[] не проверяет границы (не выбрасывает исключение)
std::cout << v[100] << "\n";  // UNDEFINED BEHAVIOR, но не exception

// at() выбросит std::out_of_range
try {
    std::cout << v.at(100) << "\n";
} catch (const std::out_of_range& e) {
    std::cerr << "Out of range: " << e.what() << "\n";
}

Проблема 6: Производительность вставки в начало

std::vector<int> v;

// УЖАСНО: O(n) для каждой вставки
for (int i = 0; i < 1000; ++i) {
    v.insert(v.begin(), i);  // Сдвигает все элементы
}
// Общая сложность: O(n^2)

// ЛУЧШЕ: использовать std::deque для вставок в начало
std::deque<int> d;
for (int i = 0; i < 1000; ++i) {
    d.push_front(i);  // O(1)
}

Проблема 7: Небезопасное удаление

std::vector<std::string> v = {"a", "b", "c", "d"};

// Может быть утечка исключений
v.pop_back();  // Может выбросить? Нет, pop_back() noexcept

// Но clear() может быть дорого для объектов с деструкторами
v.clear();  // Вызывает деструктор для каждого элемента

Проблема 8: Неправильное использование resize

std::vector<std::unique_ptr<int>> v;

// ПРОБЛЕМА: resize может инициализировать std::unique_ptr(nullptr)
v.resize(10);  // Теперь в v 10 null указателей

// ПРАВИЛЬНО: использовать emplace_back
for (int i = 0; i < 10; ++i) {
    v.emplace_back(std::make_unique<int>(i));
}

// ИЛИ явно инициализировать
std::vector<std::unique_ptr<int>> v2;
for (int i = 0; i < 10; ++i) {
    v2.push_back(std::make_unique<int>(i));
}

Проблема 9: Thread-safety

std::vector<int> v;

// НЕ ПОТОКОБЕЗОПАСНО
std::thread t1([&v]() { v.push_back(1); });
std::thread t2([&v]() { v.push_back(2); });

t1.join();
t2.join();
// Race condition! Может быть крах или потеря данных

// РЕШЕНИЕ: использовать мьютекс
std::mutex m;
std::vector<int> safe_v;

std::thread t3([&safe_v, &m]() {
    std::lock_guard<std::mutex> lock(m);
    safe_v.push_back(1);
});

Проблема 10: Неэффективное сравнение

std::vector<int> v1, v2;

// O(n) сравнение всех элементов
if (v1 == v2) {
    // ...
}

// Если нужна только ссылка равенства, лучше сравнивать адреса
if (&v1 == &v2) {
    // Тот же вектор
}

Лучшие практики

// 1. Reserve если знаешь размер
std::vector<int> v;
v.reserve(1000);

// 2. Передавай по const-ссылке
void func(const std::vector<int>& v) { }

// 3. Используй at() для проверенного доступа
int val = v.at(0);  // Выбросит исключение при ошибке

// 4. Используй range-based for
for (auto& item : v) {
    process(item);
}

// 5. Аккуратно с итераторами
for (auto it = v.begin(); it != v.end(); ++it) {
    if (shouldRemove(*it)) {
        it = v.erase(it);
    } else {
        ++it;
    }
}

// 6. Используй std::deque для operations на edges
std::deque<int> d;
d.push_front(x);
d.push_back(x);

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