How do you stop infinite loop? Because I believe that it is making an infinite c

Question

How do you stop infinite loop? Because I believe that it is making an infinite circular list.

c++ code:

Here is the list class:

#ifndef LIN_J_LIST
#define LIN_J_LIST
typedef unsigned int uint;

#include <cassert>
#include <sstream>

using namespace std;

/**
* a simplified generic singly linked list class to illustrate C++ concepts
* @author Jerry Lin
* @version 2/17/17
*/
template< typename Object >
class List
{
private:
/**
   * A class to store data and provide a link to the next node in the list
   */
class Node
{
   public:
     /**
      * The constructor
      * @param data the data to be stored in this node
      */
      explicit Node( const Object & data )
        : data{ data }, next{ nullptr } {}

    Object data;
    Node * next;
};

public:
/**
   * The constructor for an empty list
   */
List()
    : size{ 0 }, first{ nullptr }, last{ nullptr } {}

/**
   * the copy constructor-creates and copy the list
   */
List( List && rhs ) = delete;

List( const List & rhs )
{
    count = 0;
    size = 0;
   if(rhs.size != 0)
    {     
      push_front(rhs.front());
      Node * current = rhs.first;
      Node * tempNode = first;
      size++;
    
      while(current->next != nullptr)
      {  
        current = current->next;
        Node *newNode = new Node(current->data); //transfer the data. basic op.
        count++;
        tempNode->next = newNode;
        last = newNode;
        tempNode = tempNode->next;
        size++;
      }
   
    
    }

    // you document and implement this method
}

/**
   * the operator= method-copies the list
   */
   List & operator=( List && rhs) = delete;
   List & operator=( const List & rhs )
   {
    
      count = 0;
      size = 0;
      if( size != 0 )
      {
         Node * current = first;
         Node * temp;
         while( current != nullptr )
         {
           temp = current;
           current = current->next;
           delete temp;
         }
      }

      if(rhs.size!= 0)
      {
        push_front(rhs.front());
        Node * current = rhs.first;
        Node * tempNode = first; //create a temporary to store
        size++;
        while(current -> next != nullptr)
        {
           current = current->next;
           Node *newNode = new Node(current->data); //transfer the data. basic op
           count++;
           tempNode->next = newNode;
           last = newNode;
           tempNode = tempNode -> next;
           size++;
         }
      }
      return *this;
    // you document and implement this method
}

/**
* accessor
* @return count
*/

int get_count() const
{
    return count;
}

/**
   * The destructor that gets rid of everything that's in the list and
   * resets it to empty. If the list is already empty, do nothing.
   */
~List()
{
    if( size != 0 )
    {
      Node * current = first;
      Node * temp;

      while( current != nullptr )
      {
       temp = current;
       current = current->next;
       delete temp;
      }
    }
}

/**
   * Put a new element onto the beginning of the list
   * @param item the data the new element will contain
   */
void push_front( const Object& item )
{
     Node * new_node = new Node( item );//basic op.
     if(is_empty())
     {
      last = new_node;
     }
     else
     {
      new_node->next = first;
     }
     first = new_node;
     size++;
    /* you complete the rest */
}

/**
   * Remove the element that's at the front of the list. Causes an
   * assertion error if the list is empty.
   */
void pop_front()
{
     assert( !is_empty() );
     Node * temp = first;
     if( first == last )
     {
      first = last = nullptr;
     }
     else
     {
      first = first->next;
     }
     delete temp;
     size--;
}

/**
   * Accessor to return the data of the element at the front of the list.
   * Causes an assertion error if the list is empty.
   * @return the data in the front element
   */
const Object & front() const
{
     assert( !is_empty() );
     return first->data;
}

/**
   * Accessor to return the data of the element at the tail of the list.
   * Causes an assertion error if the list is empty.
   * @return the data in the last element
   */
const Object & tail() const
{
     assert (!is_empty());
     return last->data;
    // you implement this method
}

/**
   * Accessor to determine whether the list is empty
   * @return a boolean corresponding to the emptiness of the list
   */
bool is_empty() const
{
    /* you complete this method */
     return size == 0;
}

/**
   * Generate a string representation of the list
   * Requires operator<< to be defined for the list's object type
   * @return string representation of the list
   */

string to_string() const
{
    if( size == 0 )
    {
      return "";
    }
    stringstream buffer;
    for( auto current = first; current != nullptr; current = current->next )
    {
      buffer << current->data << ' ';
    }
    return move( buffer.str() );
}

private:
uint size;
Node * first;
Node * last;
int count;
};

#endif

here is the test class:

#include <iostream>
#include <sstream>
#include <climits>
#include "lin_j_list.h"
using namespace std;

typedef unsigned int uint;

int main( int argc, char * argv [] )
{
if( argc != 2 )
{
    cerr << "Usage: " << argv[0] << " n where n is the number of elements" << endl;
    return 1;
}

stringstream ss( argv[ 1 ]); // get the command line parameter
uint n = 0;
ss >> n;

srand( time( NULL ));

cout << "starting to create l1 and l2" << endl;
List<uint> l1;
List<uint> l2;
for( uint i = 0; i < n; i++)
{
    uint value = rand() % UINT_MAX;

    l1.push_front( value );
    l2.push_front( value );
}

cout << "starting to construct l3 from l1" << endl;
List<uint> l3{ l1 };

cout << "starting to copy l1 onto l2" << endl;
l2 = l1;
cerr << n << " " << l2.get_count() << " " << l3.get_count() << endl;

return 0;
}

Explanation / Answer

Answer:-

#include<iostream>
#include<stdlib.h>
using namespace std;
int main()
{
   double g;
   double s;
   double w;
  
  
   cout << "Greetings, we will be calculation watts per mile per hour ";
  
  
   cout << "Insert Generator's name capacity in watts ";
   cin >> g;
  
   if (g < 300)
{
cout << "Nameplate capacity must be between 300 and 8,000,000 watts. ";
}
else if (g > 8,000,000)
{
cout << "Nameplate capacity must be less than 8,000,000. ";
}
   exit(-99);

   cout << "Insert today's average daily wind speed ";
   cin >> s;
  
   if (s < 0)
   {
       cout << "Wind speed must be greater than zero. ";
   }
   else if ((s >= 0) && (s < 6))
   {
       cout << "Wind speed is not sufficient to power the generator. ";
   }
   else if ((s >= 39) && (s <= 73))
   {
       cout << "Tropical storm wind speeds. Wind turbine not operating. ";
   }
   else if (s > 73)
   {
       cout << "TIme to buy a new wind turbine. ";
   }
}

Related Questions

Navigate

• Browse (All)
• Browse H
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.