Searching/Iterieren boost :: spirit :: Qi :: Symbole

Question

Wenn ich eine Symboltabelle haben:

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

Ich möchte über den Tisch, um iterieren für ein Symbol durch den Datenwert zu suchen. Ich kann nicht Lambda-Ausdrücke verwenden, so dass ich eine einfache Klasse implementiert:

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

Und ich verwende es wie folgt:

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

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

Wenn ich einen Haltepunkt auf _found = s stelle ich, dass _found bestätigen kann eingestellt zu werden , search.found() gibt jedoch immer eine leere Zeichenfolge zurück. Ich vermute, es hat etwas damit zu tun, wie der Funktor innerhalb von for_each aufgerufen wird, aber ich weiß es nicht.

Was mache ich falsch?

Answer 1

Es könnte sein, dass

• der Ist-Wert des Strings ist die leere Zeichenkette (unwahrscheinlich)

• der Funktor Wert übergeben wird, so dass die Stateful Funktors nutzlos (wie das Original Staat wird nicht wirklich übergeben).

Sie könnten das _found Feld eine Referenz (die Sie auffordert, um sicherzustellen, dass die Regel-of-Three zu respektieren, damit es funktioniert) machen.

Hier ist ein Beweis dafür, dass das Prinzip der Behauptung das Ergebnis einer Rundfahrt über SymbolSearcher zeigt: 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()); 
}