Question

我想检查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;
    }

Answer 1

使用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数组时，它们会衰减到指针然后很快就会变得混乱。

Answer 2

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

Answer 3

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

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

Answer 4

解决方案：

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;

Answer 5

为了突出为什么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);
    ...
}

Answer 6

我提出了几种方法，

首先，使用自定义功能

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

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

6 个答案: