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が追加されました。ここではラムダの形式で、述語関数が必要になります。

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

のデータ構造を置き換えることを検討してくださいherp。std::set文字列を並べ替える必要がある場合などに使用しstd::unordered_setます。次に、 かどうかを確認する簡単なチェックですherp.find(input) != herp.end()。これらのデータ構造は、配列 (線形)で使用するよりも、検索操作 (対数およびstd::setと でstd::unordered_setそれぞれ償却される定数) の複雑さを保証します。ただし、 のサイズが2 を超えることがstd::find予想されない場合、これらの詳細はそれほど重要ではありません。herp

于 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

私はいくつかのアプローチを思いついた、

まず、カスタム関数で、

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

それらは基本的に同じことを行います。1 つは再帰的に、もう 1 つは反復的に行います。

jrokの答えに加えて、これもうまくいきますが、ラムダはありません。

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

を使用std::bindすることで、追加のラムダの使用を避けることができます。

最後の例では、一定の述語がいくつかあることを前提としています。

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 に答える
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 に答える