7

述語を組み合わせる方法はありますか？

私がこのようなものを持っているとしましょう：

class MatchBeginning : public binary_function<CStdString, CStdString, bool>
{   public:
          bool operator()(const CStdString &inputOne, const CStdString &inputTwo) const
    {   return inputOne.substr(0, inputTwo.length()).compare(inputTwo) == 0;    }
};

int main(int argc, char* argv[])
{
    CStdString myString("foo -b ar -t az"); 

    vector<CStdString> tokens;

    // splits the string every time it encounters a "-"
    split(myString, tokens, "-", true, true);   

    vector<CStdString>::iterator searchResult = find_if(tokens.begin(), tokens.end(), not1(bind2nd(MatchBeginning(), "-")));        

    return 0;
}

これは機能しますが、今は次のようなことをしたいと思います。

searchResult = find_if(tokens.begin(), tokens.end(), bind2nd(MatchBeginning(), "-b") || not1(bind2nd(MatchBeginning(), "-")));

そこで、「-b」で始まる最初の文字列または「-」で始まらない最初の文字列を見つけたいと思います。ただし、これによりエラーが発生します（バイナリ'||'が未定義）。

これを行う方法はありますか？

4

3 に答える 3

5

まあ、仕事をすることができるstd ::logical_orとstd::compose2があります

find_if(tokens.begin(), tokens.end(), 
  compose2(logical_or<bool>(),
    bind2nd(MatchBeginning(), "-b"),
    bind2nd(MatchBeginning(), "-")
  ) 
);

しかし、最終的には boost::lambda や phoenix の方が読みやすく、推奨される解決策だと思います。

クレジットは SGI ドキュメントに移動する必要があります。

于 2009-02-13T14:16:45.573 に答える
5

このようなタスクの関数オブジェクトを組み合わせるには、boost.lambda をお勧めします。このような単純な問題には少し重いですが。(編集) STL を使用した良い例については、xhantt によって開始されたコミュニティ wiki の回答を参照してください。

（古い、非推奨、回答）これには、同様の独自のユーティリティを作成できます。

// here we define the combiner...
template<class Left, class Right>
class lazy_or_impl {
  Left m_left;
  Right m_right;
public:
  lazy_or_impl(Left const& left, Right const& right) : m_left(left), m_right(right) {}
  typename Left::result_type operator()(typename Left::argument_type const& a) const {
    return m_left(a) || m_right(a);
  }
};

// and a helper function which deduces the template arguments
// (thx to xtofl to point this out)
template<class Left, class Right>
lazy_or_impl<Left, Right> lazy_or(Left const& left, Right const& right) {
  return lazy_or_impl<Left, Right>(left, right);
}

そしてそれを使用します：... lazy_or(bind1st(...), bind1st(...)) ...

于 2009-02-13T10:22:27.493 に答える
4

述語を作成したい場合、それを記述する最も適切な方法は、おそらく Boost Lambda または Boost Phoenix を使用することです。

// Lambda way:
// Needs:
// #include <boost/lambda/lambda.hpp>
// #include <boost/lambda/bind.hpp>
{
    using namespace boost::lambda;
    foo_vec::const_iterator it
        = std::find_if(
                    tokens.begin(),
                    tokens.end(),
                    bind(MatchBeginning(), _1, "-b") || !bind(MatchBeginning(), _1, "-")
                    );
}
// Boost bind way:
// Needs:
// #include <boost/bind.hpp>
{
    foo_vec::const_iterator it
        = std::find_if(
                    tokens.begin(),
                    tokens.end(),
                    boost::bind(
                                std::logical_or<bool>(),
                                boost::bind(MatchBeginning(), _1, "-b"),
                                !boost::bind(MatchBeginning(), _1, "-") // ! overloaded in bind
                               )
                    );

Phoenix の場合、可能性の 1 つはフェニックスの遅延関数を使用することであり、解決策は次のようになります。

// Requires:
// #include <boost/spirit/include/phoenix_core.hpp>
// #include <boost/spirit/include/phoenix_function.hpp>
// #include <boost/spirit/include/phoenix_operator.hpp>
namespace phx = boost::phoenix;

struct match_beginning_impl
{
    template <typename Arg1, typename Arg2>
    struct result
    {
        typedef bool type;
    };

    template <typename Arg1, typename Arg2>
    bool operator()(Arg1 arg1, Arg2 arg2) const
    {
        // Do stuff
    }
};
phx::function<match_beginning_impl> match_beginning;

using phx::arg_names::arg1;

foo_vec::const_iterator it
    = std::find_if(
                tokens.begin(),
                tokens.end(),
                match_beginning(arg1, "-b") || !match_beginning(arg1, "-")
                );

ただし、タスクを達成するには、さまざまなツールを使用する方が理にかなっている可能性があります。たとえば、正規表現 (Boost Regex または Boost Xpressive) などです。コマンド ライン オプションを処理する場合は、Boost Program Options を使用します。

于 2009-02-13T10:38:42.413 に答える