write code in c++ for the question. A container class is a data type that is capable of…
- User
write code in c++ for the question. A container class is a data type that is capable of holding a collection of items and provides functions to access them. Bag is an example of a container class. It is an unordered collection of items that may have duplicates. In this assignment, you are asked to design and develop an abstract Bag class, called BagInterface, with the following fixed collection of operations: Insert an item of any type into a bag Query the bag contents: two queries Is an item in the bag? How many copies of an item is in the bag? Remove an item from the bag clear the bag Get the size of the bag How many items are there in the bag? Check if the bag is empty Check if the bag is full Assume the bag capacity is 20 In addition to BagInterface, you are asked to implement two classes of bag implementations: PlainBag and MagicChangeBag.
PlainBag is a simple container that holds items of any type using an array implementation.
MagicChangeBag is also very similar to PlainBag, with two exceptions. When an item is inserted into a magic change bag, it’ll magically disappear, and bag looks empty. Whenever a remove operation is invoked, all the items, except the one is removed will appear.
- Assistant
Here is a C++ implementation of the abstract BagInterface class, as well as the PlainBag and MagicChangeBag classes:
#include <iostream> #include <algorithm> // Abstract BagInterface class template <class T> class BagInterface { public: virtual void insert(const T& item) = 0; virtual bool contains(const T& item) const = 0; virtual int count(const T& item) const = 0; virtual bool remove(const T& item) = 0; virtual void clear() = 0; virtual int size() const = 0; virtual bool isEmpty() const = 0; virtual bool isFull() const = 0; }; // PlainBag class implementation template <class T> class PlainBag : public BagInterface<T> { private: T items[20]; int itemCount; public: PlainBag() { itemCount = 0; } void insert(const T& item) { if (itemCount < 20) { items[itemCount] = item; itemCount++; } } bool contains(const T& item) const { for (int i = 0; i < itemCount; i++) { if (items[i] == item) { return true; } } return false; } int count(const T& item) const { int itemCounter = 0; for (int i = 0; i < itemCount; i++) { if (items[i] == item) { itemCounter++; } } return itemCounter; } bool remove(const T& item) { for (int i = 0; i < itemCount; i++) { if (items[i] == item) { for (int j = i; j < itemCount - 1; j++) { items[j] = items[j + 1]; } itemCount--; return true; } } return false; } void clear() { itemCount = 0; } int size() const { return itemCount; } bool isEmpty() const { return (itemCount == 0); } bool isFull() const { return (itemCount == 20); } }; // MagicChangeBag class implementation template <class T> class MagicChangeBag : public BagInterface<T> { private: T items[20]; int itemCount; public: MagicChangeBag() { itemCount = 0; } void insert(const T& item) { itemCount = 0; } bool contains(const T& item) const { return (itemCount == 0); } int count(const T& item) const { return 0; } bool remove(const T& item) { std::fill(items, items + 20, item); itemCount = 1; return true; } void clear() { itemCount = 0; } int size() const { return itemCount; } bool isEmpty() const { return (itemCount == 0); } bool isFull() const { return (itemCount == 20); } }; // Test the classes int main() { // Create a PlainBag object PlainBag<int> plainBag; // Insert some items plainBag.insert(5); plainBag.insert(3); plainBag.insert(5); // Check if items are in the bag std::cout << "Contains 5: " << std::boolalpha << plainBag.contains(5) << std::endl; std::cout << "Contains 3: " << std::boolalpha << plainBag.contains(3) << std::endl; std::cout << "Contains 7: " << std::boolalpha << plainBag.contains(7) << std::endl; // Count the number of items in the bag std::cout << "Count of 5: " << plainBag.count(5) << std::endl; std::cout << "Count of 3: " << plainBag.count(3) << std::endl; // Remove an item from the bag std::cout << "Remove 5: " << std::boolalpha << plainBag.remove(5) << std::endl; // Check the size of the bag std::cout << "Size: " << plainBag.size() << std::endl; // Check if the bag is empty std::cout << "Empty: " << std::boolalpha << plainBag.isEmpty() << std::endl; // Check if the bag is full std::cout << "Full: " << std::boolalpha << plainBag.isFull() << std::endl; // Create a MagicChangeBag object MagicChangeBag<int> magicChangeBag; // Insert an item into the bag magicChangeBag.insert(10); // Check if the bag is empty now std::cout << "Empty: " << std::boolalpha << magicChangeBag.isEmpty() << std::endl; // Remove an item from the bag std::cout << "Remove 10: " << std::boolalpha << magicChangeBag.remove(10) << std::endl; // Check the size of the bag std::cout << "Size: " << magicChangeBag.size() << std::endl; return 0; }This code defines the abstract BagInterface class, which provides the basic bag operations. The PlainBag class implements these operations using an array-based implementation, while the MagicChangeBag class also implements the operations but with some magical behavior where inserted items disappear and removed items reappear. The main function demonstrates the usage of these classes.
Note that in the MagicChangeBag class, all the functions except for
removedon't provide meaningful results, as the bag always appears empty and items inserted into it magically disappear. The functions are implemented for the sake of interface compatibility.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.