#include "ShippingContainer.h" 
 #include "ManualShippingContainer.h" 
  
 class RFIDShippingContainer : public ShippingContainer{ 
 	// derived class for RFID method of inventorying the container 
 private: 
 	string content;// for the content of the item 
          
 	int quantity;// for the quantity of the added items. 
        
 public: 
  
     RFIDShippingContainer ();// constructors 
          
     string getContent();// input string of the content. 
     int add( string );// add the item, say add one crate of pears 
     
     void setManifest( string ); // set the manifest  
     virtual string getManifest(); // return the string of manifest 
  
 }; 
  
 RFIDShippingContainer ::RFIDShippingContainer(){ 
 	content =""; 
 	quantity = 0; 
 } 
  
 void RFIDShippingContainer :: setManifest( string theManifest ){ 
 	content = theManifest; 
 } 
  
 string RFIDShippingContainer :: getContent(){ 
     return content; 
 } 
  
 string RFIDShippingContainer :: getManifest(){ 
 	cout<< content<<endl; 
 	return content; 
 } 
  
 int RFIDShippingContainer :: add( string thecontent ){ 
 	content = thecontent; 
 	/*quantity ++; 
 	return quantity;*/ 
 }

#include <iostream> 
 #include <string> 
  
 #ifndef SHIPPINGCONTAINER_H 
 #define SHIPPINGCONTAINER_H 
  
 using namespace std; 
  
 class ShippingContainer{ 
 private: 
 	int containerID; 
 public: 
  
 	//ShippingContainer (int containerID); 
     ShippingContainer(){ 
 		containerID = 0; 
 	}// constructors 
  
 	void setContainerID( int );//mutator 
 	int getContainerID();//accessor 
 	string IntToString(int i);// convert the ID integers to a string 
      
 	virtual void setManifest( string ) = 0; 
 	virtual string getManifest();//virtual function to output the empty string as the content of the shipping container. 
 }; 
  
 void ShippingContainer :: setContainerID( int thecontainerID ){ 
 	containerID = thecontainerID; 
 } 
 int ShippingContainer :: getContainerID(){ 
 	return containerID; 
 } 
  
 string ShippingContainer :: getManifest(){ 
 	//virtual function to output the empty string as the content of the shipping container. 
 	//cout<< ""; 
     return("");// return an empty string. 
 } 
  
 #endif 

#include "ShippingContainer.h" 
 #ifndef MANUALSHIPPINGCONTAINER_H 
 #define MANUALSHIPPINGCONTAINER_H 
  
 class ManualShippingContainer : public ShippingContainer{ 
 	// derived class for manual method of inventorying the container 
 private: 
 	string Content; 
 public: 
  
 	ManualShippingContainer ();// constructors 
  
 	void setManifest( string ); 
 	virtual string getManifest();//output the empty string as the content of the shipping container. 
  
 	string getContent();// input string of the content. 
 }; 
  
 void ManualShippingContainer :: setManifest(string theManifest ){ 
 	Content = theManifest; 
 } 
  
 ManualShippingContainer ::ManualShippingContainer(){ 
 	Content =""; 
 } 
  
 string ManualShippingContainer :: getContent(){ 
 	return Content; 
 } 
  
 string ManualShippingContainer :: getManifest(){ 
 	return Content; 
 } 
  
 #endif 

