Question

在玩我的个人格式库时，我遇到了一些意想不到的结果。我已将代码缩减到您可以在下面或coliru找到的列表。

#include <iostream>
#include <map>
#include <utility>
#include <string>

template <typename T>
struct executioner {
    inline static void exec( const T & ){
        std::cout << "generic" << std::endl;
    }
};

template <typename T1, typename T2>
struct executioner<std::pair<T1, T2> > {
    inline static void exec( const std::pair<T1, T2> & t ){
        std::cout << "pair" << std::endl;
        executioner<T1>::exec( t.first );
        executioner<T2>::exec( t.second );
    }
};

template <template <typename ...> class Container,
      typename ... Ts>
struct executioner<Container<Ts ...> > {
    inline static void exec( const Container<Ts ...> & c ){
        std::cout << "cont" << std::endl;
        auto it = c.begin();
        typedef decltype( * it ) ContainedType;
        executioner<ContainedType>::exec( * it );
    }
};

template <typename T> void execute( const T & t ){
    executioner<T>::exec( t );
}

int main(){
    std::map<int,std::string> aMap = { { 0, "zero" }, { 1, "one" }, { 2, "two" } };
    execute( aMap );
}

请注意，为了演示而减少了代码，在实际的部分中，我使用variadic函数中的迭代器来遍历输入容器并为每个容器的元素调用executioner<ContainedType>::exec( * it );。

执行此代码，我希望得到以下输出：

续
  对
  通用

令我惊讶的是，没有使用std::pair的专门化，实际输出是：

续
通用

我非常怀疑这是一个编译器错误（因为它发生在gcc 4.9和clang 3.2），因此我问

我没想过的是什么？

Answer 1

将可变参数模板代码更改为以下内容：

template <template <typename ...> class Container,
  typename ... Ts>
struct executioner<Container<Ts ...> > {
  inline static void exec(const Container<Ts ...> & c){
    std::cout << "cont" << std::endl;
    auto it = c.begin();
    executioner<typename Container<Ts...>::value_type>::exec(*it);
  }
};

您的代码将按预期工作。

原因：

我将尝试通过示例演示decltype无法正常工作的原因：

template <template <typename ...> class Container,
      typename ... Ts>
struct executioner<Container<Ts ...> > {
    inline static void exec( const Container<Ts ...> & c ){
        std::cout << "cont" << std::endl;
        auto it = c.begin();
        typedef decltype( (*it) ) ContainedType;
        if(std::is_same<decltype(it->first), const int>::value) {
          std::cout << "IS CONST !!!" << std::endl;
        }
        executioner<ContainedType>::exec( * it );
    }
};

如果您使用上面的代码替换，您会发现条件std::is_same<decltype(it->first), const int>::value为true。这意味着*it的类型为std::pair<const int, std::basic_string<...>>，而非std::pair<int, std::basic_string<...>>。因此，您的专业化“失败”。

Answer 2

好的，现在回到我身边了:)）

正如ildjarn暗示您可以使用std::remove_reference来删除引用。我还剥离了const限定符（请参阅this thread）。我的便利结构如下所示：

template <typename T>
struct to_value
{
    typedef typename std::remove_const<
        typename std::remove_reference< T >::type
    >::type type;
};

你这样称呼它：

    typedef decltype( *it ) ContainedType;
    executioner< typename to_value<ContainedType>::type >::exec( *it );

现在您只需要专注于值类型。这是the whole thing。

Answer 3

typedef ContainedType不是std::pair<int, std::string>。它是const std::pair<const int, std::string>&。这就是你的第一个部分专业化不匹配的原因。你可以这样修改它：

template <typename T1, typename T2>
struct executioner<const std::pair<T1, T2>&> {
    inline static void exec( const std::pair<T1, T2> & t ) {
        std::cout << "pair" << std::endl;
        executioner<T1>::exec( t.first );
        executioner<T2>::exec( t.second );
    }
};

并匹配（coliru link）。

或者您可以使用容器的value_type，而不是decltype(*it)：

typedef typename Container<Ts...>::value_type ContainedType;

在后一种情况下，ContainedType符合预期的std::pair<const int, std::string>（coliru link）。

部分模板特化的意外结果

3 个答案:

原因：