Я создал два класса: Массив и Двусвязный список в persistent-вариантах. Мне нужно реализовать конвертацию из одной структуры в другую (Расширить экономичное использование памяти на операцию преобразования одной структуры к другой). Как это я могу сделать?
Вот мои классы:

Файл "persistent_array.h":
template
class PersistentArray
{
private:
std::vector<std::vector> versions{}; // fat-node; all versions are stored here


int current_version{};
public:
// Constructor
// takes an array and its size;
// creates vector from given array and pushes it as a base version
PersistentArray(T* arr, int size)
{
std::vector base(arr, arr + size); // transform array to vector
versions.push_back(base); // save base version in the array of versions
current_version = 0;
}


// Method to add a new version of array
// takes an index of a version you want to change;
// index of element to change and a new value
//  
void addVersion(int root_position, int change_index, T new_value)
{
    // Error checking
    if (current_version < 0 || current_version >= versions.size() ||
        root_position < 0 || root_position >= versions.size() ||
        change_index < 0 || change_index >= versions[root_position].size())
    {
        throw std::out_of_range("Invalid root position");
    }

    auto temp = versions[root_position];
    temp[change_index] = new_value;
    versions.push_back(temp);
    current_version++;
}

// Method to make UNDO-action
void undo()
{
    if (current_version <= 0)
    {
        std::cout << "No actions to undo!" << std::endl;
        return;
    }

    current_version--;
    versions.push_back(versions[current_version]);
}

// Method to make REDO-action
void redo()
{
    if (current_version >= versions.size() - 1) {
        std::cout << "No actions to redo!" << std::endl;
        return;
    }

    current_version++;  // Переход к следующей версии
    versions.push_back(versions[current_version]);
}

// Method to print all versions
void printAllVersions()
{
    for (size_t i = 0; i < versions.size(); i++)
    {
        std::cout << "Version [" << i << "]: \t{";
        for (size_t j = 0; j < versions[i].size(); j++)
        {
            std::cout << versions[i][j];
            if (j < versions[i].size() - 1)
            {
                std::cout << ", ";
            }
        }
        std::cout << "}\n";
    }
}
};

Файл "persistent_doubly_linked_list.h":
// doubly-linked-list node
template
struct DL_node
{
T value;
std::shared_ptr<DL_node> prev;
std::shared_ptr<DL_node> next;


DL_node(T data) : value(data), prev(nullptr), next(nullptr) {}
};

template
class PersistentDoublyLinkedList
{
private:
std::vector<std::shared_ptr<DL_node>> versions;


int current_version;

// helper function to print one list 
void printList(size_t version_idx) const
{
    auto current = versions[version_idx]; // head of printed list

    std::cout << "{";
    while (current)
    {
        std::cout << current->value;
        current = current->next; // go to the next
        if (current)
        {
            std::cout << ", ";
        }
    }
    std::cout << "}" << std::endl;
}
public:
PersistentDoublyLinkedList(T* arr, int size) : current_version(0) {
if (size <= 0) {
return; // Если массив пуст, просто возвращаем
}


    // Создаём голову списка
    auto head = std::make_shared<DL_node<T>>(arr[0]);
    std::shared_ptr<DL_node<T>> current = head; // Хранить указатель на текущий узел

    // Проходим по массиву и создаём двусвязный список
    for (int i = 1; i < size; ++i) {
        auto new_node = std::make_shared<DL_node<T>>(arr[i]);
        current->next = new_node; // Присоединяем новый узел к текущему
        new_node->prev = current;  // Устанавливаем ссылку на предыдущий узел
        current = new_node; // Переходим к новому узлу
    }

    // Сохраняем голову списка в вектор версий
    versions.push_back(head);
    current_version = 0; // Начинаем с нулевой версии
}

void addVersion(int root_position, int change_index, T new_value)
{
    // Error checking
    if (current_version < 0 || current_version >= versions.size() ||
        root_position < 0 || root_position >= versions.size())
    {
        throw std::out_of_range("Invalid root position");
    }

    auto root = versions[root_position]; // Получаем голову списка для указанной версии
    std::shared_ptr<DL_node<T>> new_head = nullptr;  // Голова нового списка
    std::shared_ptr<DL_node<T>> new_current = nullptr; // Указатель на текущий узел нового списка

    auto current = root;
    int index = 0;

    // Копирование узлов
    while (current) {
        auto new_node = std::make_shared<DL_node<T>>(current->value); // Создаем новый узел
        if (index == change_index) {
            new_node->value = new_value; // Меняем значение, если индекс совпадает
        }

        if (!new_head) {
            new_head = new_node; // Устанавливаем голову нового списка
        }
        else {
            new_current->next = new_node; // Присоединяем новый узел к текущему
            new_node->prev = new_current;  // Устанавливаем ссылку на предыдущий узел
        }

        new_current = new_node; // Переходим к новому узлу
        current = current->next; // Переходим к следующему узлу
        index++; // Увеличиваем индекс
    }

    // Сохраняем новый список как новую версию
    versions.push_back(new_head);

    current_version++;
}

// Method to make UNDO-action
void undo()
{
    if (current_version <= 0)
    {
        std::cout << "No actions to undo!" << std::endl;
        return;
    }

    current_version--;
    versions.push_back(versions[current_version]);
}

// Method to make REDO-action
void redo()
{
    if (current_version >= versions.size() - 1) {
        std::cout << "No actions to redo!" << std::endl;
        return;
    }

    current_version++;  // Переход к следующей версии
    versions.push_back(versions[current_version]);
}

void printAllVersions()
{
    for (size_t i = 0; i < versions.size(); i++)
    {
        std::cout << "Version [" << i << "]\t";
        printList(i);

    }
}
};