堆栈实现的Queue Peek功能

Question

So I've looked around for this question, but still can't grasp what is going on.

A queue is implemented using two stacks, which I understand and all, but when it comes to the peek function, I just don't get how it works. For example,

template<class T>
T somethingsomething<T>::peek()
{
    T potato;

    if(outStack.isEmpty() == false)
    {
        potato = outStack.peek();
        return potato;
    }
    else
    {
        /* stuff stuff stuff*/
    }
}

After messing about, I found out this implementation works, but don't know why. when I do outStack.peek() , isn't this a recursive call to the function? What is going on in the code when I do this and why does it work?

Answer 1

There is no recursive call here, because the outStack must be an instance of of some class that implements a Stack , while somethingsomething is a class that implements a Queue using two Stacks. They cannot be the same class, and therefore the two methods called peek() refer to different methods of different classes, though they have the same name.

Answer 2

Peek generally means to peek the next character ie it returns the next character in the input sequence. Keep in mind that if any internal flag is set then it will return EOF(end of file). Consider the following example t understand peek function.

#include <iostream>
using namespace std;
int main(){

cout<<"Enter a number: ";


int n;
cin>>ws;
int c = cin.peek();

if(c == EOF){   //checking for end of file
    return 1;
}
if(isdigit(c)){
    cin>>n;
    cout<<"you entered: "<<n<<endl;
}

return 0;
}

So in your case, potato will return the next character from stack, you have to check it against flag and store it in variable and after that print it.