检查输入是否等于数组中存在的值

Check if input is equal to a value present in an array?

本文关键字：存在 数组 是否 输入 于数组 检查      更新时间：2023-10-16

我想检查input是否等于数组中的任何选项。我该怎么做？我可以不使用很多||运算符吗？

    //check if any input in herp[] was entered
    string input;
    string herp[2] = {"Merp", "Derp"}
    cin >> input;
    if (input == "connect "+herp[0]||"connect "+herp[1]) {
        cout << "poopie" << endl;
    }

使用 std::find ：

#include <algorithm>
if (std::find(std::begin(herp), std::end(herp), input) != std::end(herp)) {
    cout << "found it!";
}

此外，在 C++11 中，添加了std::any_of。你需要一个谓词函数，这里以lambda的形式出现：

if (std::any_of(std::begin(herp), std::end(herp),
    [&input](const std::string& str) { return str == input; })) {
    cout << "found it!";
}

我还建议您不要使用原始数组，而是使用std::vector或std::array数组。它是否在同一个函数中可能无关紧要，但是当你传递 C 数组时，它们会衰减到指针，然后事情很快就会变得混乱。

考虑将你的数据结构替换为herp;如果你需要对字符串进行排序或以其他方式std::unordered_set，请使用std::set。然后是一个简单的检查，看看是否herp.find(input) != herp.end().与在数组上使用std::find（线性）相比，这些数据结构将为查找操作（分别对数和常数摊销std::set和std::unordered_set）提供更好的复杂性保证。但是，如果您不希望herp的大小增长超过 2，则这些详细信息就不那么重要了。

如果您不需要附加任何内容：

std::string* p = std::find(std::begin(herp), std::end(herp), input);
if (p != std::end(herp))
{
    std::cout << *p << std::endl;
}
else
{
    std::cout << "Not found" << std::endl;
}

如果您确实需要附加某些内容，则有很多不同的选项。 其中之一：

std::vector<std::string> herps;
std::string myAppend(const std::string& a)
{
    return "connect " + a;
}
std::transform(std::begin(herp), std::end(herp), std::back_inserter(herps), myAppend);
std::string* p = std::find(herps.begin(), herps.end(), input);
if (p != herps.end())
{
    std::cout << *p << std::endl;
}
else
{
    std::cout << "Not found" << std::endl;
}

解决方案：

string input;
const int len = 2;
string herp[len] = {"Merp", "Derp"}
cin >> input;
for( int i = 0 ; i < len ; i++){
   if(input == herp [i])
      cout << "poopie" << endl;

为了强调为什么jroc（或Zac）的答案如此强大，以下是如何使用重用来处理追加或潜在的后缀... 请注意，这比每次通过串联创建新字符串要O(1)效率高得多，后者会使整个解决方案O(N)并完全吮吸。

//this function can either be jroc's first or second variant implementation
bool jroc_find(const std::string& input, std::vector<string> array) { .... };
...
int main(...) {
    ...
    string input, search;
    cin >> input;
    string prefix("connect _");
    if (input.substr(0,prefix.length) != prefix )
        return -1; //not found
    else
        search = input.subst(prefix.length, input.length - prefix.length);
    return jroc_find(search, herp);
    ...
}
我想

出了几种方法，

首先，使用自定义函数，

template<typename ValueType, typename ForwardIterator>
bool is_in(ValueType value, ForwardIterator begin, ForwardIterator end) {
    while (begin != end) {
        if (value == *(begin ++)) {
            return true;
        }
    }
    return false;
}
template<typename ValueType, typename ForwardIterator>
bool is_in(ValueType value, ForwardIterator begin, ForwardIterator end) {
    if (begin == end) return false;
    return value == *(begin ++) || is_in(value, begin, end);
}

它们基本上做同样的事情，一个递归地

做，另一个迭代地做。

加上 jrok 的答案，这也行得通，但没有 lambda。

std::any_of(predicates.begin(), predicates.end(), std::bind(std::equal_to<std::string>(), "dance", std::placeholders::_1));

通过使用std::bind我们可以避免使用额外的 lambda。

最后一个假设你只有几个常量谓词，

template<typename Comparable>
bool is_any(Comparable value) {
    return false;
}
template<typename ValueType, typename Comparable, typename... Comparables>
bool is_any(ValueType value, Comparable predicate, Comparables... predicates) {
    return value == predicate || is_any(value, predicates...);
}

你可以这样使用它，

is_any("dance", "apple", "banana", "cat"); // false
相关文章：