Ошибки в куче - new и delete работают, но видимо не так

#include <random>
#include <stdint.h>
#include <string>
#include <iostream>
#include <conio.h>
 
//#define assert(expr) if (!expr) throw;
 
template <typename T> inline void assert(T expr) { if (expr) {} else throw; }
 
using namespace std;
 
class huge
{
    uint32_t* val = nullptr;
    size_t len = 0;
 
    huge& allocate(size_t _len){
        if (len) delocate();
        val = new uint32_t[len = ((_len > 0) ? _len : 1)];
        return fill(0);
    }
    void delocate(){
        if (len)
        {
            delete[] val;
            val = nullptr;
            len = 0;
        }
    }
 
    inline huge& fill(uint32_t item_val) { for (size_t i = 0; i < len; i++) val[i] = item_val; return *this; }
    inline huge& fill(size_t l_idx, uint32_t item_val) {
        assert(l_idx <= len); if (l_idx == len) return *this;
        for (size_t i = 0; i < len; i++) val[i] = item_val; 
        return *this; 
    }
    inline huge& fill(size_t l_idx, size_t r_idx, uint32_t item_val) { 
        assert(l_idx <= len && r_idx <= len && l_idx <= r_idx);
        if (l_idx == len || l_idx == r_idx) return *this;
        for (size_t i = l_idx; i < r_idx; i++) val[i] = item_val; 
        return *this; 
    }
 
    inline huge& encharge(const huge& obj){
        bool sign = obj.get_sign() && len > obj.len;
        if (len < obj.len) allocate(obj.len);
        if (sign) fill(obj.len, -1);
        for (size_t i = 0; i < obj.len; i++) (sign) ? (val[i] &= obj[i]) : (val[i] = obj[i]);
        return *this;
    }
    inline huge& encharge(const huge& obj, bool sign){
        if (len < obj.len) allocate(obj.len);
        if (sign) fill(obj.len, -1);
        for (size_t i = 0; i < obj.len; i++) (sign) ? (val[i] &= obj[i]) : (val[i] = obj[i]);
        return *this;
    }
    template <typename __int, size_t size = sizeof(__int)> 
    inline huge& encharge(__int* obj, size_t sz){
        if (sz)
        {
            size_t nlen = (sz*size) / 4 + (((sz*size) % 4) ? 1 : 0);
            bool sign = (obj[sz - 1] >> (size * 8 - 1) != 0);
            if (len < nlen) allocate(nlen);
            else if (len > nlen)
                fill(nlen, sign ? -1 : 0);
            uint32_t* p_val = val;  __int* p_obj = obj + sz - 1;
            size_t i = 0;
            if (len == sz)
                for (; i < size; i += 4, p_val++)
                    *p_val |= (*p_obj >> (i * 32)) & 0xffffffff;
            for (; p_obj >= obj; p_obj--)
                if (size <= 4)
                {
                    *p_val |= *p_obj << ((i++) % (4 / size) * 8 * size);
                    if (!(i % (4 / size))) p_val++;
                }
                else
                    for (; i < size/4; i++, p_val++)
                        *p_val = (*p_obj >> (i * 32)) & 0xffffffff;
            if (sign && size < 4)
                val[nlen] = (~val[len]) ^ 0xffffffff;
        }
        return *this;
    }
 
    inline huge& copy(const huge& obj){
        if (obj.len && this != &obj) return allocate(obj.len).encharge(obj);
        return avoid();
    }
    template <typename __int, size_t size = sizeof(__int)>
    inline huge& copy(__int* _val, size_t sz){
        if (sz && (void*)_val != (void*)val)
            return allocate((sz*size) / 4 + (((sz*size) % 4) ? 1 : 0)).encharge(_val, sz);
        return avoid();
    }
 
    inline huge& zeros(){
        while ((len > 1 && !val[len - 1]) || (len > 1 && !(~val[len - 1])))
            len--;
        return *this;
    }
 
    huge& avoid(){ return allocate(1); }
 
    huge(const huge& obj, size_t sz, bool sign = false) { allocate((sz < obj.len) ? obj.len : sz).encharge(obj, sign); }
    huge(const huge& obj, bool sign) { copy(obj).set_sign(sign); }
 
    huge& operator()(size_t size){
        if (len) delocate();
        val = new uint32_t[len = ((size > 0) ? size : 1)];
        return fill(0);
    }
 
public:
    huge(){}
    huge(const huge& obj){ copy(obj); }
    huge(size_t sz, bool sign){ (*this)(sz).set_sign(sign); }
 
