Question

Hi everyone: Here i have created a queue from two stacks: You add to the one and remove from the other – when you want to remove the first stack dumps all its data into the second one, and it works perfectly – BUT
whenever i try to execute this loop without the bottom for loop or cin
the program receives a segmentation fault, i mean the most bottom for loop doesn’t even execute but take it out and see what happens. Could this be some sort of buffer overflow
and Gcc needs time to manage the memory?

=====================================================================

    struct Node
    {
        int DataMember;
        Node* Next;
    };

    class Que
    {
        public:
            Que();
            ~Que();
            void Add(int);
            void Pop();
            int getSize();
            void Purge();
        private:
            Node* Head;
            bool StackOrQue; //True = Que False = Stack
            int Size;
            int Remove();
            void Reverse();
    };

    void Que::Purge()
    {
        while(Head != NULL)
            Pop();

        if(StackOrQue)
            StackOrQue = false;
    }

    int Que::getSize()
    {
        return Size;
    }

    Que::Que()
    {
        Head = NULL;
        Size = 0;
        StackOrQue = false;
    }

    Que::~Que()
    {
        Head = NULL;
    }

    void Que::Add(int q)
    {
        if(StackOrQue)
            Reverse();
        Size += 1;
        Node* Temp = new Node;

        Temp->DataMember = q;

        Temp->Next = Head;
        Head = Temp;
    }

    int Que::Remove()
    {
        int i = Head->DataMember;
        Node* Temp = Head->Next;
        delete Head;
        Size -= 1;
        Head = Temp;
        return i;
    }

    void Que::Pop()
    {
        if(!StackOrQue)
            Reverse();
        cout << Remove();
    }

    void Que::Reverse()
    {
        Que TempStack;
        int k = Size;
        for(int i = 0; i < k; i++)
            TempStack.Add(this->Remove());
        delete this;
        *this = TempStack;

        if(!StackOrQue)
            StackOrQue = true;
        else
            StackOrQue = false;
    }

=====================================================================

Que q;
char a = NULL;

while(a != 'x')
{
    q.Purge();
    q.Add(1);
    q.Add(2);
    q.Add(3);
    q.Add(4);
    q.Add(5);
    q.Add(6);
    q.Add(7);
    q.Add(8);
    int size = q.getSize();
    for(int i = 0; i < size; i++)
        q.Pop();
    //cin >> a;
    for(int i = 0; i < 0; i++)
        ;
}

Thanks in-advance

Answer 1

    delete this;
    *this = TempStack;

There are some extreme corner cases in which delete this; actually does the right thing. This is not one of them. Specially since your Queue is placed in the stack, and you further try to delete it. If you intend to call the destructor instead do this->~Queue(), however after a manual destruction the only sensible thing to do next is a placement new. Assigning to *this is almost always a bad idea (if you bring inheritance into the picture, you have just caused a slice object to be created and more problems ahead the road). Also, your class should be implementing a copy constructor and an assignment operator, to correctly handle the resources allocated.