/* 
 Name				: Lim Boon Jye 
 Student ID			: 4372463 
 Modification Date	: 1 October 2012 
 Purpose program		: 
 */ 
  
 #include "ShippingContainer.h" 
 #include "ManualShippingContainer.h" 
 #include "RFIDShippingContainer.h" 
  
 int main(){ 
 	ManualShippingContainer theManualShippingContainer; 
 	RFIDShippingContainer theRFIDShippingContainer; 
 	ShippingContainer *theShippingContainer[6] ; 
 	theShippingContainer[0] =	new ManualShippingContainer; 
 	theShippingContainer[1] =	new ManualShippingContainer; 
 	theShippingContainer[2] =	new ManualShippingContainer; 
 	theShippingContainer[3] =	new RFIDShippingContainer; 
 	theShippingContainer[4] =	new RFIDShippingContainer; 
 	theShippingContainer[5] =	new RFIDShippingContainer; 
  
 	theShippingContainer[0]->setContainerID(5); 
 	theShippingContainer[0]->setManifest("Manual Shipping Manifest"); 
  
 	theShippingContainer[1]->setContainerID(10); 
 	theShippingContainer[1]->setManifest("Manual Shipping Manifest"); 
  
 	theShippingContainer[2]->setContainerID(15); 
 	theShippingContainer[2]->setManifest("Manual Shipping Manifest"); 
  
 	theShippingContainer[3]->setContainerID(20); 
 	theShippingContainer[3]->setManifest("crate of apple"); 
 	theShippingContainer[3]->setManifest("crate of apple"); 
 	theShippingContainer[3]->setManifest("crate of apple"); 
 	theShippingContainer[3]->setManifest("crate of apple"); 
 	theShippingContainer[3]->setManifest("crate of oranges"); 
 	theShippingContainer[3]->setManifest("crate of oranges"); 
 	theShippingContainer[3]->setManifest("crate of oranges"); 
 	theShippingContainer[3]->setManifest("crate of bananas"); 
  
 	theShippingContainer[4]->setContainerID(25); 
 	theShippingContainer[4]->setManifest("crate of apples"); 
  
 	 
 	theShippingContainer[5]->setContainerID(30); 
 	theShippingContainer[5]->setManifest("crate of oranges"); 
 	theShippingContainer[5]->setManifest("crate of oranges"); 
 	theShippingContainer[5]->setManifest("crate of apples"); 
  
  
 	for(int i = 0; i < 6; i++){ 
 		int temp = theShippingContainer->getContainerID(); 
 		cout << "Container " << temp << " manifest: " << theShippingContainer->getManifest() 
 		<< ", #" << temp << endl; 
 	} 
  
 	system( "pause" );//System Pause 
 	return 0; 
 }

To model this application, write a base class called ShippingContainer  
 that has a container ID number as an integer.  
  Include member functions to set and access the ID number.   
 Add a virtual function called getManifest that returns an empty string.   
 The purpose of this function is to return the contents of the shipping container. 
  
 Create a derived class called ManualShippingContainer that represents the manual method  
 of inventorying the container.  In this method, a human simply attaches a textual description  
 of all contents of the container.   
 For example, the description might be “4 crates of apples, 10 crates of pears.”   
 Add a new class variable of type string to store the manifest.   
 Add a function called setManifest that sets this string.  Override the getManifest function so that it returns this string. 
  
 Create a second derived class called RFIDShippingContainer that represents the  
 RFID method of inventorying the container.  To simulate what the RFID chips would compute,  
 create an add function to simulate adding an item to the container.   
 The class should store a list of all added items (as a string) and their quantity using the  
 data structures of your choice.  For example, if the add function are invoked three times as follows: 
  
 rfidContainer.add(“crate of pears”);		//add one crate of pears 
 rfidContainer.add(“crate of apples”);	//add one crate of apples 
 rfidContainer.add(“crate of pears”);		//add one crate of pears 
  
 At this point, the data structure should be storing a list of two items:  
 crate of apples and crate of pears.  The quantity of apples is one and the quantity of pears is two.  
  Override the getManifest function so that it returns a string of all items that is built by traversing the list of items.   
 In the above example, the return string would be “2 crate of pears, 1 crate of apples.” 
  
 Include other necessary functions, constructors, and destructor to all the classes above. 
  
 Finally, write a main program that creates an array of pointers to 6 ShippingContainer objects.   
 The array should be used to store both the ManualShippingContainer objects and RFIDShippingContainer objects.  
  Construct the main program to allow the user to decide the number of each type of objects to be stored in the array.  
  Instantiate all the objects accordingly and demonstrate how each objects behaves differently 
  when the same instructions are given to them.  For the ManualShippingContainer objects, you will have to invoke  
 setManifest function to set the contents.  For the RFIDShippingContainer objects, you will have to invoke add to  
 set the contents (although, if this were real, the contents of the container would “add” themselves via the  
 RFID chips instead of requiring a human to type them in).   
 

 ShippingContainer() : containerID( 0 ) 
 { 
 }

int getContainerID() const; 

rfidContainer.add(“crate of pears”);		//add one crate of pears  
  rfidContainer.add(“crate of apples”);	//add one crate of apples  
  rfidContainer.add(“crate of pears”);		//add one crate of pears 

