How to implement pop for a stack as an array program? - c++

Question

Hi I am having trouble implementing a simple pop function for a stack as an array program. The code is below and I am not sure how to fix it.
I am not sure about all the possible cases, so if you could just advise me then I would greatly appreciate!
#include "Exception.h"
template <typename Type>
class Drop_off_stack_as_array {
private:
int itop;
int ibottom;
int entry_count;
int array_capacity;
Type *array;
public:
Drop_off_stack_as_array( int = 10 );
Drop_off_stack_as_array( Drop_off_stack_as_array const & );
~Drop_off_stack_as_array();
int size() const;
bool empty() const;
Type top() const;
bool full() const;
void swap( Drop_off_stack_as_array & );
Drop_off_stack_as_array &operator = ( Drop_off_stack_as_array );
void push( Type const & );
Type pop();
void clear();
// Friends
template <typename T>
friend std::ostream &operator << ( std::ostream &, Drop_off_stack_as_array<T> const & );
};
template <typename Type>
Drop_off_stack_as_array<Type>::Drop_off_stack_as_array( int n ):
itop(0),
ibottom(0),
entry_count(0),
array_capacity(n),
array(new Type[array_capacity]){
//empty constructor
}
template <typename Type>
Drop_off_stack_as_array<Type>::Drop_off_stack_as_array( Drop_off_stack_as_array<Type> const &stack ):
itop( stack.itop ),
ibottom( stack.ibottom ),
entry_count( stack.entry_count ),
array_capacity( array_capacity ),
array( new Type[array_capacity] ) {
// The above initializations copy the values of the appropriate
// member variables and allocate memory for the data structure;
// however, you must still copy the stored objects.
for(int i = 0; i<array_capacity; i++){
array[i] = stack.array[i];
}
}
template <typename Type>
Drop_off_stack_as_array<Type>::~Drop_off_stack_as_array() {
delete[] array;
}
template <typename Type>
int Drop_off_stack_as_array<Type>::size() const {
return entry_count;
}
template <typename Type>
bool Drop_off_stack_as_array<Type>::full() const {
return (entry_count == array_capacity);
}
template <typename Type>
bool Drop_off_stack_as_array<Type>::empty() const {
return (entry_count == 0);
}
template <typename Type>
Type Drop_off_stack_as_array<Type>::top() const {
if(empty()){
throw underflow();
}
return array[itop];
}
template <typename Type>
void Drop_off_stack_as_array<Type>::swap( Drop_off_stack_as_array<Type> &stack ) {
std::swap( itop, stack.itop );
std::swap( ibottom, stack.ibottom );
std::swap( entry_count, stack.entry_count );
std::swap( array_capacity, stack.array_capacity );
std::swap( array, stack.array );
}
template <typename Type>
Drop_off_stack_as_array<Type> &Drop_off_stack_as_array<Type>::operator = ( Drop_off_stack_as_array<Type> rhs ) {
swap( rhs );
return *this;
}
template <typename Type>
void Drop_off_stack_as_array<Type>::push( Type const &obj ) {
if(full()){
array[ibottom] = 0;
itop = ibottom;
++ibottom;
}
else{
array[itop+1] = obj;
++itop;
++entry_count;
}
}
template <typename Type>
Type Drop_off_stack_as_array<Type>::pop() {
if(empty()){
throw underflow();
}
array[itop] = 0;
--itop;
--entry_count;
}
template <typename Type>
void Drop_off_stack_as_array<Type>::clear() {
delete [] array;
array = new Type(array_capacity);
}

Answer 1

Maybe something like this:
template <typename Type>
Type Drop_off_stack_as_array<Type>::pop() {
if(empty()){
throw underflow();
}
Type result = array[itop]; // Safe a copy of the top element
array[itop] = 0;
--itop;
--entry_count;
return result; // return it (your return type is not void,
// so you need a return statment which returns a value
}
What is strange in your code (and not just in this place) is the = 0 and what you are doing with the itop and ibottom counters/indices/...? But I guess that is another question waiting, your immediate problem is hopefully solved with the above.
(And next time at least include the error message/warning you get in the question, thanks!)

Answer 2

When you write template stack for class T, the class T can be an object and not primitive.
Also, you should not assume that class T has empty constructor, since it is enough for you copy constructor only.
Also, after element popped from stack, you have to release resources. In order to do so, you call destructor.
Please see the example implemented this:
code:
#include <new>
template<typename T>
class stack {
private:
int itop; // points to first free
int size; // maximal capacity
T * array; // memory for data
public:
stack(int n) : itop(0), size(n) {
array = (T *)(new char [sizeof(T) * n]);
}
~stack() {
delete [] (char *)array;
}
void push(const T &obj) {
if (itop < size) {
new (&array [ itop ++ ]) T(obj);
} else {
// error, stack is full
}
}
void pop() {
if (itop > 0) {
array[-- itop] . ~ T();
} else {
// error, stack is empty
}
}
const T &top () {
if (itop > 0) {
return array[( itop - 1)];
} else {
// error, stack is empty
}
}
};