使用 typeid 来处理不同的类型

Use of typeid to handle different types

本文关键字：类型 处理 typeid 使用      更新时间：2023-10-16

我正在尝试使用 boost：：any 来封装 sqlite 返回值。然后我尝试编写一个循环来打印这些。

我的第一个想法是做这样的事情：

for(boost::any field: row) {
  switch(field.type()) {
      case typeid(double):
          double value = any_cast<double>(field);
          ...
          break;
      case typeid(other type):
          ...
  }
}

现在对于有经验的程序员来说，很明显这是行不通的，因为 typeid 返回的是实例而不是数字 id。经过一些研究，我想我可能会尝试任何一种typeid(...).hash_code()但这还不够constexpr合格（除了哈希碰撞的危险）。

问题

  1. 有没有比构建过多的if ... else ...迷宫更好的方法来根据对象的类型来处理对象？
  2. hash_code不是const_expr有什么原因吗？这是单独编译目标文件的结果吗？
  3. std::type_index有什么用？考虑到它只提供了一些额外的运算符（<、<=、>、>=），为什么不能将其功能与std::type_info集成？

我有一种感觉，你正在寻找提升变体和静态访问。

由于没有提到变体，这可能值得作为答案发布。演示：

住在科里鲁 

#include <sstream>
#include <iostream>
#include <boost/variant.hpp>
using namespace boost;
struct Nil {};
using blob_t = std::vector<uint8_t>;
using field_value_t = boost::variant<Nil, double, char const*, long, blob_t/*, boost::date_time, std::vector<uint8_t>*/>;
struct handler : static_visitor<std::string> {
    std::string operator()(double)      const { return "double"; }
    std::string operator()(char const*) const { return "C string (ew!)"; }
    std::string operator()(long)        const { return "long"; }
    std::string operator()(blob_t)      const { return "long"; }
    std::string operator()(Nil)         const { return "<NIL>"; }
    template<typename T>
    std::string operator()(T const&)    const { throw "Not implemented"; } // TODO proper exception
};
void handle_field(field_value_t const& value) {
    std::cout << "It's a " << apply_visitor(handler(), value) << "n";
}
int main() {
    handle_field({});
    handle_field(blob_t { 1,2,3 });
    handle_field("Hello world");
    handle_field(3.14);
}

指纹

It's a <NIL>
It's a long
It's a C string (ew!)
It's a double

下面是一个类似于 boost::any 上的静态访问的实现，使用 C++11 lambda：

#include <iostream>
#include <type_traits>
#include <boost/any.hpp>
template <size_t, typename...>
struct select_type { };
template <size_t index, typename First, typename... Types>
struct select_type<index, First, Types...> : public select_type<index - 1, Types...> { };
template <typename First, typename... Types>
struct select_type<0, First, Types...>
{
    using type = First;
};
template <typename T>
struct function_traits : public function_traits<decltype(&T::operator())> { };
template <typename Return, typename Class, typename... Args>
struct function_traits<Return (Class::*)(Args...) const>
{
    using result_type = Return;
    template <size_t argN>
    using argument_type = select_type<argN, Args...>;
};
template <typename... Functors>
struct any_call_impl
{
    static bool call(boost::any &, Functors const & ...)
    {
        return false;
    }
    static bool call(boost::any const &, Functors const & ...)
    {
        return false;
    }
};
template <typename FirstFunctor, typename... Functors>
struct any_call_impl<FirstFunctor, Functors...>
{
    static bool call(boost::any & v, FirstFunctor const & first, Functors const & ... rest)
    {
        using arg = typename function_traits<FirstFunctor>::template argument_type<0>::type;
        using arg_bare = typename std::remove_cv<typename std::remove_reference<arg>::type>::type;
        if (v.type() == typeid(arg_bare)) {
            first(*boost::any_cast<arg_bare>(&v));
            return true;
        }
        return any_call_impl<Functors...>::call(v, rest...);
    }
    static bool call(boost::any const & v, FirstFunctor const & first, Functors const & ... rest)
    {
        using arg = typename function_traits<FirstFunctor>::template argument_type<0>::type;
        using arg_bare = typename std::remove_cv<typename std::remove_reference<arg>::type>::type;
        if (v.type() == typeid(arg_bare)) {
            first(*boost::any_cast<arg_bare>(&v));
            return true;
        }
        return any_call_impl<Functors...>::call(v, rest...);
    }
};
template <typename... Functors>
bool any_call(boost::any & v, Functors const & ... f)
{
    return any_call_impl<Functors...>::call(v, f...);
}
template <typename... Functors>
bool any_call(boost::any const & v, Functors const & ... f)
{
    return any_call_impl<Functors...>::call(v, f...);
}
int main(void) {
    boost::any a = 1;
    any_call(a,
        [](double d) { std::cout << "double " << d << std::endl; },
        [](int i) { std::cout << "int " << i << std::endl; }
    );
    return 0;
}

（演示）

这个想法是你传递一个boost::any或boost::any const作为any_call的第一个参数，然后你传递多个lambda。 将调用参数类型与 boost::any 中包含的对象类型匹配的第一个 lambda，然后any_call将返回 true。 如果没有 lambda 匹配，any_call 将返回 false。

相关文章：