not getting the desired output. WHY???

Once again I am having a problem. I am trying to do varoius operations with stacks. It doesn't look like it is filling the stack. I only tried to print the stack and print the second value so far. I saw that they were not working so I stopped even though I have written the other functions. It also sounds like I have a loop in the print2nd function. Any advice???

Code:

#include <iostream>
#include <cstdlib>
#include "stackType.h"
#include<fstream>

//function prototypes

void PrintStack(stack& s);
void Print2nd(stack& s);
void PrintBottom(stack& s );
void Palindrome(stack& s );

// declaring file stream variables

ifstream inData;
ofstream outData;


int main()
{
//declaration of variables
el_t element;
stack original;
const int SENTINEL = -999;
int c = 0;


//fills stack with at least 25 elements from an input file

   
    while((!original.StackIsFull() && element != SENTINEL))
    {
    inData>>element;
    original.Push(element);
    }
      
//Opening of files
inData.open("a:/stackinfo.txt");
outData.open("a:/stackoutput.txt");  

//Operations on Functions or Function Calls

outData<<"copy of stack is printed and original stack is unchanged"<<endl;
PrintStack(original);
outData<<"print 2nd element of stack"<<endl;
Print2nd(original);



//Close files
inData.close();
outData.close();


//  system("PAUSE");	
  return 0;
}

// Function to print all elements in a stack and leave stack unchanged 
// after printing
//Pre: The stack is non empty
//Post: 

void PrintStack(stack& s)
{
    el_t e;
    stack temp;
    
    while (!s.StackIsEmpty())
    {
        s.Pop(e);
        temp.Push(e);
        outData<<e;
    }
        while(!temp.StackIsEmpty())
        {
            temp.Pop(e);
            s.Push(e);
        }
}

//Function prints 2nd element from the stack and leaves stack unchanged
void Print2nd(stack& s)
{
    el_t e1, e2;
    
    while(!s.StackIsEmpty())
    {
        s.Pop(e1);
        s.Pop(e2);
        outData<<e2;
        s.Push(e2);
        s.Push(e1);
    }
}

//Function prints bottom of stack and leaves stack empty
void PrintBottom(stack& s )
{
    el_t e;
    stack temp;
    
    while(!s.StackIsEmpty())
    {
        s.Pop(e);
        temp.Push(e);
    }
    cout<<e;
}

//Function determines whether the characters form a palindrome
void Palindrome(stack& s )
{
    stack u,u2;
    el_t ch, ch1;
    bool equal = true;
    
    while(!s.StackIsEmpty())
    {
        s.Pop(ch);
        u.Push(ch);
        u2.Push(ch);
    }
        while(!u.StackIsEmpty())
        {
            u.Pop(ch);
            s.Push(ch);
        }
            while(!u2.StackIsEmpty() && equal)
            {
                 u2.Pop(ch);
                 s.Pop(ch1);
                   if (ch != ch1)
                       equal = false;
            }
                 if (equal)
                     cout<<"Palindrome"<<endl;
                          else
                             cout<<"Not a Palindrome"<<endl;
} //end of Palindrome Function

//  File: stackType.h        Class, constant values, and type definitions for c++ static
//  implementation of ADT stack.  This is the specification file for the class stack


#ifndef STACK_H
#define STACK_H

// application dependent size of stack
const unsigned int MAX_NUM_ELS = 256;

typedef char el_t;       // type varies with application
typedef int index_t;

class stack
{
    public:
        stack();                                //stack constructor
        ~stack();                               //stack deconstructor
        bool   StackIsEmpty(void);              //Is stack empty?
        bool   StackIsFull(void);               //Is stack full?
        void   Push(el_t);                      //push item
        void   Pop(el_t&);                      //pop to item
        
    private:
        void   StackError(char*);               //error handler
        index_t top;                            //top index: -1 if empty
        el_t   el[MAX_NUM_ELS];                 //container for elements
 };
 
 #endif
 
//  File: stackao.cpp  Contents: C++ source code for static
//  implementation of ADT stack.  This is the implementation file.
//

#include<iostream>
//#include<stdlib.h>
#include "stackType.h"

using namespace std;


//Default constructor
//Pre:  None
//Post: The stack object is initialized to be empty
//

stack::stack(void)
{
    top = -1;
}

//Stack destructor
//Pre: The stack has gone out of scope or an explicit call
//     to ~stack has occurred.
//Post: The stack is empty.

stack::~stack()
{
    top = -1;
}

//Boolean function that returns TRUE if the stack is empty
//Pre:  The stack has been initialized.
//Post: The function returns TRUE if the stack is empty, 
//      FALSE otherwise.

bool stack::StackIsEmpty(void)
{
    return (top == -1 ? true : false);
}

//Boolean function that returns TRUE if a stack is full
//Pre:  The sack has been initialized.
//Post:  The function has returned TRUE if the stack is full,
//       FALSE otherwise.

bool stack::StackIsFull(void)
{
    return (top == (MAX_NUM_ELS -1) ? true : false);
}

//Function to push an element onto a non_full stack
//Pre:  e is a data element of typr el_t.
//      The stack is not full.
//Post: If the stack was not full, e was placed on top of
//      the stack; otherwise StackError was called.

void stack::Push(el_t e)
{
    if ( StackIsFull())
        StackError("Stack is fulle\n");
    else
    {
        ++top;
        el[top] = e;
    }
}

//  Function to pop an element from a nonempty stack and
//  store it in the refernced variable
//  Pre:  The stack is  nonempty.
//  Post: The top stack element has been removed and stored
//        in e.  If the stack was empty, StackError was called.

void stack::Pop(el_t& e)
{
    if (StackIsEmpty())
        StackError(" Stack is empty \n");
    else
    {
        e = el[top];
        --top;
    }
}

//  Function to print an error message and abort the program
//Pre:  An unrecoverable error occurred.
//      ErrorMessage is an error message.
//Post: ErrorMessage has been output and the program aborted.

void stack::StackError( char* ErrorMessage)
{
    cerr<< ErrorMessage;
    exit(1);
}

I'm seeing areas that look problematic but I'll need to see some code from the stack class.

Code:

>//fills stack with at least 25 elements from an input file
>
>   
>    while((!original.StackIsFull() && element != SENTINEL))
>    {
>    inData>>element;
>    original.Push(element);
>    }
      
>//Opening of files
>inData.open("a:/stackinfo.txt");

You should open the input file before the while-loop, so:

Code:

//Opening of files
inData.open("a:/stackinfo.txt");
//fills stack with at least 25 elements from an input file

   
    while((!original.StackIsFull() && element != SENTINEL))
    {
    inData>>element;
    original.Push(element);
    }

I gave you stack functions a cursory glance, and didn't see any obvious problems.

You should also initialize element to something besides the value of SENTINEL, so it has some value the first time thru the while-loop:
el_t element = 0;

It looks like that's what you were doing with c here, but never used c.
int c = 0;

Code:

>//Function prints 2nd element from the stack and leaves stack unchanged
>void Print2nd(stack& s)
>{
>    el_t e1, e2;
>    
>    while(!s.StackIsEmpty())

This should be if instead of while:
    if(!s.StackIsEmpty())