2

我有以下结构的代码：

template <typename T>
struct Foo
{
  struct Bar
  {
    int data;
  };
};

我想编写元函数来告诉我类型是 Foo 还是 Bar。第一个很简单：

template <typename T>
struct is_foo : boost::mpl::false_
{};

template <typename T>
struct is_foo<Foo<T> > : boost::mpl::true_
{};
...
BOOST_MPL_ASSERT(( is_foo<Foo<int> > ));
BOOST_MPL_ASSERT_NOT(( is_foo<int> ));

但是，同样的方法不适用于 Bar：

template <typename T>
struct is_bar : boost::mpl::false_
{};

template <typename T>
struct is_bar<typename Foo<T>::Bar> : boost::mpl::true_
{};

此代码被编译器拒绝。海湾合作委员会 说：

main.cpp:38:8: error: template parameters not used in partial specialization:
main.cpp:38:8: error:         ‘T’

奇怪的是，clang 会编译代码，但它会发出警告并且元函数不起作用（总是错误的）：

main.cpp:38:8: warning: class template partial specialization contains a template parameter that can not be deduced;
      this partial specialization will never be used
struct is_bar<typename Foo<T>::Bar> : boost::mpl::true_
       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
main.cpp:37:20: note: non-deducible template parameter 'T'
template <typename T>
                   ^

这个问题有解决方法吗？特定于 c++11 的解决方案会很好。

4

3 回答 3

1

问题是它T是类型名称Foo<T>::Bar的一部分，但它不是类型结构的一部分。

一种可能的解决方案是T在类型的结构中进行编码：

template<typename Outer, typename Inner> struct Nested: public Inner {
  using Inner::Inner;
};
template<typename T> struct Foo {
  struct BarImpl {
    int data;
  };
  using Bar = Nested<Foo<T>, BarImpl>;
};

template <typename T> struct is_bar: std::false_type {};
template <typename T, typename U> struct is_bar<Nested<Foo<T>, U>>:
  std::is_same<typename Foo<T>::Bar, Nested<Foo<T>, U>> {};

测试：

static_assert(is_bar<Foo<int>::Bar>::value, "!");
static_assert(!is_bar<Foo<int>>::value, "!");
static_assert(!is_bar<int>::value, "!");
于 2012-12-04T18:36:06.640 回答
1

这是我自己的问题的一个非常不雅的解决方案，使用 TTI (http://svn.boost.org/svn/boost/sandbox/tti)：

首先，给 Bar 添加一个虚拟标签：

template <typename T>
struct Foo
{
  struct Bar
  {
    typedef void i_am_bar;
    int data;
  };
};

接下来，使用 TTI 检查该标签：

BOOST_TTI_HAS_TYPE(i_am_bar);

template <typename T>
struct is_bar : boost::tti::has_type_i_am_bar<T>
{};
...
BOOST_MPL_ASSERT(( is_bar<Foo<int>::Bar> ));
BOOST_MPL_ASSERT_NOT(( is_bar<Foo<int> > ));
BOOST_MPL_ASSERT_NOT(( is_bar<int> ));

可以肯定的是，它满足了我的用例。

于 2012-12-05T02:39:07.307 回答
0

编译器是正确的，简单易懂的解释是：他们只是不想替换所有可能的类型T，只是为了实现给定模板内部是否有嵌套类型栏。您可以在一本关于模板的“经典”（我希望是众所周知的）书中找到更准确的解释：“C++ 模板 - 完整指南”。

幸运的是 C++11 可以帮助你做得更好！:)

#include <type_traits>

template <typename T>
struct has_nested_bar
{
    template <typename W>
    struct wrapper {};

    template <typename C>
    static std::true_type check(
        const wrapper<C>*
      , const typename C::Bar* = nullptr
      );

    template <class C>
    static std::false_type check(...);

    constexpr static bool value = std::is_same<
        decltype(check<T>(nullptr))
      , std::true_type
      >::type::value;
    typedef std::integral_constant<bool, value> type;
};

此元函数将检查给定类型是否具有嵌套Bar类型（据我所知，这是您的is_bar.

template <typename T>
struct Foo
{
    struct Bar
    {
        int data;
    };
};

struct Bar {};

int main()
{
    std::cout << has_nested_bar<Foo<int>>::value << std::endl;
    std::cout << has_nested_bar<Bar>::value << std::endl;
    return 0;
}

将输出：

zaufi@gentop /work/tests $ ./has-nested-bar
1
0

稍后您可以将此元函数与您的元函数结合起来is_foo检查嵌套Bar实际上是否在Foo...

于 2012-12-04T20:43:34.387 回答