c++函数式编程（ boost::phoenix && boost::spirit）测试指针占位符中的空指针

Question

因此，我有以下精神业力规则主体：

base_rule = 
    eps(_r1 != 0) [ // _r1 is a pointer_typed placeholder
        eps
    ]
;

这会导致来自 g++ 的相当长的错误消息，该消息（有帮助地）以以下内容结尾：

/opt/dev_64_swat/Boost/include/boost/spirit/home/phoenix/operator/comparison.hpp
:37:5: error: ISO C++ forbids comparison between pointer and integer 
[-fpermissive]

This is valid c++:

struct zebra{};

int main()
{
  zebra * x;
  if( x == 0);  
}

Ithought to try boost::phoenix::static_cast_<_r1_type * >(0) 以及将 _r1_type 转换为整数（是的，这是错误的，这只是一个实验）。

问题：

如何使用spirit eps 构造对占位符执行指针测试，以防止点为零时规则体评估？

与所有“C++ 函数式编程库的使用”问题一样，我希望答案会让我感觉自己像个傻瓜。

答案

Ildjam 的观点直接回答了我的问题。我的问题有两个问题；上面有一个间接的问题。这与 PEG 中的条件有关。我想要表达的内容应该这样写：

rule = ( eps(_r) << ( /* grammar for when pointer is not null */ ) ) 
    | eps // otherwise dont do anything.
;

我使用语义动作主体（在 [] 块中指定）来表达语法的条件部分。奇怪的是，虽然我以前写过条件PEG语法，但我只是犯了一个错误，这导致了第二类问题。

因此， eps(_r1) 可以解决问题，第二种编译问题与问题无关。

Answer 1

这是 C++03 中 C++ 类型系统的一个基本问题。 值 0 很特殊，可以用在许多类型、int 不能使用的地方。这个问题很容易证明，并且在模板和指针结合时会导致很多问题。

void f(int i) {
    void* ptr = ...;
    if (ptr == i) { // MALFORMED
    }
}

f(0); // But I'm trying to compare with 0, which is legit!

template<typename T, typename Y> T construct_from(const Y& y) {
    return T(y);
}
construct_from<void*>(0); // ERROR, cannot construct ptr from int.

最简单的解决方案是编写 nullptr 的快速版本，可以在 C++0x 中找到它。

struct nullptr_t {
    template<typename T> operator T*() const {
        return 0;
    }
};

Answer 2

正如我的评论中所建议的，使用隐式指针到 bool 转换对于我来说在 Boost 1.46.1 中开箱即用。以下是一个最小的重现，其中当（且仅当）p != 0 && 时，parse 成功。 input == "not null" 或 p == 0 && input == "null"：

#include <string>
#include <ios>
#include <ostream>
#include <iostream>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>

namespace spirit = boost::spirit;
namespace qi = spirit::qi;

struct test_grammar : qi::grammar<std::string::const_iterator, void(int*)>
{
    test_grammar() : base_type(start_)
    {
        start_
            =   (   spirit::eps(spirit::_r1)
                    >> "not null"
                |   spirit::eps(!spirit::_r1)
                    >> "null"
                )
                >> spirit::eoi
            ;
    }

private:
    qi::rule<base_type::iterator_type, base_type::sig_type> start_;
};
test_grammar const test;

int main()
{
    int i = 42;
    int* p = &i;                          // alternatively, = 0;
    std::string const input = "not null"; // alternatively, = "null";

    std::string::const_iterator first = input.begin();
    std::cout
        << std::boolalpha
        << "parse succeeded: "
        << qi::parse(first, input.end(), test(p))
        << std::endl;
}

因此，无论您在尝试以这种方式使用隐式转换时遇到什么问题，它都必须特定于您的代码；即，您必须显示更多代码才能获得任何有用的反馈。