我与Spirit Qi有另一个阻碍问题。
我在一个名为error_handler的functor结构中实现了错误处理。 这是通过引用传递给语法构造函数的（参见Qi的MiniC示例）。
然后我在语法的构造函数中定义了on_error<fail>：
typedef boost::phoenix::function<error_handler<> > error_handler_function;
on_error<fail>(gr_instruction,
error_handler_function(err_handler)(L"Error: Expecting ", _4, _3));
// more on_error<fail>s...
但是，我的error_handler有私人会员。似乎每次调用on_error时，err_handler对象都会被复制，因此一旦仿函数离开，局部变量就会被破坏。
我尝试通过引用传递处理程序：
typedef boost::phoenix::function<error_handler<>& > error_handler_function; // <--- Note the ampersand!
on_error<fail>(gr_instruction,
error_handler_function(err_handler)(L"Error: Expecting ", _4, _3));
// more on_error<fail>s...
但问题仍然存在：on_error()适用于err_handler的副本，而不是单个实例!!
我还尝试了boost::phoenix::ref(err_handler)的变体，只有编译错误。
当然，通过引用传递处理程序必须有一个简单的解决方案吗？
我很感激任何意见。谢谢你的帮助。
答案 0 :(得分：8)
是的，phx :: bind和phx :: function＆lt;＆gt;默认情况下会按值将其包装类型为calleable。然而。
让我们说 [1] ，你有一个像这样的错误处理程序...极简主义的例子：
template <typename=void> struct my_error_handler {
my_error_handler() = default;
my_error_handler(my_error_handler const&) = delete;
template<typename...> struct result { typedef void type; };
template<typename... T> void operator()(T&&...) const {
std::cerr << "my_error_handler invoked " << proof++ << "\n";
}
mutable int proof = 0;
};
（正如你所看到的那样，我明确地说它是不可复制的，以确保编译器不会在我背后静默生成代码。）
现在，我不确定这是否是你不小心错过的组合，但是：
on_error<fail>(function, phx::bind(phx::ref(err_handler), L"Error: Expecting ", _4, _3));
on_error<fail>(start, phx::bind(phx::ref(err_handler), L"Error: Expecting ", _4, _3));
on_error<fail>(gr_instruction, phx::bind(phx::ref(err_handler), L"Error: Expecting ", _4, _3));
效果很好，
也是如此auto ll = phx::bind(phx::ref(err_handler), L"Error: Expecting ", _4, _3);
on_error<fail>(function, ll);
on_error<fail>(start, ll);
on_error<fail>(gr_instruction, ll);
请注意，因为bind需要引用，我们需要确保err_handler的生命周期匹配（或超过）解析器的生命周期，因此我使err_handler成为解析器类的成员
当我将输入传递给失败时，我的程序将能够打印proof的调用my_error_handler：
std::cout << "The 'proof' in the err_handler instance is: " << p.err_handler.proof << "\n";
与往常一样，一个完全集成的示例程序：
#define BOOST_SPIRIT_USE_PHOENIX_V3
//#define BOOST_SPIRIT_DEBUG
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
namespace qi = boost::spirit::qi;
namespace phx = boost::phoenix;
namespace asmast
{
typedef std::string label;
}
template <typename=void> struct my_error_handler {
my_error_handler() = default;
my_error_handler(my_error_handler const&) = delete;
template<typename...> struct result { typedef void type; };
template<typename... T> void operator()(T&&...) const {
std::cerr << "my_error_handler invoked " << proof++ << "\n";
}
mutable int proof = 0;
};
template <typename It, typename Skipper = qi::blank_type>
struct parser : qi::grammar<It, Skipper>
{
parser() :
parser::base_type(start)
{
using namespace qi;
start = lexeme["Func" >> !(alnum | '_')] > function;
function = gr_identifier
>> "{"
>> -(
gr_instruction
| gr_label
//| gr_vardecl
//| gr_paramdecl
) % eol
> "}";
gr_instruction_names.add("Mov", unused);
gr_instruction_names.add("Push", unused);
gr_instruction_names.add("Exit", unused);
gr_instruction = lexeme [ gr_instruction_names >> !(alnum|"_") ] > gr_operands;
gr_operands = -(gr_operand % ',');
gr_identifier = lexeme [ alpha >> *(alnum | '_') ];
gr_operand = gr_identifier | gr_string;
gr_string = lexeme [ '"' >> *("\"\"" | ~char_("\"")) >> '"' ];
gr_newline = +( char_('\r')
|char_('\n')
);
gr_label = gr_identifier >> ':' > gr_newline;
#if 1
on_error<fail>(function, phx::bind(phx::ref(err_handler), L"Error: Expecting ", _4, _3));
on_error<fail>(start, phx::bind(phx::ref(err_handler), L"Error: Expecting ", _4, _3));
on_error<fail>(gr_instruction, phx::bind(phx::ref(err_handler), L"Error: Expecting ", _4, _3));
#else
auto ll = phx::bind(phx::ref(err_handler), L"Error: Expecting ", _4, _3);
on_error<fail>(function, ll);
on_error<fail>(start, ll);
on_error<fail>(gr_instruction, ll);
#endif
// more on_error<fail>s...
BOOST_SPIRIT_DEBUG_NODES((start)(function)(gr_instruction)(gr_operands)(gr_identifier)(gr_operand)(gr_string));
}
my_error_handler<> err_handler;
private:
qi::symbols<char, qi::unused_type> gr_instruction_names;
qi::rule<It, Skipper> start, function, gr_instruction, gr_operands, gr_operand, gr_string;
qi::rule<It, qi::unused_type()> gr_newline;
qi::rule<It, asmast::label(), Skipper> gr_label, gr_identifier;
};
int main()
{
typedef boost::spirit::istream_iterator It;
std::cin.unsetf(std::ios::skipws);
It f(std::cin), l;
parser<It, qi::blank_type> p;
try
{
bool ok = qi::phrase_parse(f,l,p,qi::blank);
if (ok) std::cout << "parse success\n";
else std::cerr << "parse failed: '" << std::string(f,l) << "'\n";
if (f!=l) std::cerr << "trailing unparsed: '" << std::string(f,l) << "'\n";
std::cout << "The 'proof' in the err_handler instance is: " << p.err_handler.proof << "\n";
return ok;
} catch(const qi::expectation_failure<It>& e)
{
std::string frag(e.first, e.last);
std::cerr << e.what() << "'" << frag << "'\n";
}
return false;
}
输入输入
Func Ident{
Mov name, "hello"
Push 5
Exit
}
打印（作为第一行/最后一行）
my_error_handler invoked 0
my_error_handler invoked 1
...
The 'proof' in the err_handler instance is: 2
[1] 这不是我第一次想象相关代码
答案 1 :(得分：3)
我记得对此有一个深思熟虑，想要检查一下：
当然，
my_error_handler<> err_handler;
phx::function<my_error_handler<> > err_handler_(err_handler);
可以工作（但尝试复制err_handler实例，这不是你想要的）。现在，
phx::function<my_error_handler<> > err_handler_(phx::ref(err_handler));
不会飞（因为my_error<>无法从phx::ref(err_handler)构建）因此，从逻辑上讲，您实际需要做的只是：
namespace P = boost::proto;
phx::function<const phx::actor<P::exprns_::basic_expr<
P::tagns_::tag::terminal,
P::argsns_::term<boost::reference_wrapper<my_error_handler<> > >,
0l>
> > err_handler_;
......与phx::bind完全相同，但语法糖含量更高：
on_error<fail>(function, err_handler_(L"Error: Expecting ", _4, _3));
on_error<fail>(start, err_handler_(L"Error: Expecting ", _4, _3));
on_error<fail>(gr_instruction, err_handler_(L"Error: Expecting ", _4, _3));
现在，对于一些C ++ 11，这可以写得稍微冗长：
my_error_handler<> err_handler;
phx::function<decltype(phx::ref(err_handler))> err_handler_;
使用以下代码查看 Live on Coliru ：
#define BOOST_SPIRIT_USE_PHOENIX_V3
//#define BOOST_SPIRIT_DEBUG
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
namespace qi = boost::spirit::qi;
namespace phx = boost::phoenix;
namespace asmast
{
typedef std::string label;
}
template <typename=void> struct my_error_handler {
my_error_handler() = default;
my_error_handler(my_error_handler const&) = delete;
template<typename...> struct result { typedef void type; };
template<typename... T> void operator()(T&&...) const {
std::cerr << "my_error_handler invoked " << proof++ << "\n";
}
mutable int proof = 0;
};
template <typename It, typename Skipper = qi::blank_type>
struct parser : qi::grammar<It, Skipper>
{
parser() :
parser::base_type(start),
err_handler(),
err_handler_(phx::ref(err_handler))
{
using namespace qi;
start = lexeme["Func" >> !(alnum | '_')] > function;
function = gr_identifier
>> "{"
>> -(
gr_instruction
| gr_label
//| gr_vardecl
//| gr_paramdecl
) % eol
> "}";
gr_instruction_names.add("Mov", unused);
gr_instruction_names.add("Push", unused);
gr_instruction_names.add("Exit", unused);
gr_instruction = lexeme [ gr_instruction_names >> !(alnum|"_") ] > gr_operands;
gr_operands = -(gr_operand % ',');
gr_identifier = lexeme [ alpha >> *(alnum | '_') ];
gr_operand = gr_identifier | gr_string;
gr_string = lexeme [ '"' >> *("\"\"" | ~char_("\"")) >> '"' ];
gr_newline = +( char_('\r')
|char_('\n')
);
gr_label = gr_identifier >> ':' > gr_newline;
#if 0
on_error<fail>(function, phx::bind(phx::ref(err_handler), L"Error: Expecting ", _4, _3));
on_error<fail>(start, phx::bind(phx::ref(err_handler), L"Error: Expecting ", _4, _3));
on_error<fail>(gr_instruction, phx::bind(phx::ref(err_handler), L"Error: Expecting ", _4, _3));
#else
on_error<fail>(function, err_handler_(L"Error: Expecting ", _4, _3));
on_error<fail>(start, err_handler_(L"Error: Expecting ", _4, _3));
on_error<fail>(gr_instruction, err_handler_(L"Error: Expecting ", _4, _3));
#endif
// more on_error<fail>s...
BOOST_SPIRIT_DEBUG_NODES((start)(function)(gr_instruction)(gr_operands)(gr_identifier)(gr_operand)(gr_string));
}
my_error_handler<> err_handler;
phx::function<decltype(phx::ref(err_handler))> err_handler_;
private:
qi::symbols<char, qi::unused_type> gr_instruction_names;
qi::rule<It, Skipper> start, function, gr_instruction, gr_operands, gr_operand, gr_string;
qi::rule<It, qi::unused_type()> gr_newline;
qi::rule<It, asmast::label(), Skipper> gr_label, gr_identifier;
};
int main()
{
typedef boost::spirit::istream_iterator It;
std::cin.unsetf(std::ios::skipws);
It f(std::cin), l;
parser<It, qi::blank_type> p;
try
{
bool ok = qi::phrase_parse(f,l,p,qi::blank);
if (ok) std::cout << "parse success\n";
else std::cerr << "parse failed: '" << std::string(f,l) << "'\n";
if (f!=l) std::cerr << "trailing unparsed: '" << std::string(f,l) << "'\n";
std::cout << "The 'proof' in the err_handler instance is: " << p.err_handler.proof << "\n";
return ok;
} catch(const qi::expectation_failure<It>& e)
{
std::string frag(e.first, e.last);
std::cerr << e.what() << "'" << frag << "'\n";
}
return false;
}