Question

Use C++!

This program uses the class myStack to determine the highest GPA from a list of students with their GPA.The program also outputs the names of the students who received the highest GPA.

Redo this program so that it uses the STL list and STL queue! Thank you!

HighestGPAData.txt*

3.4 Randy
3.2 Kathy
2.5 Colt
3.4 Tom
3.8 Ron
3.8 Mickey
3.6 Peter
3.5 Donald
3.8 Cindy
3.7 Dome
3.9 Andy
3.8 Fox
3.9 Minnie
2.7 Gilda
3.9 Vinay
3.4 Danny

highestGrade.cpp*

#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>

#include "myStack.h"

using namespace std;

int main()
{
   //Step 1
   double GPA;
   double highestGPA;
   string name;

   stackType<string> stack(100);

   ifstream infile;

   infile.open("HighestGPAData.txt"); //Step 2

   if (!infile) //Step 3
   {
       cout << "The input file does not "
           << "exist. Program terminates!"
           << endl;
       return 1;
   }

   cout << fixed << showpoint; //Step 4
   cout << setprecision(2); //Step 4

   infile >> GPA >> name; //Step 5

   highestGPA = GPA; //Step 6

   while (infile) //Step 7
   {
       if (GPA > highestGPA) //Step 7.1
       {
           stack.initializeStack(); //Step 7.1.1

           if (!stack.isFullStack()) //Step 7.1.2
               stack.push(name);

           highestGPA = GPA; //Step 7.1.3
       }
       else if (GPA == highestGPA) //Step 7.2
           if (!stack.isFullStack())
               stack.push(name);
           else
           {
               cout << "Stack overflows. "
                   << "Program terminates!"
                   << endl;
               return 1; //exit program
           }
       infile >> GPA >> name; //Step 7.3
   }

   cout << "Highest GPA = " << highestGPA
       << endl; //Step 8
   cout << "The students holding the "
       << "highest GPA are:" << endl;

   while (!stack.isEmptyStack()) //Step 9
   {
       cout << stack.top() << endl;
       stack.pop();
   }

   cout << endl;

   return 0;
}

myStack.h*

#pragma once
//Header file: myStack.h

#ifndef H_StackType
#define H_StackType

#include <iostream>
#include <cassert>

#include "stackADT.h"

using namespace std;

template <class Type>
class stackType : public stackADT<Type>
{
public:
   const stackType<Type>& operator=(const stackType<Type>&);
   //Overload the assignment operator.

   void initializeStack();
   //Function to initialize the stack to an empty state.
   //Postcondition: stackTop = 0

   bool isEmptyStack() const;
   //Function to determine whether the stack is empty.
   //Postcondition: Returns true if the stack is empty,
   // otherwise returns false.

   bool isFullStack() const;
   //Function to determine whether the stack is full.
   //Postcondition: Returns true if the stack is full,
   // otherwise returns false.

   void push(const Type& newItem);
   //Function to add newItem to the stack.
   //Precondition: The stack exists and is not full.
   //Postcondition: The stack is changed and newItem
   // is added to the top of the stack.

   Type top() const;
   //Function to return the top element of the stack.
   //Precondition: The stack exists and is not empty.
   //Postcondition: If the stack is empty, the program
   // terminates; otherwise, the top element
   // of the stack is returned.

   void pop();
   //Function to remove the top element of the stack.
   //Precondition: The stack exists and is not empty.
   //Postcondition: The stack is changed and the top
   // element is removed from the stack.

   stackType(int stackSize = 100);
   //constructor
   //Create an array of the size stackSize to hold
   //the stack elements. The default stack size is 100.
   //Postcondition: The variable list contains the base
   // address of the array, stackTop = 0, and
   // maxStackSize = stackSize.

   stackType(const stackType<Type>& otherStack);
   //copy constructor

   ~stackType();
   //destructor
   //Remove all the elements from the stack.
   //Postcondition: The array (list) holding the stack
   // elements is deleted.

private:
   int maxStackSize; //variable to store the maximum stack size
   int stackTop; //variable to point to the top of the stack
   Type *list; //pointer to the array that holds the
                   //stack elements

   void copyStack(const stackType<Type>& otherStack);
   //Function to make a copy of otherStack.
   //Postcondition: A copy of otherStack is created and
   // assigned to this stack.
};

template <class Type>
void stackType<Type>::initializeStack()
{
   stackTop = 0;
}//end initializeStack

template <class Type>
bool stackType<Type>::isEmptyStack() const
{
   return(stackTop == 0);
}//end isEmptyStack

template <class Type>
bool stackType<Type>::isFullStack() const
{
   return(stackTop == maxStackSize);
} //end isFullStack

template <class Type>
void stackType<Type>::push(const Type& newItem)
{
   if (!isFullStack())
   {
       list[stackTop] = newItem; //add newItem to the
                                   //top of the stack
       stackTop++; //increment stackTop
   }
   else
       cout << "Cannot add to a full stack." << endl;
}//end push

template <class Type>
Type stackType<Type>::top() const
{
   assert(stackTop != 0); //if stack is empty,
                                   //terminate the program
   return list[stackTop - 1]; //return the element of the
                                   //stack indicated by
                                   //stackTop - 1
}//end top

