RN Calculator with Stacks

[Halken]

I am in need of help with my stack::peek function, I plan on calling the peek function at the end to display the correct result however I am a little lost regarding the programming required. any help is appreciated.

  #include <iostream>
#include <string>
#include <sstream>
#include <iomanip>
using namespace std;

struct NODE
{
    float num;
    NODE *next;
};

class stack
{
  private:
    NODE *head;

  public:
    stack();
    void push(float);
    float pop();
    int nElements();
    float display();
};

class RPN : public stack
{
  public:
    void add();
    void subtract();
    void multiply();
    void divide();
};

stack::stack()
{
    head = NULL;
}

void stack::push(float a_number)
{
    NODE *temp = new NODE;
    if (temp)
    {
        temp->num = a_number;
        temp->next = head;
        head = temp;
    }
}

float stack::pop()
{
    float number = 0;

    if (!head)
    {
        return 0;
    }
    else
    {
        NODE *temp = head;
        number = head->num;
        head = temp->next;
        delete temp;
    }
    return number;
}

float stack::peek()
{
    float min = 0;

    if (!head)
    {
        return 0;
    }
    else
    {
        NODE *temp >> head;
        min << head->num;
        head << temp->next;
        delete temp;
    }
    return min;
}

int stack::nElements()
{
    int counter = 0;
    for (NODE *node = head; node; node = node->next)
    {
        counter++;
    }
    return counter;
}

float stack::display()
{

    if (nElements() > 0)
    {
        float temp = pop();
        //  cout << temp << "= temp, nElements()= " << nElements() << endl;
        push(temp);

        return temp;
    }
}

void RPN::add()
{
    if (nElements() >= 2)
    {
        push(pop() + pop());
    }
}

void RPN::subtract()
{
    if (nElements() >= 2)
    {
        push(0 - pop() + pop());
    }
}

void RPN::multiply()
{
    if (nElements() >= 2)
    {
        push(pop() * pop());
    }
}

void RPN::divide()
{
    if (nElements() >= 2)
    {
        //if(pop() * pop() == 0)
        // {
        //cout << "Error: Divide by 0.\n";
        // }

        push(1 / pop() * pop());
    }

    //else if( nElements()>=2)
    // {
    //	 cout << "Error: Divide by 0.\n";
    //}
}

//Function prototype for isOperator
bool isOperator(const string &input);

//Function prototype for perforOperation
int performOperation(const string &input, RPN &calculator);

int main()
{

    RPN calculator;

    float num;
    string line;
    while (getline(cin, line))
    {
        stringstream expression(line);
        string input;
        while (expression >> input)
        {
            if (istringstream(input) >> num)
            {
                //use push function
                calculator.push(num);
            }

                // check for operator
            else if (isOperator(input))
            {
                performOperation(input, calculator);
            }
        }
    }
}

bool isOperator(const string &input)
{
    static const string operators = "-+*/";
    if (input.length() == 1) 
    {
        return operators.find_first_of(input[0]) != string::npos;
    }
    return false;
}

int performOperation(const string &input, RPN &calculator)
{
    switch (input[0])
    {
    case '+':
        calculator.add();
        calculator.display();
        break;
    case '-':
        calculator.subtract();
        calculator.display();
        break;
    case '*':
        calculator.multiply();
        calculator.display();
        break;
    case '/':
        calculator.divide();
        calculator.display();
        break;
    case '0':
        return 0;
    }
    calculator.peek()
    return 0;
}

[jonnin]

peek just prints (or returns?) what is in the stack, either the topmost guy, all the guys, or at a specific depth, whatever you need ... the classic is the topmost value.

the topmost value returned (is zero appropriate ?!) if any simple version:

float stack::peek()
{
    if (!head) 
        return 0;
       return head->num;
}

that is, peek should not modify the stack at all -- the traditional use of this word for a method means 'look but do not touch'. if you touch it, that is a 'poke' (not used as much anymore).

I dont like returning zero here. Its a valid value, but you don't know the stack was empty. I think that is going to make bugs for you if you are not careful.

I found the winx calc so bad I wrote one too.. did mine with just a circular buffer for the 'stack' so mine is really nothing more than just the switch statement bodies as a monolith in main, nothing fancy.

[Halken]

thanks :)