Hello dear, I have the below program trying to create a PostFix calculator using

Question

Hello dear,

I have the below program trying to create a PostFix calculator using a compantiontion of defined stack and queue but sadly I don't understand how to finish it. Your help is so much appreciated, Peter

#include <iostream>
#include <sstream>
#include <iomanip>
#include <string>
#include <cstdlib>
#include <cmath>
#include <stack>
#include <queue>
#include <cctype>

using namespace std;

template <class T>
struct Node
{
T value; // The value in this node
Node *next; // To point to the next node
};

template<class T>
class Combo
{
private:
int count;
Node<T> *head; // List head pointer
  
public:
  
// Constructor
Combo() { head = nullptr; count = 0; }
  
// Destructor
~Combo() {
Node<T> *p = head;
while(p) { delete p; p = p->next; }
}
  
void insert(T); // ref. for push_front
void remove(T); // ref. for pop_front and pop_back
void display() const;
string toString();
  
// The new ones
T front(); // Read front
T back(); // Read back
void push_front(T);
void push_back(T);
void pop_front();
void pop_back();
int size() { return count; }
  
};

// Read front
template <class T>
T Combo<T>::front()
{
if(count>0)
return head->value;
  
else return 0;
}

// Read back
template <class T>
T Combo<T>::back()
{
Node<T> *newNode = head;
  
if(newNode == nullptr)
return 0;
  
while(newNode->next != nullptr)
{
newNode = newNode->next;
}
return newNode->value;
}

// Insert in the front!
template <class T>
void Combo<T>::push_front(T newValue)
{
Node<T> *newNode = new Node<T>;
  
newNode->value = newValue;
newNode->next = head;
  
head = newNode;
  
count++;
}

// Append!
template <class T>
void Combo<T>::push_back(T newValue)
{
Node<T> *newNode = head;
Node<T> *appendNode = new Node<T>;
appendNode->value = newValue;
appendNode->next = nullptr;
  
if(newNode == nullptr)
{
newNode = new Node<T>;
newNode->value = newValue;
}
else
{
while(newNode->next != nullptr)
{
newNode = newNode->next;
}
newNode->next = appendNode;
}
count++;
}

// Remove front
template <class T>
void Combo<T>::pop_front()
{
if(count>0)
{
T value = front();
remove(value);
}
}

// Remove back
template <class T>
void Combo<T>::pop_back()
{
if(count>0)
{
T value = back();
remove(value);
}
}

template<class T>
void Combo<T>::insert(T num) {
Node<T> *newNode, *p, *prev=nullptr;
newNode = new Node<T>;
newNode->value = num;
newNode->next = nullptr;
  
// if(head == nullptr)
if(!head) { // empty list
head = newNode;
count++;
}
else {
p = head;
while( p != nullptr && p->value < num) {
prev = p;
p = p->next;
}
  
// p must be pointing to the first bigger, or end
if(prev==nullptr) { // the first one is the last one.
head = newNode;
newNode->next = p;
}
else {
prev->next = newNode;
newNode->next = p;
}
count++;
}
}

template<class T>
void Combo<T>::remove(T num) {
Node<T> *p, *prev = nullptr;
if(!head) return;
if(head->value == num) {
p = head->next;
delete head;
head = p;
count--;
}
else {
p = head;
// skip all NOTs
while( p != nullptr && p->value != num ) {
prev = p;
p = p->next;
}
if(p) {
prev->next = p->next;
delete p;
count--;
}
}
}

template<class T>
void Combo<T>::display() const {
Node<T> *p = head;

while(p->next) {
cout << p->value << ", ";
p=p->next;
}
cout << p->value << endl;
}

template<class T>
string Combo<T>::toString() {
stringstream ss;
Node<T> *p = head;
bool first = true;
while(p) {
if (first) first = !first;
else ss << ", ";
ss << p->value;
p = p->next;
}
  
return ss.str();
}

int calc(char op, int num1, int num2) {
int result;
switch(op) {
case '*': result = num1 * num2; break;
case '/': result = num1 / num2; break;
case '+': result = num1 + num2; break;
case '-': result = num1 - num2; break;
case '^': result = pow(num1, num2); break;
}
return result;
}

int main()
{
string postfix;
  
cout << "Enter a valid postfix expression: ";
getline( cin, postfix );
  
Combo<char> postfixQueue;
for( auto item:postfix )
postfixQueue.push_back(item);
  
Combo<char> stk;
int num1, num2, result;
while( !postfixQueue.empty() ) {
char token = postfixQueue.front();
if( isalnum(token) ) {
stk.push( token - '0' );
postfixQueue.pop_front();
}
else if( token == '+' || token == '-' ||
token == '*' || token == '/' ) {
postfixQueue.pop_front();
num2 = stk.top(); stk.pop();
num1 = stk.top(); stk.pop();
result = calc( token, num1, num2 );
stk.push(result);
cout << num1 << token << num2 << endl;
}
}
  
return 0;
}

Explanation / Answer

stack header file

#ifndef STACK_H
#define STACK_H

template <class T>
class Stack
{
public:
Stack(int = 10);
~Stack();
void push(const T&);
T pop();
bool empty() const {return top == -1;}
private:
int size;
int top;
T* stack;
bool isFull() const {return top == size -1;}
};

template<class T>
Stack<T>::Stack(int s)
{
size = 10; // i made the assumption the size was 10 based on the output.
top = -1;
stack = new T[size];
}

template<class T>
Stack<T>::~Stack()
{
if (stack != NULL)
delete[] stack;
}

template<class T>
void Stack<T>::push(const T& pushValue)
{
if(!isFull())
{
stack[++top] = pushValue;
}
}

template<class T>
T Stack<T>::pop()
{
return stack[top--];
}

#endif

The main function

#include<iostream>
#include<string>
#include "stack.h"

using namespace std;

int main()
{
char decision, operation;
char space = ' ';
int number1, number2;
do
{
cout << "Please enter 1 to continue with the posfix operations. 2 will end the program: ";
cin >> decision;
cout << ("Please enter a postfix expression: ") << endl;
cin >> number1, space, number2, space, operation;

Stack<int> operations(10);
  
switch(operation)
{
case '+':
number1 = operations.pop();
number2 = operations.pop();
operations.push(number2 + number1);
break;
  
case '-':
number1 = operations.pop();
number2 = operations.pop();
operations.push(number2 - number1);
break;
  
case '*':
number1 = operations.pop();
number2 = operations.pop();
operations.push(number2 * number1);
break;
  
case '/':
number1 = operations.pop();
number2 = operations.pop();
operations.push(number2 / number1);
break;
  
default:
cout << "This operation is invalid";
}
}while (decision == 1);
  
system("Pause");
  
}

Related Questions

Navigate

• Browse (All)
• Browse H
• Subjects

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