Here is my code and input file information. I must print out the highest GPA. Th
ID: 3681649 • Letter: H
Question
Here is my code and input file information. I must print out the highest GPA. Then print to screen the first name, last name, and classification of the students with the highes GPA.
#ifndef H_StackADT
#define H_StackADT
template <class Type>
class stackADT
{
public:
virtual void initializeStack() = 0;
//Method to initialize the stack to an empty state.
//Postcondition: Stack is empty.
virtual bool isEmptyStack() const = 0;
//Function to determine whether the stack is empty.
//Postcondition: Returns true if the stack is empty,
// otherwise returns false.
virtual bool isFullStack() const = 0;
//Function to determine whether the stack is full.
//Postcondition: Returns true if the stack is full,
// otherwise returns false.
virtual void push(const Type& newItem) = 0;
//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.
virtual Type top() const = 0;
//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.
virtual void pop() = 0;
//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.
};
#endif
****************************************************************************************
#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 = NULL;
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
****************************************************************************************
#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>
#include "myStack.h"
using namespace std;
int main()
{
//Step 1
double GPA;
double highestGPA;
string fname;
string lname;
string classification;
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 >> fname >> lname >> classification; //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(fname);
highestGPA = GPA; //Step 7.1.3
}
else if (GPA == highestGPA) //Step 7.2
if (!stack.isFullStack())
stack.push(fname);
else
{
cout << "Stack overflows. "
<< "Program terminates!" << endl;
return 1; //exit program
}
infile >> GPA >> fname >> lname >> classification; //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;
}
**************************************************************************************************************************************************
//input text file (HighestGPAData.txt)
3.4 Randy Travis Senior
3.2 Kathy Bates Freshman
2.5 Colt James Freshman
3.4 Tom Hannks senior
3.8 Ron Johnson sophmore
3.8 Mickey Mouse Junior
3.6 Peter Pan Sophmore
3.5 Donald Duck Junior
3.8 Cindy Crawford Senior
3.7 Dome Ron Junior
3.9 Andy Simmons Sophmore
3.8 Fox Brown freshman
3.9 Minnie Mouse senior
2.7 Gilda Frank Junior
3.9 Vinay low Junior
3.4 Danny Ward Senior
**********************************************************************************************************************************************************************
problem : I can only print out the highest GPA and the students first name with the highest GPA.
output should look like this:
Highest GPA = 3.90
The students holding the highest GPA are:
Vinay Low Junior
Minnie Mouse senior
Andy Simmons Sophmore
Explanation / Answer
Hi have corrected your code. Please test and give me feedback.
stackADT.h and myStack.h will be same.
#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>
#include "myStack.h"
using namespace std;
int main()
{
//Step 1
double GPA;
double highestGPA;
string fname;
string lname;
string classification;
// declaring three stack to store three type of information
stackType<string> firstNameStack(100);
stackType<string> lastNameStack(100);
stackType<string> classificationStack(100);
ifstream infile;
infile.open("HighestGPAData.txt");
if (!infile)
{
cout << "The input file does not "
<< "exist. Program terminates!" << endl;
return 1;
}
// first find higest GPA
infile >> GPA >> fname >> lname >> classification;
highestGPA = GPA;
while (infile)
{
if (GPA > highestGPA)
{
highestGPA = GPA;
}
infile >> GPA >> fname >> lname >> classification;
}
infile.close(); // closing file
// Again opening file
infile.open("HighestGPAData.txt");
cout << fixed << showpoint;
cout << setprecision(2);
while (infile >> GPA >> fname >> lname >> classification)
{
if(GPA == highestGPA){
if (!firstNameStack.isFullStack()){
firstNameStack.push(fname);
lastNameStack.push(lname);
classificationStack.push(classification);
}
else
{
cout << "Stack overflows. "
<< "Program terminates!" << endl;
return 1; //exit program
}
}
}
cout<< "Highest GPA = " << highestGPA << endl;
cout<< "The students holding the "<< "highest GPA are:" << endl;
while (!firstNameStack.isEmptyStack())
{
cout << firstNameStack.top()<<" "<< lastNameStack.top()<<" "<<classificationStack.top()<< endl;
firstNameStack.pop();
lastNameStack.pop();
classificationStack.pop();
}
cout << endl;
infile.close();
return 0;
}
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.