Throwing a data exception if item passed in array already exists

user_13388503 0
Viewed 328

I am trying to write a function that detects if an item that is passed in an array already exists,

here is a function I already had that would throw an exception if the capacity of the array was exceeded, I am unsure how to write a function that would detect if an item passed in already exists.

template<class ItemType>
void ArraySet<ItemType>::add(const ItemType& newEntry) {
    if (itemCount >= maxItems) {
        throw ExceededCapacityError();
    } else {
        items[itemCount] = newEntry;
        itemCount++;
    }  
}

Update: code compiles but end up getting unhandled exception error

Error: Unhandled exception at 0x74E440B2 in ArraySetV1.exe: Microsoft C++ exception: cs_set::ArraySetstd::basic_string<char,std::char_traits<char,std::allocator > >::DuplicateItemError at memory location 0x00AFF577.

template<class ItemType>
void ArraySet<ItemType>::add(const ItemType& newEntry) {
    auto result1 = std::find(std::begin(items), std::end(items), newEntry);
    if (std::begin(items) == std::end(items)) {
        throw DuplicateItemError();
    } else {    
        items[itemCount] = newEntry;
        itemCount++;
    }  
}

Try / Catch used in main:

    try {
        cout << "Try to add another entry: add(\"extra\")... ";
        set.add("extra");
        cout << "should cause exception but didn't" << endl;
    } catch (ArraySet<string>::DuplicateItemError e) {
        cout << "should cause exception!" << endl;
    }

Here is my first header file:

namespace cs_set {

    template<class ItemType>
    void ArraySet<ItemType>::add(const ItemType& newEntry) {
        auto result1 = std::find(std::begin(items), std::end(items), newEntry);
        if (result1 == std::end(items)) {
            throw DuplicateItemError();
        } else {    //Error
            items[itemCount] = newEntry;
            itemCount++;
        }  
    }  




    template<class ItemType>
    ArraySet<ItemType>::ArraySet() {
        itemCount = 0;
        maxItems = DEFAULT_CAPACITY;
    }





    template<class ItemType>
    int ArraySet<ItemType>::getCurrentSize() const {
        return itemCount;
    }





    template<class ItemType>
    bool ArraySet<ItemType>::isEmpty() const {
        return itemCount == 0;
    }




    template<class ItemType>
    std::vector<ItemType> ArraySet<ItemType>::toVector() const {
        std::vector<ItemType> setContents;
        for (int i = 0; i < itemCount; i++) {
            setContents.push_back(items[i]);
        }
  
        return setContents;
    }




    template <class ItemType>
    bool ArraySet<ItemType>::contains(const ItemType& anEntry) const {
        bool isFound = false;
        int curIndex = 0;
        while (!isFound && (curIndex < itemCount)) {
            isFound = (anEntry == items[curIndex]);
            if (!isFound) {
                curIndex++;
            }
        }

        return isFound;
    }






    template<class ItemType>
    void ArraySet<ItemType>::clear() {
        itemCount = 0;
    }





    template<class ItemType>
    int ArraySet<ItemType>::getIndexOf(const ItemType& target) const {
        bool isFound = false;
        int result = -1;
        int searchIndex = 0;

        while (!isFound && (searchIndex < itemCount)) {
            isFound = (items[searchIndex] == target);
            if (isFound) {
                result = searchIndex;
            } else {
                searchIndex++;
            }
        }

        return result;
    }






    template<class ItemType>
    void ArraySet<ItemType>::remove(const ItemType& anEntry) {
        int locatedIndex = getIndexOf(anEntry);
        if (locatedIndex > -1) {
            itemCount--;
            items[locatedIndex] = items[itemCount];
        } else {
            throw ItemNotFoundError();
        }
    }
 }

Header File:

#ifndef ARRAY_SET_
#define ARRAY_SET_
#include <algorithm>
#include <iterator>
#include "SetInterface.h"

namespace cs_set {
    template<class ItemType>
    class ArraySet : public SetInterface<ItemType>
    {
        public:
            typedef ItemType value_type;
    
            class DuplicateItemError {};
            class ItemNotFoundError {};
    
            ArraySet();
            int getCurrentSize() const;
            bool isEmpty() const;
            void add(const ItemType& newEntry);
            void remove(const ItemType& anEntry);
            void clear();
            bool contains(const ItemType& anEntry) const;
            //int getFrequencyOf(const ItemType& anEntry) const;
            std::vector<ItemType> toVector() const;
        private:
            static const int DEFAULT_CAPACITY = 6;
            ItemType items[DEFAULT_CAPACITY];
            int itemCount;
            int maxItems;