    huge(const byte& _val)      { copy(&_val, 1); }
    huge(const int8_t& _val)    { copy(&_val, 1); }
    huge(const int16_t& _val)   { copy(&_val, 1); }
    huge(const int32_t& _val)   { copy(&_val, 1); }
    huge(const int64_t& _val)   { copy(&_val, 1).zeros(); }
    huge(const uint8_t& _val)   { copy(&_val, 1); }
    huge(const uint16_t& _val)  { copy(&_val, 1); }
    huge(const uint32_t& _val)  { copy(&_val, 1); }
    huge(const uint64_t& _val)  { copy(&_val, 1).zeros(); }
 
    huge(byte* _val, size_t sz)     { copy(_val, sz).zeros(); }
    huge(int8_t* _val, size_t sz)   { copy(_val, sz).zeros(); }
    huge(int16_t* _val, size_t sz)  { copy(_val, sz).zeros(); }
    huge(int32_t* _val, size_t sz)  { copy(_val, sz).zeros(); }
    huge(int64_t* _val, size_t sz)  { copy(_val, sz).zeros(); }
    huge(uint8_t* _val, size_t sz)  { copy(_val, sz).zeros(); }
    huge(uint16_t* _val, size_t sz) { copy(_val, sz).zeros(); }
    huge(uint32_t* _val, size_t sz) { copy(_val, sz).zeros(); }
    huge(uint64_t* _val, size_t sz) { copy(_val, sz).zeros(); }
 
    template <size_t sz> huge(const byte(&_val)[sz])    { copy(_val, sz - 1).zeros(); }
    template <size_t sz> huge(const int8_t(&_val)[sz])  { copy(_val, sz).zeros(); }
    template <size_t sz> huge(const int16_t(&_val)[sz]) { copy(_val, sz).zeros(); }
    template <size_t sz> huge(const int32_t(&_val)[sz]) { copy(_val, sz).zeros(); }
    template <size_t sz> huge(const int64_t(&_val)[sz]) { copy(_val, sz).zeros(); }
    template <size_t sz> huge(const uint8_t(&_val)[sz]) { copy(_val, sz).zeros(); }
    template <size_t sz> huge(const uint16_t(&_val)[sz]){ copy(_val, sz).zeros(); }
    template <size_t sz> huge(const uint32_t(&_val)[sz]){ copy(_val, sz).zeros(); }
    template <size_t sz> huge(const uint64_t(&_val)[sz]){ copy(_val, sz).zeros(); }
 
 
    const huge& operator=(const huge& _val){ delocate(); return copy(_val); }
 
        operator bool() const { return (len) ? (val[len-1] > 0) : false; }
    bool operator!() const{ return !bool(*this); }
 
    size_t size() const {
        return len;
    }
 
    int8_t to_int8()    const { return (int8_t)(val[0] & 0xff); }
    int16_t to_int16()  const { return (int16_t)(val[0] & 0xffff); }
    int32_t to_int32()  const { return (int32_t)(val[0]); }
    int64_t to_int64()  const { return (int64_t(val[0]) << 32) | ((len > 1) ? val[1] : 0); }
    uint8_t to_uint8()  const { return (uint8_t)(val[0] & 0xff); }
    uint16_t to_uint16()const { return (uint16_t)(val[0] & 0xffff); }
    uint32_t to_uint32()const { return (uint32_t)(val[0]); }
    uint64_t to_uint64()const { return (uint64_t(val[0]) << 32) | ((len > 1) ? val[1] : 0); }
 
    template <typename T> static T to_int(const huge& obj) {
        switch (sizeof(T))
        {
        case 1: return (T)(obj.to_uint8() & T(-1));
        case 2: return (T)(obj.to_uint16() & T(-1));
        case 4: return (T)(obj.to_uint32() & T(-1));
        case 8: return (T)(obj.to_uint64() & T(-1));
        default: return T(0);
        }
    }
    
    ~huge(){ delocate(); }
 
#pragma region statics
    string heximal(size_t split_on = 8) const {
        string res = "";
        if (get_sign()) return " -" + abs().heximal();
        char* buf = new char[10];
        for (size_t i = 0; i < len - 1; i++)
        {
            _snprintf_s(buf, 10, 9, "%08x", val[i]);
            res = string(buf) + res;
        }
        _itoa_s(val[len - 1], buf, 10, 16);
        res = string(buf) + res;
        delete[] buf;
        if (split_on < res.length())
        {
            res.insert(res.end() - split_on, ' ');
            for (size_t i = 2; i < res.length() / split_on; i++)
                res.insert(res.end() - (i*split_on + (i - 1)), ' ');
        }
        return res;
    }
    static string heximal(const huge& obj, size_t split_on = 8) {
        return obj.heximal();
    }
 
    huge abs() const { return huge(*this, false); }
    static huge abs(const huge& obj) { return obj.abs(); }
 
#pragma endregion
private:
    inline uint32_t& operator[](size_t index){ assert(index >= 0 && index < len); return val[index]; }
    inline const uint32_t& operator[](size_t index) const { assert(index >= 0 && index < len); return val[index]; }
};