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

Да, при добавлении элементов в вектор (например, `std::vector` в C++) происходит перераспределение памяти, если количество элементов превышает текущую емкость вектора. Однако, как вы заметили, может возникнуть ситуация, когда адрес вектора не меняется, и это может привести к путанице.

### Как работает `std::vector`

`std::vector` управляет своей памятью следующим образом:

1. **Начальная емкость**: При создании вектора его емкость может быть 0 (в зависимости от реализации). Когда вы добавляете новый элемент с помощью метода `push_back()`, если емкость равна 0, вектор выделяет память для хранения первого элемента.

2. **Увеличение емкости**: Когда вектор заполняется и количество элементов превышает текущую емкость, он выделяет новую память с большей емкостью. Обычно вектор увеличивает емкость в два раза (это зависит от реализации). Это означает, что новый адрес будет отличаться от старого.

### Почему адрес может не меняться

Если вы наблюдаете ситуацию, когда адрес вектора остается неизменным, стоит помнить следующее:

- **Использование `std::vector::reserve`**: Если вы заранее вызываете `reserve()`, вектор выделяет память для заданного количества элементов, и перераспределение может не произойти до тех пор, пока вы фактически не превысите эту емкость.
  
- **Адреса элементов**: Если вы сохраняете адреса элементов вектора (например, с помощью указателей или ссылок), то действительно, после перераспределения массив будет по новому адресу, и старые адреса станут недействительными (висячими указателями).

### Перераспределение и ссылки на элементы

Когда происходит перераспределение:

1. Вектор выделяет новую память достаточно большого размера для хранения всех существующих элементов.
2. Система копирует существующие элементы старого вектора в новую память.
3. После копирования нового вектора старый вектор можно уничтожить, а новый вектор начинает использовать новую память.

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

### Пример

Вот пример программы на C++, которая демонстрирует, как вектор изменяет свой адрес при перераспределении:

```cpp
#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec;

    std::cout << "Initial address: " << &vec << "\n";

    for (int i = 0; i < 20; ++i) {
        vec.push_back(i);
        std::cout << "Size: " << vec.size() << ", Capacity: " << vec.capacity() 
                  << ", Address of vector: " << &vec << "\n";
    }

    return 0;
}
```

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

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

При превышении capacity адрес может измениться. 
 Довольно банальная оптимизация - если впереди необходимая память свободна, расширение происходит на месте, без переноса. 
 
 Проверить можно так 
 
fn main() {
    let mut vec = Vec::with_capacity(2);
    let initial_ptr = vec.as_ptr();

    let (new_ptr, new_capacity) = std::iter::repeat(())
        .enumerate()
        .find_map(|(i, _)| {
            vec.push(i as i32 + 3);
            (vec.as_ptr() != initial_ptr).then(|| (vec.as_ptr(), vec.capacity()))
        })
        .unwrap();
    println!("Initial ptr: {:?}", initial_ptr);
    println!("New ptr: {:?}", new_ptr);
    println!("New capacity: {}", new_capacity);
}