Question

假设我有一个类Element，

class Element {
private:
    int value;
public:
    void setValue(int v) {
        value = v;
    }
    int getValue() {
        return value;
    }
};

我将这个类的对象存储在一个数组中。现在，我如何检查我的对象数组是否包含Element类的某个对象。我尝试使用此函数匹配对象的值...有没有更好的方法？

bool contains(Element e)
{
    int i;

    for(i=0;i<size;i++)
        if(elements[i].getValue()==e.getValue()) return true;
    else return false;
}

Answer 1

您可以使用像std :: array这样的C ++容器，然后使用std :: find_if。

如果您希望扩展代码，可以使用

重载operator==

bool operator==(const Element& lhs, const Element& rhs) {
    return lhs.value == rhs.value
}

然后你可以使用

for(i=0;i<size;i++)
    if(elements[i]==e) return true;

编辑：

由于Element.value是私有的，您可能希望将此方法设为Element

bool Element::operator==(const Element& other) {
    return value == other.value
}

Answer 2

我建议使用像stds::array或std::vector这样的C ++容器来保存您的元素并使用std::find_if来搜索它。

如果您使用的是支持C ++ 11语法的编译器，那么您可以像这样使用std :: find_if：

int main () 
{
    std::vector<Element> myvector;

    // fill vector

   int valueToCompare = 1234;

   auto it = std::find_if(begin(myvector), end(myvector), [=](const Element& e) {return e.getValue() == valueToCompare;});

   return 0;
}

Answer 3

您可以将比较运算符添加到元素类，然后使用stl算法或类似算法来确定元素是否在容器中。

class Element {
private:
    int value;
public:
    Element(int v) : value(v) {}
    Element(Element const& e) : value(e.value) {}

    Element & operator=(Element const& e) {
        value = e.value;
    }

    bool operator==(Element const& e) const {
        return value == e.value;
    }

    bool operator!=(Element const& e) const {
        return value != e.value;
    }

    void setValue(int v) {
        value = v;
    }
    int getValue() {
        return value;
    }
};

现在你可以做这样的事了。

std::vector<Element> elements;

for(int i = 0; i < 10; ++i) {
    elements.push_back(Element(i));
}

 // Find the element with the value 4
auto found = std::find(elements.begin(), elements.end(), Element(4));
if(found != elements.end()) {
    // Do something
}

或者像你描述的那样使用循环。

Element toFind(4);

for(auto it = elements.begin(); it != elements.end(); ++it) {
     if(*it == toFind) {
       // Do something
     }
}

Answer 4

首先，您可以实现等比较运算符

class Element {
private:
    int value;
public:
    // btw. These setters and getters are Java style, not C++ style.
    void setValue(int v) {
        value = v;
    }
    // note that a getter should be const. It doesn't change the object.
    auto getValue() const -> int {
        return value;
    }
    auto operator == (const Element& other) const -> bool {
        return value == other.value;
    }
    auto operator != (const Element& other) const -> bool {
        return !(*this == other);
    }
};

现在你可以使用std :: find（）：

auto contains(const Element& e) -> bool
{
    auto end = elements + size; // pointers can be used as iterators as well.
    return std::find(elements, end, e) != end;
}

您应该比原始数组更喜欢std::vector或std::array。 std::array不会增加任何开销，但会使界面与其他std:: - 容器更加一致。 std::vector用于动态大小的数组。它为您处理所有分配，初始化，销毁，释放等。

Answer 5

虽然上述答案可能对专业程序员有好处，但我相信Adkison，你想要一个更简单的回复。

bool contains(Element e)
{
    int i;

    for(i=0;i<size;i++)
        if(elements[i].getValue()==e.getValue()) return true;
    else return false;
}

好的，所以一个问题是元素没有值，大小也没有。它应该作为参数传入。我们还会使用const＆amp; amp;在e上，所以不需要复制（虽然这不是一个很大的成本）。

bool contains  (const Element elements[], int size, const Element& e) ...

（是的，我们可以将元素作为向量传递，但让我们现在保持简单。）

我相信你注意到的问题是它永远不会过去看第0个元素。追踪，你会明白为什么。假设元素＃0等于e;你的函数返回true，并完成。假设它不相等：你的函数返回false，并且完成了。所有其他元素呢？我们也不应该检查它们，至少如果元素＃0不是我们想要的吗？

所以：当应该时，我们返回false？当我们通过整个列表而未找到e时。

    for(i=0;i<size;i++)
        if(elements[i].getValue()==e.getValue()) return true;

    return false;

这个版本在查看整个数组之前不会返回false，并且找不到e。

c ++：检查对象数组中类的对象

5 个答案: