Question

Write a program that opens a text file called input.txt and reads its contents into a stack of characters. The program should then pop the characters from the stack and save them in a second text file called output.txt. The order of the characters saved in the second file should be the reverse of their order in the first file. We don’t know the text file length.

Input.txt

This is a file is for test

output.txt

tset rof si elif a si sihT

Directions:

Finish

Stack & Stack::operator=(const Stack & original)

{

            // write code here, refer copy construct

}

// File name: stack.h

#include <iostream>

using namespace std;

typedef char StackElement;

class Stack
{
        public:
        Stack();
        Stack(const Stack & original);
        ~Stack();
        bool empty() const;
        void push(const StackElement & value);
        void display(ostream & out) const;
        StackElement top() const;
        void pop();
        Stack & operator=(const Stack & original);

        private:
                class Node
                {
                        public:
                        StackElement data;
                        Node *next;
                        Node (StackElement value, Node *link = 0)
                        {
                                data = value;
                                next = link;
                        }
                };
                
                typedef Node *NodePointer;
                NodePointer myTop;
};

Stack::Stack()
{
       myTop = 0;
       myTop = NULL;
}

Stack::Stack(const Stack & original)
{
        myTop = 0;
        if(!original.empty())
        {
                myTop = new Stack::Node(original.top());
                Stack::NodePointer lastPtr = myTop,
                        origPtr = original.myTop->next;
                while(origPtr != 0)
                {
                        lastPtr->next = new Stack::Node(origPtr->data);
                        lastPtr = lastPtr->next;
                        origPtr = origPtr->next;
                }
        }
}

Stack::~Stack()
{
        Stack::NodePointer currPtr = myTop, nextPtr;
        while (currPtr != 0)
        {
                nextPtr = currPtr->next;
                delete currPtr;
                currPtr = nextPtr;
        }
}

bool Stack::empty() const
{
        return (myTop == 0);
}

void Stack::push(const StackElement & value)
{
        myTop = new Stack::Node(value, myTop);
}

void Stack::display(ostream & out) const
{
        Stack::NodePointer ptr;
        for (ptr = myTop; ptr != 0; ptr = ptr->next)
                out << ptr->data << endl;
}

StackElement Stack::top() const
{
        if (!empty())
                return (myTop->data);
        else
        {
                cerr << "*** Stack is empty "
                        "--- returning garbage value ***\n";
                return *(new StackElement);
        }
}

void Stack::pop()
{
        if (!empty())
        {
                Stack::NodePointer ptr = myTop;
                myTop = myTop->next;
                delete ptr;
        }
        else
                cerr << "*** Stack is empty -- can't remove a value ***\n";
}

Stack & Stack::operator=(const Stack & original)
{
        // write code here, refer copy construct
}

#endif

Answer 1

Answer Here, I have given following modified code are highlighted for the given program. I have given code, text files and sample output as shown below Code CharStack.h #include <iostream> using namespace std; typedef char stackEl ement; class Stack public: Stack(); Stack(const stack & original); Stack); bool empty() const, void push (const stackElement & value); void display (ostream & out) const; stackE1 ement top)const; char pop(); Stack & operator-(const Stack & original); private: class Node public: stackElement data Node *next; Node(StackElement value, Node link0) data value; next link;

3; typedefNode *NodePointer Nodepointer myTop; 3; stack: Stack myTop = NULL; stack: :Stack(const stack & original) my Top = 0; if (loriginal empty()) myTop new stack: :Node(original.top()); Stack: :NodePointer lastPtr my Top, origptr = original.myTop->next; while (origPtr != 0) lastPtr->next = new stack: :Node(origPtr->data); lastPtr = 1astptr->next; Stack:toStack() Stack:: NodePointer currPtrmyTop, nextPtr while (currptr !- 0) nextPtr-currPtr->next delete currptr; currptrnextPtr; bool stack::empty) const

return (myTop== 0); void Stack: :push(const StackElement & value) myTop stack; :Node(value, myTop); = new void Stack::display(ostream & out) const stack: :NodePointer ptr; for (ptr-my Top; ptr - 0; ptr- ptr->next) out << ptr->data << endl; stackEl ement stack: :top() const if (lempty()) return (myTop->data); else cerr<"*** stack is empty "--- returning garbage value ***\n"; return *(new StackElement); //**as changed into char char Stack: :pop) char c; if (lempty)) stack: : NodePointer ptr -my Top; myTop myTop->next; c = ptr-〉data; delete ptr else cerr <** stack is empty --can't remove a value;

