在编译时迭代检查函数是否存在

Question

关于我现在面临的一个问题，我有一个问题。在C ++中，我创建了一个帮助程序，能够检测给定模板方法的模板参数是否实现了serialize方法（boost序列化实现）。帮助程序可以完美地与我可以抛出的大多数类一起工作，但是我想扩展它的功能如下。

让我们假设我有一个Foo类，它具有serialize方法。我希望我可以传递任何嵌套支持的容器vector<list<array<Foo,8>>>，因为vector，list和array提供serialize方法。

如何迭代地将包含的类型更深入到不实现value_type成员的类型？

先感谢您

在这里，您可以获得我当前的解

namespace check
{
///A set of classes and struct to be sure the serialised object is either trivial or implementing custom serialize
template <class Type, class Archive, typename = typename std::enable_if<std::is_class<Type>::value>::type>
class is_boost_serializable
{
 private:
  struct TypeOverloader {
    void serialize(Archive& ar, const unsigned int version) {}
  };
  struct TypeExt : public Type, public TypeOverloader {
  };
  template <typename T, T t>
  class DeductionHelper
  {
  };

  class True
  {
    char m;
  };
  class False
  {
    True m[2];
  };

  template <typename TestType>
  static False deduce(TestType*, DeductionHelper<void (TypeOverloader::*)(), &TestType::serialize>* = 0);
  static True deduce(...);

 public:
  static const bool value = (sizeof(True) == sizeof(deduce((TypeExt*)(0))));
};
} // namespace check

Answer 1

#include <utility>
#include <type_traits>

template <typename...>
using void_t = void;

template <typename Type, typename Archive, typename = void_t<>>
struct is_boost_serializable : std::false_type {};

template <typename Type, typename Archive>
struct is_boost_serializable<Type, Archive,
    void_t<decltype(std::declval<Type&>().serialize(std::declval<Archive&>(), 0))>>
    : std::true_type {};

template <typename Type, typename Archive, typename = void_t<>>
struct nested_is_boost_serializable
    : is_boost_serializable<Type, Archive> {};

template <typename Type, typename Archive>
struct nested_is_boost_serializable<Type, Archive, void_t<typename Type::value_type>>
    : nested_is_boost_serializable<typename Type::value_type, Archive> {};

DEMO

Answer 2

根据Piotr非常棒的建议，我已经扩展了他的解决方案，以便与boost trivially serialisable类型兼容（int，char，double ...）。

在我的定制解决方案之后。

干杯谢谢！

#include <type_traits>
#include <utility>
#include <vector>
#include <list>
#include <array>
#include <cassert>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/serialization/is_bitwise_serializable.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/array.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/list.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/set.hpp>
#include <boost/type_traits.hpp>

struct Arc
{
};

struct Foo
{
    int pippo = 0;

    friend class boost::serialization::access;

    template <class Archive>
    void serialize(Archive &ar, const unsigned int version)
    {
        ar &pippo;
    }
};

struct Bar
{
};

template <typename...>
using void_t = void;

template <typename Type, typename Archive = boost::archive::binary_oarchive, typename = void_t<>>
struct is_boost_serializable_base : std::false_type
{
};

template <class Type, typename Archive>
struct is_boost_serializable_base<Type, Archive,
                                  void_t<decltype(std::declval<Type &>().serialize(std::declval<Archive &>(), 0))>>
    : std::true_type
{
};

template <typename Type, typename Archive>
struct is_boost_serializable_base<Type, Archive,
                                  typename std::enable_if<boost::serialization::is_bitwise_serializable<Type>::value>::type>
    : std::true_type
{
};

template <typename Type, typename Archive = boost::archive::binary_oarchive, typename = void_t<>>
struct is_boost_serializable
    : is_boost_serializable_base<Type, Archive>
{
};

template <typename Type, typename Archive>
struct is_boost_serializable<Type, Archive, void_t<typename Type::value_type>>
    : is_boost_serializable<typename Type::value_type, Archive>
{
};

template <typename Type>
struct is_boost_serializable<Type, boost::archive::binary_oarchive, void_t<typename Type::value_type>>
    : is_boost_serializable<typename Type::value_type, boost::archive::binary_oarchive>
{
};

int main()
{
    static_assert(is_boost_serializable<Foo, Arc>::value, "!");
    static_assert(is_boost_serializable<std::vector<std::list<std::array<Foo, 8>>>, Arc>::value, "!");
    static_assert(is_boost_serializable<std::vector<std::list<std::array<int, 8>>>, Arc>::value, "!");
    static_assert(not is_boost_serializable<std::vector<std::list<std::array<Bar, 8>>>, Arc>::value, "!");
}