Respuesta inesperada en asignación de memoria

[aguml]

Ya lo voy pillando, entonces me surge otra pregunta ¿que pasa si intento llenar todos sus miembros con el valor maximo - 1 de un long long? o lo que es lo mismo, obligo al programa a guardar un valor muy grande de tipo long long en todos sus miembros. ¿Crashearia y se cerraria el programa? ya que la memoria realmente no existe porque ha asignado para size_t y no para long long ¿no?
El codigo anterior lo he puesto para que tarde el menor tiempo posible en dar con el valor maximo de forma precisa aunque supongo que este seria un caso para hacerlo de forma recursiva pero yo y la recursividad nos odiamos
Aqui el codigo:

Código PHP:

  #include <iostream>
#include <new>
#include <math>
using namespace std;
 
int main ()
{
   unsigned long long int n = std::numeric_limits<long long int>::max();
   long long int *p, tamEnBytes, tamEnKb;
   double tamEnMb, tamEnGb;
   int nCeros=0;
   size_t maxSize;
   
   // Voy dividiendo el valor maximo del tipo long long int entre 10*nDigitos para avanzar mas rapido
   // incrementando nDigitos en cada pasada hasta dar con un valor que no de null al reservar
   do{
      p= new (std::nothrow) long long int[n];
      if(p == NULL){
         nCeros++;
         n = std::numeric_limits<long long int>::max() / (10 * nCeros);
      }
   }while(n > 0 && p == NULL);
 
   //Una vez salga libero la memoria
   if(p != NULL)
   {
      delete [] p;
 
      if(n != std::numeric_limits<long long int>::max())
      {
         // Una vez salga del bucle anterior tendré un valor mayor al que puedo usar
         // asi que lo voy decrementando hasta encontrar el valor valido maximo
         do{
            n+=10000;
            p= new (std::nothrow) long long int[n];
            if(p != NULL)
               delete [] p;
         }while(p != NULL && n < std::numeric_limits<long long int>::max());
 
         do{
            n -= 1000;
            p= new (std::nothrow) long long int[n];
         }while(n > 0 && p == NULL);
 
         delete [] p;
 
         // Una vez salga del bucle anterior tendré un valor mayor al que puedo usar
         // asi que lo voy decrementando hasta encontrar el valor valido maximo
         do{
            n+=100;
            p= new (std::nothrow) long long int[n];
            if(p != NULL)
               delete [] p;
         }while(p != NULL && n < std::numeric_limits<long long int>::max());
 
         do{
            n -= 10;
            p= new (std::nothrow) long long int[n];
         }while(n > 0 && p == NULL);
 
         delete [] p;
 
         // Una vez salga del bucle anterior tendré un valor mayor al que puedo usar
         // asi que lo voy decrementando hasta encontrar el valor valido maximo
         do{
            n++;
            p= new (std::nothrow) long long int[n];
            if(p != NULL)
               delete [] p;
         }while(p != NULL && n < std::numeric_limits<long long int>::max());
 
         n--;
      }
      
      maxSize = n-1;
      tamEnBytes = sizeof(long long int) * maxSize;
      tamEnKb = tamEnBytes / 1024;
      tamEnMb = tamEnKb / 1024.0;
      tamEnGb = tamEnMb / 1024;
      cout << endl << "-----------------------" << endl;
      cout << "Numero maximo de elementos para los que se pudo obtener memoria es: " << n << endl;
      cout << "Memoria total consumida por el array: " << endl <<
      tamEnBytes << " bytes o " << endl <<
      tamEnKb << " Kb o " << endl <<
      tamEnMb << " Mb o " << endl <<
      tamEnGb << " Gb" << endl << endl;
   }
   cout << "Presiona una tecla para salir" << endl;
   cin.get();
   return 0;
}