如何将 boost::any 打印到流？

Question

我有一个地图 std::map，它来自 boost::program_options 包。现在我想打印该地图的内容：

for(po::variables_map::const_iterator it = vm.begin(); it != vm.end(); ++it) {
  std::cerr << it->first << ": " << it->second << std::endl;
}

不幸的是，这是不可能的，因为 boost::any 没有定义 operator<< 。

打印该地图最简单的方法是什么？

我可以为任何自动尝试将每个 any 转换为 int、然后是 double、然后是字符串等定义自己的输出运算符，每次都会忽略错误并尝试进行转换，直到转换成功为止我可以按照指定的类型打印。

但是Boost中应该有更简单的方法吧？我需要类似反向 lexical_cast 的东西...

Answer 1

您可以使用 boost::spirit::hold_any 代替。它在这里定义：

#include <boost/spirit/home/support/detail/hold_any.hpp>

并且与 boost::any 完全兼容。与 boost::any 相比，此类有两个不同之处：

• 它利用小对象优化习惯和一些其他优化技巧，使 spirit::hold_any 更小、更快与 boost::any 相比，
• 它定义了流运算符（operator<<() 和 operator>>()），允许无缝输入和输出spirit::hold_any。

唯一的限制是您不能输入空的 spirit::hold_any，但它需要保存输入所期望的类型的实例（可能是默认构造的）。

Answer 2

如果您可以将 boost::any 更改为其他类型，则可以使用 Boost.TypeErasure。如果您曾经想要创建一个类似于 any 的类型，但仅支持在编译时支持这些特定操作的类型，那么这正适合您。

#include <boost/type_erasure/operators.hpp>
#include <boost/type_erasure/any.hpp>
#include <boost/mpl/vector.hpp>
#include <random>
#include <iostream>

namespace te = boost::type_erasure;

typedef te::any<boost::mpl::vector<
    te::copy_constructible<>,
    te::destructible<>,
    te::ostreamable<>
>> streamable_any;

int main()
{
    streamable_any i(42);
    streamable_any d(23.5);
    std::mt19937 mt;
    streamable_any r(mt);
    std::cout << i << "\n" << d << "\n" << r << "\n";
}

在 Coliru 上直播

Answer 3

不幸的是，对于 any ，唯一的方法是使用 type() 方法来确定 any 中包含的内容，然后使用 type() 对其进行强制转换>任意广播。显然，您必须启用 RTTI，但如果您使用any，则可能已经启用了 RTTI：

for(po::variables_map::const_iterator it = vm.begin(); it != vm.end(); ++it) {
  if(typeid(float) == it->second.type()) {
      std::cerr << it->first << ": " << any_cast<float>(it->second) << std::endl;
  }
  else if(typeid(int) == it->second.type()) {
      std::cerr << it->first << ": " << any_cast<int>(it->second) << std::endl;
  }
  ...
}

Answer 4

定义一些辅助函数来输出到流：

template<class T>
bool out_to_stream(std::ostream& os, const boost::any& any_value)
{
    try {
        T v = boost::any_cast<T>(any_value);
        os << v;
        return true;
    } catch(boost:: bad_any_cast& e) {
        return false;
    }
}

您可以为某些类型定义特殊格式

template<>
bool out_to_stream<std::string>(std::ostream& os, const boost::any& any_value)
{
    try {
        std::string v(std::move(boost::any_cast<std::string>(any_value)));
        os << "'" << v << "'";
        return true;
    } catch(boost:: bad_any_cast& e) {
        return false;
    }
}

或

template<>
bool out_to_stream<bool>(std::ostream& os, const boost::any& any_value)
{
    try {
        os << ((boost::any_cast<bool>(any_value))? "yes" : "no");
        return true;
    } catch(boost:: bad_any_cast& e) {
        return false;
    }
}

然后为 boost::any 定义一个输出运算符，其中列出您想要尝试转换和输出的所有类型

std::ostream& operator<<(std::ostream& os, const boost::any& any_value)
{
    //list all types you want to try
    if(!out_to_stream<int>(os, any_value))
    if(!out_to_stream<double>(os, any_value))
    if(!out_to_stream<bool>(os, any_value))
    if(!out_to_stream<std::string>(os, any_value))
        os<<"{unknown}"; // all cast are failed, an unknown type of any
    return os;
}

并且那么对于 value_type：

std::ostream& operator<<(std::ostream& os, const boost::program_options::variable_value& cmdline_val)
{
    if(cmdline_val.empty()){
        os << "<empty>";
    } else {
        os<<cmdline_val.value();
        if(cmdline_val.defaulted()) 
            os << "(default)";
    }
    return os;
}

Answer 5

其他答案中提出的类型开关列表可以通过使用 Boost MPL 的类型列表循环来改进（请参阅 mpl::for_each 和 mpl::vector）。以下代码为类型列表 SupportedTypes 中给定的任何 boost::any 定义一个运算符<<，否则抛出异常。

#include <stdexcept>
#include <iostream>
#include <string>

#include <cstdint>

#include <boost/any.hpp>
#include <boost/mpl/for_each.hpp>
#include <boost/mpl/vector.hpp>

