StackOverflowException n'a pas été gérée

Question

Je reçois une erreur de débordement de pile en utilisant ce code, et si j'utilise head=0, il demande le nouvel opérateur.

void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc) 
    {  // try to allocate size bytes 
    void *p; 
    while ((p = malloc(size)) == 0) 
      if (_callnewh(size) == 0) 
      {  // report no memory 
      static const std::bad_alloc nomem; 
      _RAISE(nomem); 
      } 
    return (p); 
    } 



    #include "StdAfx.h" 
    #include "event.h" 


    EventList::EventList() 
     { 
     size = 0; 
     EventList *head = new EventList(); 
     tail = NULL; 


    } 


    EventList::~EventList() 
    { 
    //Do nothing 
    } 

    unsigned int EventList::Size() 
     { 
     return size; 
     } 

    void EventList :: add(Event* ev) 
    /*the event will be added to the correct location based on its time 
     So, always the event at the top (or at location 0) is the most 
     imminent event that must be handled firstly*/ 

     if(size == 0) 
      { 
      head = tail = ev; 
      ev->next = ev->previous = 0; 
      } 
     else 
      { 
      if(ev->eventTime < head->eventTime) 
      { 
      /////////////// 
      ev -> next = head; 
      head -> previous = ev; 
      ev -> previous = 0 ; 
      head = ev; 
      /////////////// 
      } 
     else 
      { 
      //////////// 
      Event* tracer = head; 
      while (tracer -> next != 0) 
       { 
       if (ev -> eventTime >= tracer -> eventTime) 
        { 
        tracer = tracer -> next; 
        } 
       else 
        { 
        ev -> next = tracer; 
        ev -> previous = tracer -> previous; 
        tracer -> previous -> next = ev; 
        tracer -> previous = ev ;       
        } 
       } 
       ////////////// 
       if (tracer -> next == 0) 
        { 
        ev -> next = 0 ; 
        ev -> previous = tracer ; 
        tracer -> next = ev; 
        tail = ev; 
        } 
       //////////// 
      } 
     } 
     size++; 
    } 
    //Remove the most imminent event from the event list to be handled 
    //by the simulator 
    //Since we have an ordered linked list this event is found at the head 
    //of the event list 
    //The retreived event will be found in ev 
    bool EventList :: remove(Event* ev) 
    { 
    /*public ev =new EventList();*/ 
    if(size == 0) 
     { 
     ev = 0; 
     return false; 
     } 
    else 
     { 
     ev =head;  
     //head=ev; 
     if (size != 1) 
      { 
      //head -> next -> previous = 0; 
      head = head -> next ; 
      ev -> next = ev -> previous = 0; 
      } 
     else 
      { 
      head = tail = 0; 
      } 
     return true; 
     } 
    delete head; 
    head=NULL; 
    } 

Answer 1

EventList::EventList() 
{ 
    // ... 
    EventList *head = new EventList(); 
    // ... 
} 

Lorsqu'un EventList est construit, il commence à construire une autre EventList. Puisque vous ne terminez pas la récursivité, vous finirez par manquer d'espace de pile.

(Même si vous avez mis fin à la récursion, vous fuir tous ces objets qui EventList youv'e créés, puisque vous ne stocke pas les pointeurs vers eux en dehors du constructeur.)