Question

C++ programming language:

In this program you will create a simplified bag that acts like a stack meaning that the Last item inserted is the First Item that comes out. Your backend implementation must use a linked list. The code should pass the test (there's only 1) and there should be no memory leaks. Note that passing the test does not ensure full credit! The functions are listed in the suggested order of implementation but you may implement them in any order you like. There is only 1 test case, do not modify main but feel free to comment out portions of main and uncomment as you implement.

PUT ALL YOUR CODE IN bag.cpp

bag();

The default constructor should create an empty bag represented by an empty list

void insertItem(const value_type& entry);

Insert should put the item at the front of the list

std::ostream& operator <<(std::ostream& outs, const bag& source)

prints the bag in order of last one inserted to first one inserted, as follows-- let's say the bag had the numbers 6,7,8,9 inserted in that order

Ordered Bag: 9 8 7 6

If it's empty the bag should print out

Ordered Bag: Empty

~bag(); //destructor

The destructor should release any dynamic memory

value_type removeItem();

Remove item should remove the last item inserted into the bag or return the number 0 if there's no item left in the bag (just for easiness-- if you return NULL you'll get an implicit conversion warning)

size_type bag::howMany(const value_type& entry)

returns the number of items with value equal to entry currently in the bag

void bag::operator =(const bag& source)

makes the current bag equal to the source bag via a deep copy

main.cpp

#include <iostream>
#include "bag.h"
using namespace std;
int main() {
cout<<"Creating bag a"<<endl;
bag a;
cout<<"Coutting a, should be empty"<<endl;
cout<<a<<endl;
cout<<"now adding 5 to a and printing"<<endl;
a.insertItem(5);
cout<<a<<endl;
cout<<"now adding 10 and 15, in that order, to a and printing"<<endl;
a.insertItem(10);
a.insertItem(15);
cout<<a<<endl;
  
cout<<"now removing FOUR items from a"<<endl;
cout<<"First item removed: "<<a.removeItem()<<endl;
cout<<"Second item removed: "<<a.removeItem()<<endl;
cout<<"Third item removed: "<<a.removeItem()<<endl;
cout<<"Fourth item removed: "<<a.removeItem()<<endl;
  
cout<<"now checking the number of 20's in a"<<endl;
cout<<"Number of 20s: "<<a.howMany(20)<<endl;
cout<<"Now adding 3 20's and 2 10's"<<endl;
a.insertItem(20);a.insertItem(20); a.insertItem(20); a.insertItem(10); a.insertItem(10);
cout<<"Number of 20s: "<<a.howMany(20)<<endl;
cout<<"Number of 10s: "<<a.howMany(10)<<endl;
cout<<"Now making bag b and inserting 200 into it"<<endl;
bag b;
b.insertItem(200);
cout<<"now setting b equal to a"<<endl;
b=a;
cout<<"bag a is "<<a<<endl;
cout<<"bag b is "<<b<<endl;
cout<<"now inserting 1000 into a and 200 into b"<<endl;
a.insertItem(1000);
b.insertItem(200);
cout<<"bag a is "<<a<<endl;
cout<<"bag b is "<<b<<endl;
}

bag.h

#ifndef BAG_H_ //macroguard that stops the header from being included twice.
#define BAG_H_ //Including the header twice stops the compilation, Note no Semilcolon
#include <cstdlib>
#include <iostream>
#include "Node.h"
class bag
{
public:
typedef std::size_t size_type;
typedef int value_type; //we define value type to be an int
bag ();
~bag(); //destructor
void insertItem(const value_type& entry); //inserts into your bag
value_type removeItem();//erases the last in item from the bag and returns it
size_type howMany(const value_type& entry); //returns how many of a particular item is in the bag
void operator =(const bag& source);//sets two bags equal
friend std::ostream& operator <<(std::ostream& outs, const bag& source);//couts the bag contents
private:
Node *head;
};

#endif

bag.cpp

#include <iostream>
#include "bag.h"
typedef std::size_t size_type;
typedef int value_type; //we define value type to be an int

bag::bag ()
{
}


bag::~bag()
{

}

void bag::insertItem(const value_type& entry)
{

}

value_type bag::removeItem()
{


}

size_type bag::howMany(const value_type& entry)
{

}

void bag::operator =(const bag& source)
{

}

std::ostream& operator <<(std::ostream& outs, const bag& source)
{

}

Node.h

#ifndef NODE_H
#define NODE_H
#include <cstdlib> // Provides size_t and NULL

class Node //Node is all inlined and implemented
{
public:
typedef int value_type;
  
   // CONSTRUCTOR
   Node(const value_type& init_data = value_type( ),Node* init_link = NULL)
   { data_field = init_data; link_field = init_link; }

   // Member functions to set the data and link fields:
   void set_data(const value_type& new_data) { data_field = new_data; }
   void set_link(Node* new_link) { link_field = new_link; }

   // Constant member function to retrieve the current data:
   value_type data( ) const { return data_field; }

   // Two slightly different member functions to retreive
   // the current link:
   const Node* link( ) const { return link_field; }
   Node* link( ) { return link_field; }
  
private:
   value_type data_field;
   Node* link_field;
};
#endif

Answer 1

/* Node.h */