struct list{ 
    lisr *next;  
    int quantity;  
    string content;  
 }; 

 #ifndef SHIPPINGCONTAINER_H 
 #define	SHIPPINGCONTAINER_H 
  
 #include	<string> 
  
 class ShippingContainer 
 { 
 public: 
 	ShippingContainer() : containerID( 0 ) {} 
 	virtual ~ShippingContainer() {} 
 	void setContainerID( int theContainerID ) { containerID = theContainerID;  } 
 	int getContainerID() const { return ( containerID );  } 
 	virtual std::string getManifest() const { return ( "" ); } 
  
 private: 
 	int containerID; 
 }; 
  
 #endif	//	SHIPPINGCONTAINER_H

 #ifndef	MANUALSHIPPINGCONTAINER_H 
 #define	MANUALSHIPPINGCONTAINER_H 
  
 #include	<string> 
 #include	"ShippingContainer.h" 
  
 class ManualShippingContainer : public ShippingContainer 
 { 
 public: 
  
 	ManualShippingContainer() {} 
 	~ManualShippingContainer() {} 
 	std::string getManifest() const { return ( manifest ); } 
 	void setManifest( const std::string &theManifest ) { manifest = theManifest; } 
  
 private: 
 	std::string manifest; 
 }; 
  
 #endif	//	MANUALSHIPPINGCONTAINER_H

 #ifndef	RFIDSHIPPINGCONTAINER_H 
 #define	RFIDSHIPPINGCONTAINER_H 
  
 #include	<string> 
 #include	"ShippingContainer.h" 
  
 class RFIDShippingContainer : public ShippingContainer 
 { 
 public: 
 	RFIDShippingContainer() : manifestList( 0 ) {} 
 	~RFIDShippingContainer() 
 	{ 
 		list *current = manifestList; 
 		while ( current ) 
 		{ 
 			list *tmp = current; 
 			current = current->get_next(); 
 			delete tmp; 
 		} 
 		manifestList = 0; 
 	} 
  
 	std::string getManifest() const 
 	{ 
 		std::string theManifest; 
  
 		list *current = manifestList; 
  
 		while ( current ) 
 		{ 
 			if ( !theManifest.empty() ) theManifest += ", "; 
 			theManifest += current->toString(); 
 			current = current->get_next(); 
 		} 
  
 		return ( theManifest ); 
 	} 
 	void add( const std::string &theManifest ) 
 	{ 
 		list *item = find( theManifest ); 
  
 		if ( item == 0 ) 
 		{ 
 			item = new list( theManifest, manifestList ); 
 			manifestList = item; 
 		} 
 		else 
 		{ 
 			++( *item ); 
 		} 
 	} 
  
 private: 
 	struct list 
 	{ 
 	public: 
 		list( std::string theManifest, list *theNext = 0 )  
 			: manifest( theManifest ), quantity( 1 ), next( theNext ) {} 
 		list * get_next() const { return ( next ); } 
 		bool operator ==( const std::string &theManifest ) const 
 		{ 
 			return ( manifest == theManifest ); 
 		} 
 		list & operator ++() 
 		{ 
 			++quantity; 
 			return ( *this ); 
 		} 
 		std::string toString() const 
 		{ 
 			return ( std::to_string( ( long long )quantity ) + " " + manifest ); 
 		} 
 	private: 
 		list *next; 
 		int quantity; 
 		std::string manifest; 
 	}; 
 	list *manifestList; 
  
 	list * find( const std::string &theManifest ) const 
 	{ 
 		list *current = manifestList; 
  
 		while ( current && !(*current == theManifest ) ) current = current->get_next(); 
  
 		return ( current ); 
 	} 
 }; 
  
 #endif	//	RFIDSHIPPINGCONTAINER_H

 #include "stdafx.h" 
 #include	<iostream> 
 #include	"ShippingContainer.h" 
 #include	"ManualShippingContainer.h" 
 #include	"RFIDShippingContainer.h" 
  
  
 int _tmain(int argc, _TCHAR* argv[]) 
 { 
 	const size_t TOTAL_CONTAINERS = 6; 
 	ShippingContainer *sc[TOTAL_CONTAINERS]; 
  
 	RFIDShippingContainer *RFID_item = new RFIDShippingContainer(); 
  
 	RFID_item->add( "crate of pears" ); 
 	RFID_item->add( "crate of apples" ); 
 	RFID_item->add( "crate of pears" ); 
  
 	sc[0] = RFID_item; 
  
 	ManualShippingContainer *Manual_item = new ManualShippingContainer(); 
  
 	Manual_item->setManifest( "5 crate of apples " ); 
  
 	sc[1] = Manual_item; 
  
 	for ( size_t i = 0; i < 2; i++ ) 
 	{ 
 		std::cout << sc[ i ]->getManifest() << std::endl; 
 	} 
  
  
 	delete RFID_item; 
 	delete Manual_item; 
  
 	return 0; 
 }

 private: 
 	RFIDShippingContainer( const RFIDShippingContainer & );  
 	RFIDShippingContainer & operator = ( const RFIDShippingContainer & );