std::vector<Interval> R; R.reserve(global_iter...

Проблема почти наверняка в перевыравнивании (overallocation) для Interval: вы задали __declspec(align(64)), а std::vector в вашем окружении (MSVC + /clr + .NET WinForms) не гарантирует корректную память с такой «сверх-» выравненностью без спец. поддержки aligned new или кастомного аллокатора. В результате при emplace_back(...) попадаем в память, выровненную лишь до max_align_t (обычно 16), а не до 64 — и получаем краш именно на вставке.

Почему это похоже именно на выравнивание:

• С примитивами (float) всё ок — они не требуют 64-байтного выравнивания.
• Сам по себе конструктор Interval отдельно работает — там память выделяете «как обычно», без контейнера.
• const-поля тут не мешают vector (ему нужен move-конструктор, а он будет сгенерирован); но падение на первом emplace_back при уже сделанном reserve указывает именно на проблемы адреса/выравнивания, а не на перемещения/копии.

Что сделать

Выберите один из безопасных вариантов (от самого простого к чуть более «инженерному»):

1. Убрать жесткое выравнивание

cpp
// было:
// __declspec(align(64)) struct Interval final { ... };
// станет:
struct Interval final { ... };

Чаще всего выигрыша от 64-байтного align здесь нет, а стабильность важнее. Это самый быстрый фикс.

2. Понизить выравнивание до ≤ max_align_t
   Напр., alignas(16):

cpp
alignas(16) struct Interval final { ... };

Обычно 16 поддерживается без проблем даже под /clr.

3. Оставить 64 байта, но обеспечить корректный аллокатор
   Используйте аллокатор с _aligned_malloc/_aligned_free:

cpp
template<class T, std::size_t Align>
struct aligned_allocator {
    using value_type = T;
    aligned_allocator() noexcept {}
    template<class U> aligned_allocator(const aligned_allocator<U, Align>&) noexcept {}

    T* allocate(std::size_t n) {
        void* p = _aligned_malloc(n * sizeof(T), Align);
        if (!p) throw std::bad_alloc();
        return static_cast<T*>(p);
    }
    void deallocate(T* p, std::size_t) noexcept {
        _aligned_free(p);
    }
};

using IntervalVec = std::vector<Interval, aligned_allocator<Interval, 64>>;
IntervalVec R;
R.reserve(global_iterations * 8u);
R.emplace_back(std::pair{true_start, end_val}, std::pair{true_end, best_f}, N);

4. (Альтернатива) Переопределить оператор new/delete у Interval на выровненный:

cpp
void* operator new(std::size_t sz) {
    if (void* p = _aligned_malloc(sz, 64)) return p;
    throw std::bad_alloc();
}
void operator delete(void* p) noexcept { _aligned_free(p); }

Но при размещении в std::vector для массивов может использоваться array new у аллокатора, так что вариант с кастомным аллокатором контейнера (п.3) надёжнее.

5. Включить aligned new от компилятора
   Если хотите оставить alignas(64) без аллокатора — убедитесь, что проект собирается минимум с C++17 и включён флаг MSVC /Zc:alignedNew. Под /clr это иногда не работает/работает не во всех версиях MSVC, поэтому я бы не рассчитывал только на этот флаг в смешанном проекте.

---

Ещё пара замечаний (не критично для краша)

• Поля const делают тип не присваиваемым (no move-assign), но для std::vector это не проблема — при перераспределении он использует move-конструктор/копию, а не присваивание. С этим всё ок.
• R (поле в структуре) у вас не инициализируется в конструкторе — это не причина падения, но имейте в виду, что до первого вызова ChangeCharacteristic значение мусорное.

---

Итог

Краш вызван несоответствием выравнивания элементов Interval и реального выравнивания памяти, которую выдаёт std::vector в вашем окружении (/clr). Самый быстрый фикс — убрать __declspec(align(64)) или снизить до 16. Если 64 действительно нужно для кеш-линий/false sharing — используйте кастомный выровненный аллокатор (п.3).