Реверсное отношение данных

#pragma once
#include <forward_list>
#include <vector>
#include <assert.h>
#include <algorithm>
 
// ** Элемент массива данных
struct s_data{
    int k;
};
 
// ** Объект
struct s_obj{
    char name[32];
    s_data *p_data;
};
 
// ** Обёртка для хранения пакета объектов
struct s_store{
    s_obj *p_obj;
    s_data *p_data;
    size_t count;
    friend bool operator==( const s_store&a, const s_store&b );
    friend bool operator==( const s_store&a, const s_obj*b );
};
 
class Example{
private:
    std::vector<s_data> datas; // ** Массив данных
    std::forward_list<s_store> objs; // ** Список объектов
    size_t counter; // ** Тест-заполнитель данных
public:
    Example():datas(), objs(),counter(1){
        // ~~ Резервация памяти под данные для избежния реаллоцирования массива
        datas.reserve( 80000 );
    }
    ~Example(){
        _clear();
        return;
        for( auto &p : objs )
            delete[]p.p_obj;
    }
    void _clear(){
        for( auto &p : objs )
            delete[]p.p_obj;
        datas.clear();
        objs.clear();
    }
    // ** Добавление пакета объектов
    s_obj* _add_object( const char *name, size_t count ){
        assert( count > 0 && "Zero count" );
        assert( datas.size() + count <= datas.capacity() && "Data array overflow" );
        s_store s;
        s.p_obj = new s_obj[count];
        datas.resize( datas.size() + count ); // Расширить массив данных под новые объекты
        auto data_ptr = &( *( datas.end() - count ) ); // Указатель на начало данных для пакета объектов
        s.p_data = data_ptr;
        s.count = count;
        // ~~ Установить данные объектов
        for( size_t i = 0; i < count; i++, data_ptr++ ){
            data_ptr->k = counter++;
            s.p_obj[i].p_data = data_ptr;
        }
        objs.push_front( s );
        return s.p_obj;
    }
    // ** Удаление пакета объектов
    void _remove_object( s_obj *p ){
        auto obj = std::find( objs.begin(), objs.end(), p ); // ** Результат поиска
        if( obj != objs.end() ){
            auto &q = *obj;
            auto i = q.p_data - datas.data(); // ** Индекс первого элемента в массиве данных удаляемого пакета
            auto count = q.count; // ** Количество объектов в пакете
            s_data*addr = nullptr; // ** Указатель на первый элемент перемещаемого блока
            s_data*real = &datas[i]; // ** Указатель на первый элемент вырезаемого блока
            // ~~ Элементов после вырезанного нет
            if( datas.size() - ( i + q.count ) == 0 ){
                delete[]q.p_obj;
                objs.remove( q );
            }
            // ~~ Необходима дефрагментация
            else{
                // ~~ Элементов после вырезанного меньше
                if( q.count > datas.size() - ( i + q.count ) ){
                    addr = &datas[i + q.count];
                    memcpy( real, addr, sizeof( datas[i] )*datas.size() - ( i + q.count ) );
                }
                // ~~ Элементов после вырезанного не меньше
                else{
                    addr = &datas[datas.size() - q.count];
                    memcpy( real, addr, sizeof( datas[i] )*q.count );
                }
                delete[]q.p_obj;
                objs.remove( q );
                // !! Необходимо оптимизировать
                // ~~ Переназначение указателя на данные для объекта
                // ??         ******************        ??
                // Необходимо реверсное отношение для
                // .. переназначения указателя объекта == addr + индекс_объекта_в_пакете
                // .. на real + индекс_объекта_в_пакете
                // ??         ******************        ??
                for( auto&p : objs ){ // !! Цикл раз
                    // ~~ Переназначение для пакета объектов
                    if( p.p_data == addr )
                        p.p_data = real;
                    // ~~ Переназначение для каждого объекта
                    for( size_t i = 0; i < count; i++ ){ // !! Цикл два
                        for( size_t j = 0; j < p.count; j++ ){ // !! Цикл три
                            if( p.p_obj[j].p_data == addr + i )
                                p.p_obj[j].p_data = real + i;
                        }
                    }
                }
            }
            datas.resize( datas.size() - count ); // ~~ Сжатие массива
        }
    }
    // ** Тест-вывод объектов
    void print()const{
        if( objs.empty() )
            printf_s( "[EMPTY]\n" );
        else{
            for( auto&p : objs ){
                if( p.count > 1 )
                    printf_s( "[0x%p]\n", &p );
                for( size_t i = 0; i < p.count; i++ ){
                    // !! Смотрим, что и где находится
                    // (A:) p.p_data + i должно быть таким же, что и p.p_obj[i].p_data (O:)
                    // (N:) - индекс объекта в пакете объектов
                    printf_s( "[0x%p] N:[%zu] A:[%p:%2d], O:[%p:%2d]\n", &p.p_obj[i], i, &p.p_data[i], p.p_data[i].k, p.p_obj[i].p_data, p.p_obj[i].p_data->k );
                }
            }
            printf_s( "\n" );
        }
    }
};
 
int main(){
    Example ex;
    auto a = ex._add_object( "a", 1 );
    auto b = ex._add_object( "b", 10 );
    auto c = ex._add_object( "c", 1 );
    // ~~ Пример внешнего использования данных объекта
    printf_s( "%d %d\n", a->p_data->k, b[3].p_data->k );
    ex.print();
    ex._remove_object( b );
    ex.print();
    ex._remove_object( a );
    ex.print();
    ex._remove_object( c );
    ex.print();
    a = ex._add_object( "a", 2 );
    ex.print();
    b = ex._add_object( "a", 5 );
    ex.print();
    c = ex._add_object( "a", 9 );
    ex.print();
    // !! Тут ошибка, реаллок неправильный
    // Невозможно назначить указатель на данные для пакета объектов
    // .. из-за нарушения последовательности данных пакета объектов (частичное перемещение)
    // Необходимо смещение элементов после, а не перемещение с конца
    ex._remove_object( b );
    ex.print();
    ex._clear();
    ex.print();
    return 0;
}
 
bool operator==( const s_store & a, const s_store & b ){
    return a.p_obj == b.p_obj;
}
 
bool operator==( const s_store & a, const s_obj * b )
{
    return a.p_obj==b;
}