2

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

6 回答 6

12

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

于 2013-09-18T18:52:46.490 回答
3

Consider replacing your data structure for herp; use std::set if you need the strings to be ordered or std::unordered_set otherwise. Then it's a simple check to see if herp.find(input) != herp.end(). These data structures will provide you better complexity guarantees for the find operation (logarithmic and constant amortized for std::set and std::unordered_set respectively) over using std::find on an array (linear). However, these details are less important if you don't expect the size of herp to ever grow beyond 2.

于 2013-09-18T18:53:34.003 回答
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;
}
于 2013-09-18T18:56:27.447 回答
1

解决方案：

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;
于 2013-09-18T18:56:38.603 回答
0

为了强调为什么 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);
    ...
}
于 2013-09-18T19:46:02.230 回答
0

我想出了几种方法，

首先，使用自定义函数，

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
于 2015-11-11T09:43:44.280 回答