我有一个由几种类型组成的boost::variant
,包括字符串类型别名和字符串类型。字符串类型别名的工作方式与boost::spirit::qi
替代解析器相同,但boost::spirit::karma
替代生成器不仅以不需要的方式工作,而且以意外的方式工作,不使用所需的字符串类型别名生成器规则,而且当变体包含字符串类型时,甚至不使用内置的字符串生成器:
#include <iostream>
#include <iterator>
#include <string>
#include <vector>
#include <boost/spirit/include/karma.hpp>
using mode = std::string;
using alt_variant = boost::variant<mode, std::string, unsigned>;
using alt_variant_without_string = boost::variant<mode, unsigned>;
template <typename OutputIterator>
boost::spirit::karma::rule<OutputIterator, mode()>
mode_gen{
boost::spirit::karma::lit("mode="") <<
boost::spirit::karma::string
<< boost::spirit::karma::lit(""")
};
int main(int argc, char *argv[]) {
alt_variant foo1{mode{"bar"}};
alt_variant_without_string foo2{mode{"bar"}};
std::string output;
using namespace boost::spirit::karma;
const auto gen = mode_gen<std::back_insert_iterator<std::string>> | uint_ | string;
boost::spirit::karma::generate(std::back_inserter(output), gen, foo1);
std::cout << "Output"" << output << ""n"; //Output""
output.clear();
boost::spirit::karma::generate(std::back_inserter(output), gen, foo2);
std::cout << "Output"" << output << ""n";//Output"mode="bar""
return 0;
}
有人可以解释这种行为,以及我是如何获得想要的行为的吗?
对于后面的,我想,我必须摆脱所有字符串类型别名并使用显式结构作为类型,但随后我再次陷入丑陋的一成员结构极端情况。( https://codereview.stackexchange.com/q/206259/95143 然而,第一个输出至少不仅仅是"bar",即当模式生成器也没有使用字符串生成器时,对我来说看起来像一个错误,即我无法理解。
从哪里开始。
A. 未指明的行为
这实际上可能是未定义的行为,但我没有检查文档。
类型别名不会创建新类型。因此typeid(std::string) == typeid(mode)
变体无法区分这两种元素类型。
变量的行为未指定。比较:住在科里鲁
boost::variant<mode, std::string> v;
并生活在科里鲁
boost::variant<int, mode, std::string> v;
B. 未定义的行为
然后你做
const auto gen = mode_gen<std::back_insert_iterator<std::string> > | uint_ | string;
与 Qi 相同:原始表达式通过引用保存规则操作数,这意味着auto
是一个坏主意:
- 提升精神语法行为不一致 boost::spirit::
- qi::p hrase_parse 中的某个地方未定义的行为
使用 UBSan/ASan 运行您的代码,并使用 Valgring 在此类错误消耗客户数据之前捕获此类错误。
问题所在
你的问题是你想要可以打开的表达类型。我认为Java主义者喜欢称之为抽象数据类型。这是一个崇高的目标,您可以:
解决方案 1
使mode
成为自定义类型:
住在科里鲁
#include <boost/spirit/include/karma.hpp>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>
struct mode : std::string {
using std::string::string;
};
namespace karma = boost::spirit::karma;
template <typename Out = boost::spirit::ostream_iterator>
karma::rule<Out, mode()> mode_gen = "mode="" << karma::string << """;
int main() {
using Variant = boost::variant<mode, std::string, unsigned>;
Variant foo = std::string("foo"),
bar = mode("bar"),
i = 42;
for (Variant v : { foo, bar, i })
std::cout << "Output: " << format(mode_gen<> | karma::uint_ | karma::string, v) << "n";
}
指纹
Output: foo
Output: mode="bar"
Output: 42
解决方案#2:强大的类型定义
我无法立即完成这项工作,所以让我只指出一个示例实现:
#include <boost/serialization/strong_typedef.hpp>
解决方案#3:区分std::string
您可以使用黑客:
namespace hack {
template <typename Char, typename Tag>
struct my_traits : std::char_traits<Char> {};
}
using mode = std::basic_string<char, hack::my_traits<char, struct ModeTag> >;
那仍然打印相同的Live On Coliru上
Output: foo
Output: mode="bar"
Output: 42
奖金
您的生成器有问题。具体来说,如果您的mode
值包含报价,事情就会出错。您可以简单地利用ostream
:
struct mode : std::string {
using std::string::string;
friend std::ostream& operator<<(std::ostream& os, mode const& m) {
return os << "mode=" << std::quoted(m);
}
};
这样一个简单的
std::cout << mode("yo") << std::endl;
std::cout << mode("y"!"o") << std::endl;
将打印Live On Coliru
mode="yo"
mode="y"!"o"
这要优雅得多。这也意味着你可以用karma::stream
替换所有的业力语法:
住在科里鲁
#include <boost/spirit/include/karma.hpp>
#include <iostream>
#include <iomanip>
struct mode : std::string {
using std::string::string;
friend std::ostream& operator<<(std::ostream& os, mode const& m) {
return os << "mode=" << std::quoted(m);
}
};
int main() {
boost::variant<mode, std::string, unsigned>
foo = std::string("foo"),
bar = mode("bar"),
i = 42;
for (auto v : { foo, bar, i })
std::cout << "Output: " << karma::format(karma::stream, v) << "n";
}
我喜欢它,当越来越少的代码做越来越多的事情时。但按照这个速度,人们想知道为什么还要使用
karma
?
奖金#2 - ADL 它,谁需要业力
为了使它与my_traits
方法和标签类型大放异彩,请将与参数相关的查找发挥到最大:
住在科里鲁
#include <boost/variant.hpp>
#include <iostream>
#include <iomanip>
namespace hack {
template <typename Char, typename Tag>
struct my_traits : std::char_traits<Char> {};
}
namespace mylib {
struct ModeTag{};
struct ValueTag{};
static inline std::ostream& operator<<(std::ostream& os, ModeTag) { return os << "mode"; }
static inline std::ostream& operator<<(std::ostream& os, ValueTag) { return os << "value"; }
template <typename Char, typename Tag>
static inline std::ostream& operator<<(std::ostream& os, hack::my_traits<Char, Tag>)
{ return os << Tag{}; }
template <typename Char, typename CharT, typename Alloc>
std::ostream& operator<<(std::ostream& os, std::basic_string<Char, CharT, Alloc> const& s) {
return os << CharT{} << "=" << std::quoted(s);
}
}
using mode = std::basic_string<char, hack::my_traits<char, struct mylib::ModeTag> >;
using value = std::basic_string<char, hack::my_traits<char, struct mylib::ValueTag> >;
int main() {
boost::variant<mode, value, unsigned>
foo = value("foo"),
bar = mode("bar"),
i = 42;
std::cout << foo << std::endl;
std::cout << bar << std::endl;
std::cout << i << std::endl;
}
它的编译速度提高了 10 倍,并打印:
value="foo"
mode="bar"
42