OK, as I've explained to you what a stack is and how it works on a conceptual level, let's get started.

This will be quite detailed and I'm more or less explaining each line of the code.  So don't freak out; just take it line by line and barring any syntax errors the program will work fine.  In total this will be about 44 lines of code.


We will use this to learn about string parsing and error checking eventually.  However we will start very simply.

Let's call it rpncalc.c.  You will almost certainly only need stdio.h.
Create a global variable named stack, which is an array of 5 int, and another global named stkptr (short for stack pointer) which is an int.
Prototype two functions:
void push(int p);
int pop();

In main:
- define an input buffer of 256 char;
- define an int named quit, initialised to zero;
- initialise stkptr to zero;
- then enter a while or for loop with !quit as the test.

In that loop, display the prompt "RPNCALC> " without a newline, then read a line from the user into the input buffer using:
fgets(buffer name, length of buffer, stdin);

We won't use scanf, for two reasons: (1) scanf is a piece of shit that should be avoided at all costs; (2) we don't actually know what type of data the user is going to enter, so we'll have to get something in, then parse it to find out what it is.

(I think people like talking about scanf because it's the logical converse of printf, and probably we would need to get input from the user before tackling string parsing.  However, users rarely enter formatted data correctly; they like to enter loads of errors, and if they do that to scanf it'll feck up your program.  So we use fgets instead.)

We'll keep this very simple to start with.  Use a switch statement to check the first character of the buffer.  (Don't forget we're still inside the !quit loop.)

If it's 'q', set quit to 1.

If it's '.', display the return value of pop().

Otherwise, assume it's an integer, so call push() with the return value of atoi() which itself takes the input buffer as the parameter.
Even though we don't technically need a break statement on this last one, put one in anyway because it's good practice.
Close the switch statement, the !quit loop and main with a } each, giving you a nice cascading:
........}
....}
}
(dots only in there because leading spaces would probably be removed)

As I've already given you quite a lot to do here, I'll just get you started with push() and pop():

void push(int p)
{
  stack[stkptr++]=p;
}

int pop()
{
  return stack[--stkptr];
}


That's all for this step.  All being well it will compile and run.  If it doesn't, keep a cool head and check the errors one by one.  If you get hundreds of errors, don't panic because you always only ever need to look at the first few.  If you're stuck, post me the code and the error messages.  By the way, with gcc it's good practice to use -Wall to get full error checking, and to make sure the program compiles without any warnings.  So these are two very good habits to get into from the start.  I might set up a Linux VM for giggles and check your code with gcc -Wall.

Note that currently there is NO error checking.  So don't try to "." on an empty stack, or push more than 5 integers onto the stack.  Well, you can, it might be interesting.  It won't break your computer.  You might get a core dump.  We'll add error checking later but this is enough for now.

(If you've heard of "buffer overflow" bugs, usually in a security context, popping off an empty stack or pushing onto a full stack are both examples of that.  Popping off an empty stack is also called "underflow" as a logical opposite of overflow).

When it runs, try adding some numbers to the stack and displaying them.  When you've had enough, "q" to exit and send me the code.

Dave