如果数组中传递的项目已经存在，则抛出数据异常

Question

我正在尝试编写一个函数来检测数组中传递的项是否已经存在，

这是我已经拥有的一个函数，如果超出数组的容量，它会抛出异常，我不确定如何编写一个函数来检测传入的项目是否已经存在。

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

更新：代码编译但最终得到未处理的异常错误

错误：ArraySetV1.exe 中 0x74E440B2 处未处理的异常：Microsoft C++ 异常：cs_set::ArraySetstd::basic_string>::DuplicateItemError 在内存位置 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 在 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;
    }

这是我的第一个头文件：

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();
        }
    }
 }

头文件：

#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

另一个头文件：

#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

主文件：

#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;
}

Answer 1

这似乎是std::find 的一个可能用例，正如你提到的 c++ 而不是 c 我会提出类似的建议

#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);
}

如果迭代器等于std::end(v)，那么你可以抛出任何你喜欢的异常

Answer 2

最简单的方法是遍历每个现有元素并在找到它时抛出异常/返回 false。否则你可以添加它。

虽然我建议使用排序列表（例如：std::set），但如果您可以接受更改的元素顺序。