如何确保每100个给定类型的对象都被分配到连续内存中

我有一个类型。我在应用程序的不同部分实例化它，但在某个位置按顺序迭代所有部分。我不知道最后会有多少。如何创建一个分配器来存储100个对象的块，并根据需要为我提供指针？

我已经尝试过这样的方法与一个简单的类固醇工厂，但它会超过5秒：

#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>
#include <thread>
#include <mutex>
using namespace std;
template<class T>
struct Item {
    T data;
    bool alive = true;
    int id = 0;
};
template<class T>
class ItemFactory {
    vector<Item<T>> items;
    unordered_map<int, int> item_ids;
    unsigned int lastCounter=0;
    int removedCounter=0;
    mutex m;
    public:
    int CreateItem() {
        lock_guard<mutex> l(m);
        auto result = lastCounter++;
        Item<T> item;
        item.id = result;
        items.push_back(item);
        item_ids[result] = items.size()-1;
        return result;
    }
    T& GetItem(int id) {
        lock_guard<mutex> l(m);
        return items[item_ids[id]].data;
    }
    void RemoveItem(int id) {
        lock_guard<mutex> l(m);
        items[item_ids[id]].alive = false;
        removedCounter++;
        if(removedCounter>=1000) {
            removedCounter = 0;
            auto end = remove_if(items.begin(), items.end(), [](const Item<T>& item){
                return !item.alive;
            });
            items.erase(end, items.end());
            auto size = items.size();
            item_ids.clear();
            for(auto i = 0; i < size; i++) {
                item_ids[items[i].id]=i;
            }
        }
    }
};
struct demo {
    string bla;
    float arr[256];
};
int main() {
    ItemFactory<demo> f;
    for(int i = 0; i < 50000; i++) {
        auto id = f.CreateItem();
        auto id2 = f.CreateItem();
        auto & i1 = f.GetItem(id);
        auto & i2 = f.GetItem(id2);
        i1.bla = "abra kadabra bum";
        i2.bla = "bla bla bla";
        f.RemoveItem(id);
    }
    cout << "!!!" << endl;
    for(int i = 0; i < 25000; i++) {
        auto id = i + i*2;
        auto & i1 = f.GetItem(id);
        i1.bla = "abra kadabra bum";
        f.RemoveItem(id);
    }
    return 0;
}

有没有什么方法可以让连续的内存块在插入/删除时更有效？