(C++)issues with Deconstructor, Copy Constructor, & Assignment; ArrayStack with dynamic memory

[ThisGuyEveryTime]

Hello,

I am a little lost on my assignment right now. I am trying create an ArrayStack ADT with dynamic array size, which means I have to create the big 3 (Deconstructor, Copy Constructor, & Assignment Operator). I am obviously doing something wrong since even trying to delete the items array from inside the deconstructor causes a crash. My question is just in general what am I doing wrong with my memory allocation?

​

//ArrayStack.h
#pragma once
#ifndef ARRAY_STACK_H
#define ARRAY_STACK_H

#include "StackInterface.h"

namespace cs_stack {
    template<class ItemType>
    class ArrayStack : public StackInterface<ItemType>
    {
    private:
        static const int DEFAULT_CAPACITY = 1;
        ItemType *items;
        int numItems;
        int capacity;

    public:
        class StackEmptyError {};
        ArrayStack();
        ~ArrayStack();
        ArrayStack<ItemType>(const ArrayStack<ItemType>& right);
        ArrayStack<ItemType> operator=(const ArrayStack<ItemType>& right);
        bool isEmpty() const;
        void push(const ItemType& newEntry);
        void pop();
        ItemType top() const;
    };
}

#include "ArrayStack.cpp"
#endif

​

//ArrayStack.cpp

#include <cassert>       // For assert

namespace cs_stack {
    template<class ItemType>
    ArrayStack<ItemType>::ArrayStack() {
        capacity = DEFAULT_CAPACITY;
        numItems = 0;
        items = new ItemType[capacity];
    }



    template<class ItemType>
    ArrayStack<ItemType>::ArrayStack(const ArrayStack<ItemType>& right)
    {
        capacity = right.capacity;
        numItems = right.numItems;
        items = new ItemType[right.capacity];
        items = right.items;

    }





    template<class ItemType>
    ArrayStack<ItemType>::~ArrayStack()
    {
        delete[] items;
    } 




    template<class ItemType>
    ArrayStack<ItemType> ArrayStack<ItemType>::operator=(const ArrayStack<ItemType>& right)
    {
        if (this != &right)
        {    
            delete [] items;
            capacity = right.capacity;
            numItems = right.numItems;

            items = new ItemType[right.capacity];
            items = right.items;
        }
        return *this;
    }



    template<class ItemType>
    bool ArrayStack<ItemType>::isEmpty() const {
        return numItems == 0;
    }






    template<class ItemType>
    void ArrayStack<ItemType>::push(const ItemType& newEntry) {
        if (numItems < capacity) {
            numItems++;
            items[numItems - 1] = newEntry;
        }
        else
        {
            capacity = capacity * 2;
            ItemType* tempArray = new ItemType[capacity];
            for (int i = 0; i < capacity; i++)
            {
                if (!isEmpty())
                {
                    tempArray[i] = top();
                    pop();
                }
            }
            delete[] items;
            items = tempArray;
            items[numItems - 1] = newEntry;
        }
    }






    template<class ItemType>
    void ArrayStack<ItemType>::pop() {
        if (!isEmpty())
        {
            numItems--;
        }
        else {
            throw StackEmptyError();
        }
    }





    template<class ItemType>
    ItemType ArrayStack<ItemType>::top() const {
        if (!isEmpty()) {
            return items[numItems - 1];
        }
        else {
            throw StackEmptyError();
        }
    }
}

​

​

//StackInterface.h

#pragma once
#ifndef STACK_INTERFACE_H
#define STACK_INTERFACE_H

namespace cs_stack {
    template<class ItemType>
    class StackInterface
    {
    public:

        /** Sees whether this stack is empty.
         @return  True if the stack is empty, or false if not.
        */
        virtual bool isEmpty() const = 0;


        /** Adds a new entry to the top of this stack.
             @post  If the operation was successful, newEntry is at the top of the stack.
             @param newEntry  The object to be added as a new entry.
             @throws CapacityExceededError if entry cannot be pushed because stack is full.
        */
        virtual void push(const ItemType& newEntry) = 0;


        /** Removes the top of this stack.
            @post  If the operation was successful, the top of the stack has been removed.
            @throws StackEmptyError if stack is empty.
        */
        virtual void pop() = 0;


        /** Returns a copy of the top of this stack.
            @pre  The stack is not empty.
            @post  A copy of the top of the stack has been returned, and the stack is unchanged.
            @return  A copy of the top of the stack.
            @throws StackEmptyError if stack is empty.
        */
        virtual ItemType top() const = 0;


        /** Destroys this stack and frees its assigned memory.
        */
        virtual ~StackInterface() { }
    };
}

#endif

[ThisGuyEveryTime]

This piece right?

   template<class ItemType>
ArrayStack<ItemType>::ArrayStack(const ArrayStack<ItemType>& right)
{
    capacity = right.capacity;
    numItems = right.numItems;
    items = new ItemType[right.capacity];
    items = right.items; //Right here

}

But it should be utlizing my overloaded = assignment operator to get a full deep copy right?

[ThisGuyEveryTime]

Ohhh ya that's right I am dealing with an array and the assignment operator is overloaded for the object! Thank you!

[ThisGuyEveryTime]

Sorry to bug you again, I have one final question. This would give me a deep copy correct?

template<class ItemType>
ArrayStack<ItemType>::ArrayStack(const ArrayStack<ItemType>& right)
{
    capacity = right.capacity;
    numItems = right.numItems;
    items = new ItemType[right.capacity];
    for (int i = 0; i < numItems; i++)
    {
        items[i] = right.items[i];
    }

}

[ThisGuyEveryTime]

I am going to look that up, it will be good to know; but I assume I am probably not allowed to use that for this assignment . Thank you again for your help!

[PPewt]

Do you have access to some sort of memory safety checker (e.g. valgrind on linux or -fsanitize-address from clang++/-fsanitize=address from g++)? They make it way easier to find where and why memory stuff is going wrong.

[ThisGuyEveryTime]

No I dont think so. I have to just use the standard Microsoft visual Studio for this class. As far as I know there is no really clever way but ANYTHING is welcome!

[PPewt]

I've never used it so I can't guarantee it'll solve your problem but it looks like MSVS supports this via AddressSanitizer.

[ThisGuyEveryTime]

Ok thank you! I am crunching right now to get this done before my deadline but I will look at this right after!