            // Returns either the index of the element in the array items that
            // contains the given target or -1, if the array does not contain 
            // the target.
            int getIndexOf(const ItemType& target) const;   
    };
}

#include "ArraySet.cpp"
#endif

Another Header file:

#ifndef SET_INTERFACE
#define SET_INTERFACE

#include <vector>
#include <algorithm>
#include <iterator>

namespace cs_set {
    template<class ItemType>
    class SetInterface
    {
    public:
       /** Gets the current number of entries in this bag.
        @return  The integer number of entries currently in the bag. */
       virtual int getCurrentSize() const = 0;

       /** Sees whether this bag is empty.
        @return  True if the bag is empty, or false if not. */
       virtual bool isEmpty() const = 0;

       /** Adds a new entry to this bag.
        @post  If successful, newEntry is stored in the bag and
           the count of items in the bag has increased by 1.
        @param newEntry  The object to be added as a new entry.
        @return  True if addition was successful, or false if not. */
       virtual void add(const ItemType& newEntry) = 0;

       /** Removes one occurrence of a given entry from this bag,
           if possible.
        @post  If successful, anEntry has been removed from the bag
           and the count of items in the bag has decreased by 1.
        @param anEntry  The entry to be removed.
        @return  True if removal was successful, or false if not. */
       virtual void remove(const ItemType& anEntry) = 0;

       /** Removes all entries from this bag.
        @post  Bag contains no items, and the count of items is 0. */
       virtual void clear() = 0;

       /** Counts the number of times a given entry appears in this bag.
        @param anEntry  The entry to be counted.
        @return  The number of times anEntry appears in the bag. */
      // virtual int getFrequencyOf(const ItemType& anEntry) const = 0;

       /** Tests whether this bag contains a given entry.
        @param anEntry  The entry to locate.
        @return  True if bag contains anEntry, or false otherwise. */
       virtual bool contains(const ItemType& anEntry) const = 0;

       /** Empties and then fills a given vector with all entries that
           are in this bag.
        @return  A vector containing all the entries in the bag. */
       virtual std::vector<ItemType> toVector() const = 0;

       /** Destroys this bag and frees its assigned memory. (See C++ Interlude 2.) */
       virtual ~SetInterface() { }
    };
}
#endif

Main file:

#include <iostream>
#include <string>
#include "ArraySet.h"

using std::cout;
using std::endl;
using std::string;
using namespace cs_set;

void displaySet(ArraySet<string>& set) {
   cout << "The set contains " << set.getCurrentSize()
        << " items:" << endl;
   std::vector<string> setItems = set.toVector();

   int numEntries = setItems.size();
   for (int i = 0; i < numEntries; i++) {
      cout << setItems[i] << " ";
   }
   cout << endl << endl;
}




void setTester(ArraySet<string>& set)
{
    cout << "isEmpty: returns " << set.isEmpty()
         << "; should be 1 (true)" << endl;
    displaySet(set);

    std::string items[] = {"one", "two", "three", "four", "five", "one"};
    cout << "Add 6 items to the set: " << endl;
    for (int i = 0; i < 6; i++) {
        set.add(items[i]);
    }

    displaySet(set);

    cout << "isEmpty: returns " << set.isEmpty()
         << "; should be 0 (false)" << endl;

    cout << "getCurrentSize: returns " << set.getCurrentSize()
         << "; should be 6" << endl;

    try {
        cout << "Try to add another entry: add(\"extra\")... ";
        set.add("extra");
        cout << "should cause exception but didn't" << endl;
    } catch (ArraySet<string>::DuplicateItemError e) {
        cout << "should cause exception and did!" << endl;
    }
 displaySet(set);

 }


int main()
{
    ArraySet<string> set;
    cout << "Testing the Array-Based Set:" << endl;
    cout << "The initial set is empty." << endl;
    setTester(set);
    cout << "All done!" << endl;
}
class exception arrays c++
2 Answers

This seem like a possible use case for std::find as you mentioned c++ and not c I would propose something like


#include <algorithm>
#include <array>
#include <iterator>
void search(int val){
    std::array<int,5> v{0, 1, 2, 3, 4};
    auto result1 = std::find(std::begin(v), std::end(v), val);
}

then if the iterator is equal with std::end(v) then you can throw whatever exception you like

user_107555220

The most trivial approach would be to iterate over every existing element and throw an Exception / return false when you find it. Otherwise you can add it.

Though i'd recommend to use sorted Lists (e.g.: std::set) if you can live with a changed order of Elements.

user_117529070
Related