class StreamInserter
{
private:
    std::ostream& os_;
    const boost::any &v_;
    mutable bool has_printed_;

public:
    struct UnsupportedType {};

    StreamInserter(std::ostream& os, const boost::any &v)
        : os_(os), v_(v), has_printed_(false) {}

    template <typename T>
    void operator()(const T&) const
    {
        if (!has_printed_ && v_.type() == typeid(T))
        {
            os_ << boost::any_cast<T>(v_);
            has_printed_ = true;
        }
    }

    void operator()(const UnsupportedType&) const
    {
        if (!has_printed_)
            throw std::runtime_error("unsupported type");
    }
};

std::ostream& operator<<(std::ostream& os, const boost::any& v)
{
    typedef boost::mpl::vector<float, double, int8_t, uint8_t, int16_t, uint16_t,
            int32_t, uint32_t, int64_t, uint64_t, std::string, const char*,
            StreamInserter::UnsupportedType> SupportedTypes;
    StreamInserter si(os, v);
    boost::mpl::for_each<SupportedTypes>(si);
    return os;
}

int main(int, char**)
{
    std::cout << boost::any(42.0) << std::endl;
    std::cout << boost::any(42) << std::endl;
    std::cout << boost::any(42UL) << std::endl;
    std::cout << boost::any("42") << std::endl;
    std::cout << boost::any(std::string("42")) << std::endl;
    std::cout << boost::any(bool(42)) << std::endl; // throws exception
}

Answer 6

我认为你必须涵盖你必须打印的对象的每种可能情况......或者使用 boost::variant。

编辑：抱歉，我想我应该写为什么。

我认为这是因为，查看任何源代码，它似乎依赖于您在插入和获取数据时提供类型的事实。当您插入时，编译器会自动检测数据，因此您不必指定它。但是当你获取数据时，你应该使用any_cast，因为你不确定你得到的数据类型。

如果它以不同的方式工作并且数据类型是确定的，我认为就不需要 any_cast :)

相反，变体有一组有限的可能数据类型，并且此信息在某种程度上已注册，使您能够迭代变体容器的通用方式。

如果您需要这种操作 - 迭代一组通用值 - 我认为您应该使用变体。

Answer 7

尝试使用 xany https://sourceforge.net/projects/extendableany/?source=directory xany 类允许向任何现有功能添加新方法。顺便说一下，文档中有一个示例，它完全可以满足您的需求。

Answer 8

我没有重写我的类来使用 boost::spirit::hold_any，而是创建了一种流 boost::any 的方法，类似于 清单，但只在一处。

ostream& operator<<(ostream& _os, const boost::any& _any)
{
  // only define simple type conversions
  if (_any.type() == typeid(int))
    _os << boost::any_cast<int>(_any);

   /*any other types you use...*/
}

虽然相当麻烦，但它允许我在代码中的任何位置传输 boost::any 变量。

能够从 boost:any 构造 boost::spirit::hold_any 怎么样？

Answer 9

这次聚会有点晚了，但任何感兴趣的人都可以使用 std::tuple 和类似 std::for_each 的模板来迭代元组。

这是基于 ingomueller.net 在此线程中的答案。

我最近有一个案例，我创建了一个属性映射（从 XML 文件读取配置值，主要是基本类型，并将它们插入到 std::unordered_map 中，其中值类型为 any。出于调试目的，我希望能够打印整个映射及其键和值以及值的类型。

在该项目中，我根本没有使用 Boost。 ，我使用了自己的 any 实现，但它与 boost::any 非常相似。

插入运算符基本上如下所示：

template <typename TChar>
inline std::basic_ostream<TChar>&
operator<< (std::basic_ostream<TChar>& os, const sl::common::any& v)
{
    // Types that we support with sl::common::any.
    std::tuple<
        float, double, bool, 
        int8_t, uint8_t, 
        int16_t, uint16_t,
        int32_t, uint32_t, 
        int64_t, uint64_t,
        std::wstring, const wchar_t*,
        StreamInserter::UnsupportedType> t;

    // Prepare ostream for printing a value of type any
    StreamInserter si(os, v);

    // Iterate over all types in tuple t. If the last type(UnsupportedType) is
    // reached, given v is unsupported.
    for_each(t, si);
    return os;
}

for_each 模板如下所示 (C++14)：

template <typename Tuple, typename F, std::size_t ...Indices>
constexpr void for_each_impl(Tuple&& tuple, F&& f, std::index_sequence<Indices...>) {
    using swallow = int[];
    (void)swallow{1,
        (f(std::get<Indices>(std::forward<Tuple>(tuple))), void(), int{})...
    };
}

template <typename Tuple, typename F>
constexpr void for_each(Tuple&& tuple, F&& f) {
    constexpr std::size_t N = std::tuple_size<std::remove_reference_t<Tuple>>::value;
    for_each_impl(std::forward<Tuple>(tuple), std::forward<F>(f),
                  std::make_index_sequence<N>{});
}

有了这个，只需使用StreamInserter 类或 Ingos 答案中显示的类似内容

希望有所帮助。