Question

Objective

You are given a partial implementation of one header file, GildedRose.h. Item is a class that holds the information for each item for the inn. GildedRose is a class that holds an internal listing of many Item objects. This inventory should hold at least 10 items. For this you can use arrays, the std::array class, or even the vector class.

Complete the implementation of these classes, adding public/private member variables and functions as needed. You should choose an appropriate data structure to maintain this inventory with an unknown size known only at runtime. Your code is tested in the provided main.cpp.

You will need to implement the following functions:

• Constructors/Destructors - Initialize your data. Allocate memory if using a native array. The destructor should deallocate memory if using a native array.

• size() - This should return the number of items currently for sale (this is different from the max).

• get(size_t) - This should return the item with the matching index. For example if given an index of 3, you should return the item at index 3 in the list.

• add(Item) - This should add another item for sale in the Gilded Rose by adding it to your inventory.

• operator[](size_t) - This should perform identical to the get(size_t) function.

SKELETAL CODE FOR HEADER FILE:

#pragma once

#include <string>
using std::string;

// This is already done for you...
class Item {
public:
   string name;
   int sellIn;
   int quality;
   Item(string, int, int);
};

Item::Item(string new_name, int new_sellIn, int new_quality)
   : name(new_name), sellIn(new_sellIn), quality(new_quality) {
}

// This class is incomplete...
class GildedRose {
private:
   // Add something to hold at least 10 items

public:
   GildedRose();
   ~GildedRose();

   size_t size() const;
   Item& get(size_t);
   void add(const Item&);

   Item& operator[](size_t);
};

Code should be in C++

Answer 1

Screenshot

--------------------------------------------------------

Program

Main.cpp

#include "stdafx.h"
//Header files
#include<iostream>
#include "GildedRose.h"
#include "item.h"
using namespace std;

int main()
{
   Item item1("Bench", 1, 1);
   Item item2("Chair", 1, 1);
   GildedRose gr;
   gr.add(item1);
   gr.add(item2);
   cout << "Item from index 1(using[]):";
   cout << gr[1].name << " " << gr[1].sellIn << " " << gr[1].quality << endl;
   cout << "Get the number of items in GildedRose:" << gr.size() << endl;
   cout << "Item from index 1(using get):";
   cout << gr.get(0).name<< " " << gr.get(0).sellIn << " " << gr.get(0).quality << endl;
    return 0;
}

Item.h

#pragma once
#include <string>
using std::string;

// This is already done for you...
class Item {
public:
   string name;
   int sellIn;
   int quality;
   Item(string, int, int);
};

Item.cpp

#include "item.h"
Item::Item(string new_name, int new_sellIn, int new_quality)
   : name(new_name), sellIn(new_sellIn), quality(new_quality) {
}

GildedRose.h

#pragma once
#include "item.h"
#include<vector>
using std::vector;
class GildedRose{
private:
   // Add something to hold at least 10 items
   vector<Item> items;

public:
   GildedRose();
   ~GildedRose();

   size_t size() const;
   Item& get(size_t);
   void add(const Item&);

   Item& operator[](size_t);
};

GildedRose.cpp

#include "GildedRose.h"
//Default constructor
GildedRose::GildedRose(){ }
//Parameterized constructor
GildedRose::~GildedRose() {   }
//Get number of items in the vector
size_t GildedRose::size() const {
   return items.size();
}
//Get item details of the given index
Item& GildedRose::get(size_t i) {
   return items.at(i);
}
//Add an item
void GildedRose::add(const Item& item) {
   items.push_back(item);
}
//Using operator[] to access item details of corresponding index
Item& GildedRose::operator[](size_t i) {
   return items.at(i);
}

-----------------------------------------------------------------------

Output

Item from index 1(using[]):Chair 1 1
Get the number of items in GildedRose:2
Item from index 1(using get):Bench 1 1
Press any key to continue . . .