template <class Type>
void stackType<Type>::pop()
{
   if (!isEmptyStack())
       stackTop--; //decrement stackTop
   else
       cout << "Cannot remove from an empty stack." << endl;
}//end pop

template <class Type>
stackType<Type>::stackType(int stackSize)
{
   if (stackSize <= 0)
   {
       cout << "Size of the array to hold the stack must "
           << "be positive." << endl;
       cout << "Creating an array of size 100." << endl;

       maxStackSize = 100;
   }
   else
       maxStackSize = stackSize; //set the stack size to
                                   //the value specified by
                                   //the parameter stackSize

   stackTop = 0; //set stackTop to 0
   list = new Type[maxStackSize]; //create the array to
                                   //hold the stack elements
}//end constructor

template <class Type>
stackType<Type>::~stackType() //destructor
{
   delete[] list; //deallocate the memory occupied
                   //by the array
}//end destructor

template <class Type>
void stackType<Type>::copyStack(const stackType<Type>& otherStack)
{
   delete[] list;
   maxStackSize = otherStack.maxStackSize;
   stackTop = otherStack.stackTop;

   list = new Type[maxStackSize];

   //copy otherStack into this stack
   for (int j = 0; j < stackTop; j++)
       list[j] = otherStack.list[j];
} //end copyStack

template <class Type>
stackType<Type>::stackType(const stackType<Type>& otherStack)
{
   list = nullptr;

   copyStack(otherStack);
}//end copy constructor

template <class Type>
const stackType<Type>& stackType<Type>::operator=
(const stackType<Type>& otherStack)
{
   if (this != &otherStack) //avoid self-copy
       copyStack(otherStack);

   return *this;
} //end operator=   

#endif

Answer 1

Answer

#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>
#include <list>        //include the list STL
using namespace std;

int main()
{
   //Step 1
double GPA;
double highestGPA;
string name;
list<string> gradelist;   //create a list of strings to store the names of students with highest GPA

   ifstream infile;
   infile.open("HighestGPAData.txt"); //Step 2
   if (!infile) //Step 3
{
cout << "The input file does not " << "exist. Program terminates!" << endl;
return 1;
}

   cout << fixed << showpoint; //Step 4
   cout << setprecision(2); //Step 4
   infile >> GPA >> name; //Step 5 read the first GPA and name from the input file
   highestGPA = GPA; //Step 6 assign the GPA as highestGPA

   while (infile) //Step 7 when file is not empty
{
if (GPA > highestGPA) //Step 7.1
{
        gradelist.clear();           //clear the previous list
        gradelist.push_front(name);   //push the name at the front of the list
        highestGPA = GPA;           //assign the GPA as highestGPA
   }
   else if (GPA == highestGPA) //Step 7.2
   {
          gradelist.push_front(name);   //push the name at the front of the list
   }
       infile >> GPA >> name; //Step 7.3 read the next GPA and name from the input file
   }

       cout << "Highest GPA = " << highestGPA << endl; //Step 8 display the highest GPA
       cout << "The students holding the " << "highest GPA are:" << endl;
       while (!gradelist.empty())
       {
   cout << gradelist.front() << endl;   //display name of students with highest GPA
   gradelist.pop_front();
   }
   cout << endl;
   return 0;
}

highestgrade.cpp 1 #include <iostream» #include <10man!p> 3 #include <fstream> <string> #include //include the list STL 5 #include <list> 6 using namespace std; 8 int main() 9 //Step 1 double GPA; double highestGPA string name; list<string> gradelist; //create a list of strings to store the names of students with highest GPA 10 12 13 14 15 16 ifstream infile; infile.open ("HighestGPAData.txt"); //Step 2 if (linfile) //Step 3 18 cout << "The input file does not "<< "exist. Program terminates!" << endl; return 1; 19 20 21

highestgrade.cpp 23 cout << fixed << showpoint; //Step 4 cout << setprecision(2); //step 4 infile > GPA > name; //Step 5 read the first GPA and name from the input file highestGPA GPA //Step 6 assign the GPA as highestGPA 24 25 26 28 while (infile) //Step 7 when file is not empty 29 30 İf (GPA 〉 highestGPA) //Step 7.1 32 gradelist.clear; gradelist.push_front(name); //push the name at the front of the list highestGPAGPA; //clear the previous list //assign the GPA as highestGPA 35 36 else if (GPA == highestGPA) //Step 7.2 gradelist.push_front(name); //push the name at the front of the list 40 infile > GPA > name; //Step 7.3 read the next GPA and name from the input file 42 43 cout << "Highest GPA-" << highestGPA << endl; //Step 8 display the highest GPA cout << "The students holding the "<<"highest GPA are:" << endl: 45

10 infile >GPA >name; //Step 7.3 read the next GPA and name from the input file cout<"Highest GPA -"<< highestGPA << endl; //Step 8 display the highest GPA cout << "The students holding the " 〈〈 "highest GPA are :" endl; while (!gradelist.empty)) 14 15 16 17白 cout << gradelist.front() くく endl; //display name of students with highest GPA gradelist.pop_front); 18 19 cout << endl; return e; 52 3

Output

D:cppprog Basic c programs Vhighestgrade.exe Highest GPA 3.90 The students holding the highest GPA are inay Minnie Andy Process exited after 0.4919 seconds with returnvalue 0 Press any key to continue -. _