खोज/पुनरावृत्ति बढ़ावा :: भावना :: क्यूई :: प्रतीकों

Question

अगर मैं एक प्रतीक तालिका है:

struct MySymbols : symbols<char, MyEnum::Fruits> 
{ 
    MySymbols() 
     : symbols<char, MyEnum::Fruits>(std::string("MySymbols")) 
    { 
     add("apple", MyEnum::Apple) 
      ("orange", MyEnum::Orange); 
    } 
}; 

मैं आदेश डेटा मान से एक प्रतीक के लिए खोज करने में मेज पर पुनरावृति करना चाहते हैं। मैं लैम्ब्डा भाव उपयोग नहीं कर सकते तो मैं एक साधारण वर्ग कार्यान्वित:

template<typename T> 
struct SymbolSearcher 
{ 
    SymbolSearcher::SymbolSearcher(T searchFor) 
     : _sought(searchFor) 
    { 
     // do nothing 
    } 

    void operator() (std::basic_string<char> s, T ct) 
    { 
     if (_sought == ct) 
     { 
      _found = s; 
     } 
    } 

    std::string found() const { return _found; } 

private: 
    T _sought; 
    std::string _found; 
}; 

और मैं यह उपयोग कर रहा हूँ इस प्रकार है:

SymbolSearcher<MyEnum::Fruits> search(ct); 
MySymbols symbols; 

symbols.for_each(search); 
std::string symbolStr = search.found(); 

अगर मैं _found = s पर एक ब्रेकपाइंट सेट मुझे लगता है कि _found पुष्टि कर सकते हैं सेट हो रही है हालांकि, search.found() हमेशा एक खाली स्ट्रिंग देता है। मैं अनुमान लगा रहा हूं कि इसके लिए फंक्टर को अंदरूनी तरीके से बुलाया जा रहा है, लेकिन मुझे नहीं पता।

मैं क्या गलत कर रहा हूं?

Answer 1

यह हो सकता है कि

• स्ट्रिंग के वास्तविक मूल्य (रिक्त स्ट्रिंग (संभावना नहीं)

• functor मूल्य द्वारा पारित किया जा रहा है, स्टेटफुल functor बेकार बना रही है मूल रूप में राज्य वास्तव में पारित नहीं किया जाएगा)।

आप _found क्षेत्र एक संदर्भ बना सकता है (यदि आप इसे काम करने के लिए नियम-के-तीन सम्मान करने के लिए सुनिश्चित करने के लिए आवश्यकता होती है)। http://liveworkspace.org/code/4qupWC$1

#include <boost/spirit/include/qi.hpp> 

namespace qi  = boost::spirit::qi; 

template<typename T> 
struct SymbolSearcher 
{ 
    SymbolSearcher(T searchFor, std::string& result) : _sought(searchFor), _found(result) 
    { 
    } 

    void operator() (std::basic_string<char> s, T ct) 
    { 
     if (_sought == ct) 
     { 
      _found = s; 
     } 
    } 

    std::string found() const { return _found; } 

private: 
    T _sought; 
    std::string& _found; 
}; 

int main() 
{ 
    const std::string str("mies"); 

    typedef std::string::const_iterator It; 
    It begin = str.cbegin(); 
    It end = str.cend(); 

    qi::symbols<char, int> symbols; 
    symbols.add("aap", 1)("noot", 2)("mies", 3); 

    int out; 
    bool ok = qi::parse(begin, end, symbols, out); 
    assert(ok); 

    std::string found; 
    SymbolSearcher<int> sf(out, found); 
    symbols.for_each(sf); 

    assert(str == sf.found()); 
}