2017-10-15 8 views
0

Pourquoi pour les boucles seulement 3 fois?Pour les boucles de boucle seulement 3 fois

for (size_t i = 0; i < 10; i++) 
{ 
    std::cout << "Dodany element kolejki: " << i << std::endl; 
    queue.Enqueue(i); 
} 

La boucle se casse toujours quand i est égal à 3. Et voici le code pour la classe File d'attente:

#ifndef QUEUE_H 
#define QUEUE_H 

#include "Node.h" 
#include <stdexcept> 

template<class T> 
class Queue 
{ 
public: 
    Queue() 
    { 
     this->FirstElement = nullptr; 
     this->LastElement = nullptr; 
    } 

    void Enqueue(T value) 
    { 
     if (0 == Size()) 
     { 
      FirstElement = new Node<T>(value); 
      LastElement = FirstElement; 
     } 
     else 
     { 
      LastElement->Previous = new Node<T>(value); 
      LastElement = LastElement->Previous; 
     } 
    } 

    T Dequeue() 
    { 
     if (0 == Size()) 
     { 
      throw std::out_of_range("Out of range ! Empty stack !"); 
     } 

     T element(FirstElement->Value); 

     if (nullptr != FirstElement->Previous) 
     { 
      Node<T>* temp = FirstElement->Previous; 
      delete FirstElement; 
      FirstElement = temp; 
     } 
     else 
     { 
      delete FirstElement; 
      FirstElement = nullptr; 
      LastElement = nullptr; 
     } 

     return element; 
    } 

    int Size() 
    { 
     int queueSize = 0; 
     Node<T>* element = FirstElement; 

     if (nullptr != FirstElement) 
     { 
      while (nullptr != FirstElement->Previous) 
      { 
       ++queueSize; 
      } 

      ++queueSize; //Uwzglednienie ostatniego elementu, ktory nie jest policzony w petli 
     } 

     return queueSize; 
    } 

private: 
    Node<T>* FirstElement; 
    Node<T>* LastElement; 
}; 
#endif // !QUEUE_H 

et le code pour la structure du Noeud:

#ifndef NODE_H 
#define NODE_H 

template<class T> 
struct Node 
{ 
public: 
    Node(T value) 
    { 
     this->Previous = nullptr; 
     this->Value = value; 
    } 

    Node<T>* Previous; 
    T Value; 
}; 
#endif // !NODE_H 

Et ici est sortie:

Dodany element kolejki: 0 
Dodany element kolejki: 1 
Dodany element kolejki: 2 

Lorsque je supprime l'appel de la méthode de mise en file d'attente pour les boucles 10 fois. Il n'y a aucun avertissement du compilateur ou de l'exception lancée ou toute autre erreur de quelque sorte que ce soit. C'est juste des boucles 3 fois pour une raison quelconque.

+2

S'il vous plaît fournir un [exemple minimal, complet et Vérifiable] (https://stackoverflow.com/help/mcve). – Ron

Répondre

1

Votre programme ne s'arrête pas à l'itération de boucle 3, mais se bloque plutôt après 3 itérations. Cela est probablement dû à la fonction Queue :: Size() qui semble entrer dans une boucle infinie.

Je pense que vous vouliez dire Taille être quelque chose comme:

int Size() 
{ 
    int queueSize = 0; 
    Node<T>* element = FirstElement; 

    if (nullptr != FirstElement) 
    { 
     while (nullptr != element->Previous) 
     { 
      element = element->Previous; 
      ++queueSize; 
     } 
     ++queueSize; 
    } 
    return queueSize; 
}