Question

C++ Class involving duplication

The goal is to make add() not allow duplicates.

Bag<int> bag1;

bag1.add(1); //ok

bag1.add(2); //ok

bag1.add(1); //ignore but do not break or terminate. The submission will go through but will not get added to array

#include <iostream>
#include <string>

#include <vector>
using namespace std;

template<class T>
class Bag
{
public:
    Bag();
    int getCurrentSize() const;
    bool isEmpty() const;
    bool add(const T& new_entry); //Modify this
    bool remove(const T& an_entry);
    /**
     @post item_count_ == 0
     **/
    void clear();
    /**
     @return true if an_etry is found in items_, false otherwise
     **/
    bool contains(const T& an_entry) const;

    /**
     @return the number of times an_entry is found in items_
     **/
    int getFrequencyOf(const T& an_entry) const;

    /**
     @return a vector having the same cotntents as items_
     **/
    std::vector<T> toVector() const;

    void display() const;  // displays the output 


protected:
    static const int DEFAULT_CAPACITY = 200;  //max size of items_
    T items_[DEFAULT_CAPACITY];              // Array of bag items
    int item_count_;                         // Current count of bag items
    int getIndexOf(const T& target) const;


};

template<class T>
Bag<T>::Bag(): item_count_(0)
{
}  // end default constructor

template<class T>
int Bag<T>::getCurrentSize() const
{
    return item_count_;
}  // end getCurrentSize

template<class T>
bool Bag<T>::isEmpty() const
{
    return item_count_ == 0;
}  // end isEmpty


template<class T>
bool Bag<T>::add(const T& new_entry)
{
    bool has_room = (item_count_ < DEFAULT_CAPACITY);
    //bool notDup = items_.getFrequencyOf(new_entry) == 0; 
    if (has_room) //&& notDup) 
    {
        items_[item_count_] = new_entry;
        item_count_++;
        return true;
    }  // end if

    return false;
}  // end add

template<class T>
void Bag<T>::display() const {
    for(int x = 0; x < item_count_;x++)
        cout << items_[x] << ", "; 
}


/**
 @return true if an_etry was successfully removed from items_, false otherwise
 **/
template<class T>
bool Bag<T>::remove(const T& an_entry)
{
   int found_index = getIndexOf(an_entry);
    bool can_remove = !isEmpty() && (found_index > -1);
    if (can_remove)
    {
        item_count_--;
        items_[found_index] = items_[item_count_];
    }  // end if

    return can_remove;
}  // end remove


/**
 @post item_count_ == 0
 **/
template<class T>
void Bag<T>::clear()
{
    item_count_ = 0;
}  // end clear

template<class T>
int Bag<T>::getFrequencyOf(const T& an_entry) const
{
   int frequency = 0;
   int cun_index = 0;       // Current array index
   while (cun_index < item_count_)
   {
      if (items_[cun_index] == an_entry)
      {
         frequency++;
      }  // end if

      cun_index++;          // Increment to next entry
   }  // end while

   return frequency;
}  // end getFrequencyOf

template<class T>
bool Bag<T>::contains(const T& an_entry) const
{
    return getIndexOf(an_entry) > -1;
}  // end contains

template<class T>
std::vector<T> Bag<T>::toVector() const
{
   std::vector<T> bag_contents;
    for (int i = 0; i < item_count_; i++)
        bag_contents.push_back(items_[i]);

   return bag_contents;
}  // end toVector

Answer 1

/******************************************************************************
The error is because of this line items_.getFrequencyOf(new_entry) == 0;
getFrequencyOf is method of class Bag
you are trying to acces it on items which is int in this case.

*******************************************************************************/

#include <iostream>

#include <string>

#include <vector>
using namespace std;

template < class T > class Bag
{
public:
Bag ();
int getCurrentSize () const;
bool isEmpty () const;
bool add (const T & new_entry);   //Modify this
bool remove (const T & an_entry);
/**
@post item_count_ == 0
**/
void clear ();
/**
@return true if an_etry is found in items_, false otherwise
**/
bool contains (const T & an_entry) const;

/**
@return the number of times an_entry is found in items_
**/
int getFrequencyOf (const T & an_entry) const;

/**
@return a vector having the same cotntents as items_
**/
std::vector < T > toVector ()const;

void display () const;   // displays the output

protected:
static const int DEFAULT_CAPACITY = 200;   //max size of items_
T items_[DEFAULT_CAPACITY];   // Array of bag items
int item_count_;       // Current count of bag items
int getIndexOf (const T & target) const;

};

template < class T > Bag < T >::Bag ():item_count_ (0)
{
}               // end default constructor

template < class T > int Bag < T >::getCurrentSize () const const
{
return item_count_;
}               // end getCurrentSize

template < class T > bool Bag < T >::isEmpty () constconst
{
return item_count_ == 0;
}               // end isEmpty

template < class T > bool Bag < T >::add (const T & new_entry)
{
bool has_room = (item_count_ < DEFAULT_CAPACITY);
bool notDup = getFrequencyOf (new_entry) == 0;
if (has_room && notDup)
{
items_[item_count_] = new_entry;
item_count_++;
return true;
}               // end if

return false;
}               // end add

template < class T > void Bag < T >::display () const const
{
for (int x = 0; x < item_count_; x++)
cout << items_[x] << ", ";
}

/**
@return true if an_etry was successfully removed from items_, false otherwise
**/
template < class T > bool Bag < T >::remove (const T & an_entry)
{
int found_index = getIndexOf (an_entry);
bool can_remove = !isEmpty () && (found_index > -1);
if (can_remove)
{
item_count_--;
items_[found_index] = items_[item_count_];
}               // end if

return can_remove;
}               // end remove

/**
@post item_count_ == 0
**/
template < class T > void Bag < T >::clear ()
{
item_count_ = 0;
}               // end clear

template < class T > int Bag < T >::getFrequencyOf (const T & an_entry) const const
{
int frequency = 0;
int cun_index = 0;       // Current array index
while (cun_index < item_count_)
{
if (items_[cun_index] == an_entry)
   {
   frequency++;
   }           // end if

cun_index++;       // Increment to next entry
}               // end while

return frequency;
}               // end getFrequencyOf

template < class T > bool Bag < T >::contains (const T & an_entry) const const
{
return getIndexOf (an_entry) > -1;
}               // end contains

template < class T > std::vector < T > Bag < T >::toVector () constconst
{
std::vector < T > bag_contents;
for (int i = 0; i < item_count_; i++)
bag_contents.push_back (items_[i]);

return bag_contents;
}               // end toVector

using
namespace
std;

int
main ()
{

Bag < int >
bag;
bag.add (1);
bag.add (2);
bag.add (1);
bag.add (3);
bag.display ();

return 0;
}