return c // Gets error hereSomake as comment line /*stack & stack::operator (const Stack & original) /I write code here, refer copy construct Main.cpip #include iostream» #include <fstream > #include "CharStack.h" using namespace std int main() stack stack; char ch; ifstream inputFile; ofstream outputFile; inputFile,open("in.txt"); if (inputFile) cout< "The file cannot be opened. \n"; exit(1); while (inputFile.get (ch)) stack.push(ch); inputFile.close( outputFile open ("out.txt"); if (loutputFile) cout <"The file cannot be opened.\n"; exit(1); while (!stack.empty))

ch-stack.pop); outputFile.put(ch) outputFile.close() «ysim("pause"); return0 Output:

In.txt: in Notepad File Edit Format View Help hai, how are you

Out.txt: out Notepad File Edit Format View Help uoy era woh iah

Editable code:

CharStack.h

#include <iostream>

using namespace std;

typedef char StackElement;

class Stack

{

public:

       Stack();

       Stack(const Stack & original);

       ~Stack();

       bool empty() const;

       void push(const StackElement & value);

       void display(ostream & out) const;

       StackElement top() const;

       char pop();

       Stack & operator=(const Stack & original);

private:

       class Node

       {

       public:

              StackElement data;

              Node *next;

              Node(StackElement value, Node *link = 0)

              {

                     data = value;

                     next = link;

              }

       };

       typedef Node *NodePointer;

       NodePointer myTop;

};

Stack::Stack()

{

       myTop = 0;

       myTop = NULL;

}

Stack::Stack(const Stack & original)

{

       myTop = 0;

       if (!original.empty())

       {

              myTop = new Stack::Node(original.top());

              Stack::NodePointer lastPtr = myTop,

                     origPtr = original.myTop->next;

              while (origPtr != 0)

              {

                     lastPtr->next = new Stack::Node(origPtr->data);

                     lastPtr = lastPtr->next;

                     origPtr = origPtr->next;

              }

       }

}

Stack::~Stack()

{

       Stack::NodePointer currPtr = myTop, nextPtr;

       while (currPtr != 0)

       {

              nextPtr = currPtr->next;

              delete currPtr;

              currPtr = nextPtr;

       }

}

bool Stack::empty() const

{

       return (myTop == 0);

}

void Stack::push(const StackElement & value)

{

       myTop = new Stack::Node(value, myTop);

}

void Stack::display(ostream & out) const

{

       Stack::NodePointer ptr;

       for (ptr = myTop; ptr != 0; ptr = ptr->next)

              out << ptr->data << endl;

}

StackElement Stack::top() const

{

       if (!empty())

              return (myTop->data);

       else

       {

              cerr << "*** Stack is empty "

                     "--- returning garbage value ***\n";

              return *(new StackElement);

       }

}

//*** as changed into char

char Stack::pop()

{

       char c;

       if (!empty())

       {

              Stack::NodePointer ptr = myTop;

              myTop = myTop->next;

              c = ptr->data;

              delete ptr;

       }

       else

              cerr << "*** Stack is empty -- can't remove a value ***\n";

       return c;

}

// Gets error here.. so , make as comment line

/*Stack & Stack::operator=(const Stack & original)

{

       // write code here, refer copy construct

      

}*/

Main.cpp

#include <iostream>

#include <fstream>

#include "CharStack.h"

using namespace std;

int main()

{

       Stack stack;

       char ch;

       ifstream inputFile;

       ofstream outputFile;

       inputFile.open("in.txt");

       if (!inputFile)

       {

              cout << "The file cannot be opened.\n";

              exit(1);

       }

       while (inputFile.get(ch))

       {

              stack.push(ch);

       }

       inputFile.close();

       outputFile.open("out.txt");

       if (!outputFile)

       {

              cout << "The file cannot be opened.\n";

              exit(1);

       }

       while (!stack.empty())

       {

              ch=stack.pop();

              outputFile.put(ch);

       }

       outputFile.close();

       system("pause");

       return 0;

}