#ifndef NODE_H
#define NODE_H
#include <cstdlib> // Provides size_t and NULL

class Node //Node is all inlined and implemented
{
public:
typedef int value_type;
  
// CONSTRUCTOR
Node(const value_type& init_data = value_type( ),Node* init_link = NULL)
{ data_field = init_data; link_field = init_link; }

// Member functions to set the data and link fields:
void set_data(const value_type& new_data) { data_field = new_data; }
void set_link(Node* new_link) { link_field = new_link; }

// Constant member function to retrieve the current data:
value_type data( ) const { return data_field; }

// Two slightly different member functions to retreive
// the current link:
const Node* link( ) const { return link_field; }
Node* link( ) { return link_field; }
  
private:
value_type data_field;
Node* link_field;
};
#endif

/* bag.h */

#ifndef BAG_H_ //macroguard that stops the header from being included twice.
#define BAG_H_ //Including the header twice stops the compilation, Note no Semilcolon
#include <cstdlib>
#include <iostream>
#include "Node.h"
class bag
{
public:
typedef std::size_t size_type;
typedef int value_type; //we define value type to be an int
bag ();
~bag(); //destructor
void insertItem(const value_type& entry); //inserts into your bag
value_type removeItem();//erases the last in item from the bag and returns it
size_type howMany(const value_type& entry); //returns how many of a particular item is in the bag
void operator =(const bag& source);//sets two bags equal
friend std::ostream& operator <<(std::ostream& outs, const bag& source);//couts the bag contents
private:
Node *head;
};

#endif

/* bag.cpp */

#include <iostream>
#include "bag.h"
typedef std::size_t size_type;
typedef int value_type; //we define value type to be an int

bag::bag()
{
   head = NULL;
   this->howMany(0);
}

bag::~bag()
{
   Node* current = head;
   while( current != NULL) {
   Node* n = current->link();
   delete current;
   current = n;
   }
   head = NULL;
}

void bag::insertItem(const value_type& entry)
{
   Node *p = new Node(entry);
   if(head == NULL){
       head = p;
       return;
   }
   p->set_link(head);
   head = p;
}

value_type bag::removeItem()
{
   if(head == NULL){
       return 0;
   }else{
       value_type d = head->data();
       head = head->link();
       return d;
   }  

}

size_type bag::howMany(const value_type& entry)
{
   value_type count = 0;
   Node *p = head;
   while(p!=NULL){
       if(p->data() == entry)
           count++;
       p = p->link();
   }
   return count;
}

void bag::operator =(const bag& source)
{
   if(this!=&source){
  
       if (source.head == NULL) {
           head = NULL;
           return;
       }
           Node* p = source.head; // points to current node on other
           Node* tmp = new Node(p->data()); // make a copy of the first node
           head = tmp;
           Node* tail = tmp; // points to last node of this list
           while (p->link() != nullptr) {
               p = p->link();
               tmp = new Node(p->data());
               tail->set_link(tmp);
               tail = tmp;
           }
      
   }
}

std::ostream& operator <<(std::ostream& outs, const bag& source)
{
   if(source.head == NULL){
       outs<<"Ordered Bag: Empty\n";
   }else{
       outs<<"Ordered Bag: ";
       Node *cur = source.head;
       while(cur!=NULL){
           outs<<cur->data()<<" ";
           cur = cur->link();
       }
       outs<<std::endl;      
   }
   return outs;  
}

/* main.cpp */

#include <iostream>
#include "bag.h"
using namespace std;
int main() {
cout<<"Creating bag a"<<endl;
bag a;
cout<<"Coutting a, should be empty"<<endl;
cout<<a<<endl;
cout<<"now adding 5 to a and printing"<<endl;
a.insertItem(5);
cout<<a<<endl;
cout<<"now adding 10 and 15, in that order, to a and printing"<<endl;
a.insertItem(10);
a.insertItem(15);
cout<<a<<endl;
  
cout<<"now removing FOUR items from a"<<endl;
cout<<"First item removed: "<<a.removeItem()<<endl;
cout<<"Second item removed: "<<a.removeItem()<<endl;
cout<<"Third item removed: "<<a.removeItem()<<endl;
cout<<"Fourth item removed: "<<a.removeItem()<<endl;
  
cout<<"now checking the number of 20's in a"<<endl;
cout<<"Number of 20s: "<<a.howMany(20)<<endl;
cout<<"Now adding 3 20's and 2 10's"<<endl;
a.insertItem(20);a.insertItem(20); a.insertItem(20); a.insertItem(10); a.insertItem(10);
cout<<"Number of 20s: "<<a.howMany(20)<<endl;
cout<<"Number of 10s: "<<a.howMany(10)<<endl;
cout<<"Now making bag b and inserting 200 into it"<<endl;
bag b;
b.insertItem(200);
cout<<"now setting b equal to a"<<endl;
b=a;
cout<<"bag a is "<<a<<endl;
cout<<"bag b is "<<b<<endl;
cout<<"now inserting 1000 into a and 200 into b"<<endl;
a.insertItem(1000);
b.insertItem(200);
cout<<"bag a is "<<a<<endl;
cout<<"bag b is "<<b<<endl;
}

/* OUTPUT */

/* PLEASE UPVOTE */