Question

在我的基于策略的类的根目录中有一个容器适配器，它提供了一个用于在不同容器之间进行转换的接口。它由类型T和模板模板参数Container参数化。为了使它与标准容器一起工作，我需要部分应用它们的一些参数，例如分配器或数组大小。我就是这样做的：

template< typename T >
struct vector_{
  using policy = std::vector<T>; //default allocator
};

或者在给我带来麻烦的情况下：

 //data_adapter expects template template parameter that takes one type-argument,
 //but sadly std::array is a template<typename, size_t>
 //so we need to partially apply the size_t parameter
namespace array_detail{
  template< size_t N >
  struct array_impl{
    template< typename T >
    using array_default = std::array<T, N>;
  };  //now we can write array_impl<32>::array_default which is template<typename T>
}

问题是我需要对data_adaptor的所有N部分专门化array_impl，而GCC 4.8.1在调用其构造函数时似乎不考虑我的专业化。这是代码：

data_adapter.hpp：

//data_adapter.hpp
#ifndef __DATA_ADAPTER_HPP__
#define __DATA_ADAPTER_HPP__

#include <array>
#include <type_traits>

template <
  typename T,
  template< typename t >
  class Container
> class data_adapter
: protected Container< T >
{
protected:
  typedef Container<T> data_type;

public:
    //constructor forwarding
  using data_type::data_type;

    //const iterator access for cross-container conversion copying
  using data_type::cbegin;
  using data_type::cend;

  data_adapter() = default;

public:
  ~data_adapter() {}
};

  //SFINAE helper to test whether T is an iterator or not

template<typename T, typename = void>
struct is_iterator
{
   static constexpr bool value = false;
};

template<typename T>
struct is_iterator<T, typename std::enable_if<!std::is_same<typename std::iterator_traits<T>::value_type, void>::value>::type>
{
   static constexpr bool value = true;
};

  //data_adapter expects template template parameter that takes one type-argument,
  //but sadly std::array is a template<typename, size_t>
  //so we need to partially apply the size_t parameter
namespace array_detail{
  template< size_t N >
  struct array_impl{
    template< typename T >
    using array_default = std::array<T, N>;
  };  //now we can write array_impl<32>::array_default which is template<typename T>
}

//partial specialization for array_impl<N>::array_default for any N???

template< typename T, size_t N >
class data_adapter< T, array_detail::array_impl<N>::template array_default >
: protected array_detail::array_impl<N>::template array_default<T>
{
protected:
  typedef typename array_detail::array_impl<N>::template array_default<T> data_type;

public:
  using data_type::data_type;

  using data_type::cbegin;
  using data_type::cend;

    //why doesn't std::array implement this constructor?
    //is it because it has static size and conversion from a dynamic container is dangerous?

  template<
    typename InputIt,
    typename = typename
      std::enable_if<is_iterator<InputIt>::value>::type
  > data_adapter( InputIt begin, InputIt end )
  : data_type() {
    std::copy( begin, end, this->begin() );
  }

public:
  ~data_adapter() {}
};

//still doesn't work with explicit instantiation
//template class data_adapter< int, array_detail::array_impl<32>::template array_default >;

#endif // __DATA_ADAPTER_HPP__

main.cpp中：

//main.cpp
#include <algorithm>
#include <ctime>
#include <cstdint>
#include <iostream>
#include <random>


#include "data_adapter.hpp"

int main()
{
  std::mt19937 generator(time(NULL));
  std::uniform_int_distribution<unsigned char> uniform_symbol( 0, 255 );
  auto random_symbol =
    [ &generator, &uniform_symbol ]( int ){
      return uniform_symbol(generator);
    };

  std::vector< int > symbols(32);
  std::transform( symbols.cbegin(), symbols.cend(), symbols.begin(), random_symbol );

  data_adapter< int, array_detail::array_impl<32>::template array_default > adapter( symbols.cbegin(), symbols.cend() );

  std::for_each( symbols.begin(), symbols.end(), []( int s ){ std::cout << s << " "; } );

  return 0;
}

错误：

g++.exe -Wall -fexceptions  -std=c++11 -g  -Wall    -c C:\Users\windows\Desktop\data_test\main.cpp -o obj\Debug\main.o
C:\Users\windows\Desktop\data_test\main.cpp: In function 'int main()':
C:\Users\windows\Desktop\data_test\main.cpp:23:119: error: no matching function for call to 'data_adapter<int, array_detail::array_impl<32u>::array_default>::data_adapter(std::vector<int>::const_iterator, std::vector<int>::const_iterator)'
   data_adapter< int, array_detail::array_impl<32>::template array_default > adapter( symbols.cbegin(), symbols.cend() );
                                                                                                                       ^
C:\Users\windows\Desktop\data_test\main.cpp:23:119: note: candidates are:
In file included from C:\Users\windows\Desktop\data_test\main.cpp:9:0:
C:\Users\windows\Desktop\data_test\data_adapter.hpp:25:3: note: data_adapter<T, Container>::data_adapter() [with T = int; Container = array_detail::array_impl<32u>::array_default]
   data_adapter() = default;
   ^
C:\Users\windows\Desktop\data_test\data_adapter.hpp:25:3: note:   candidate expects 0 arguments, 2 provided
C:\Users\windows\Desktop\data_test\data_adapter.hpp:11:9: note: constexpr data_adapter<int, array_detail::array_impl<32u>::array_default>::data_adapter(const data_adapter<int, array_detail::array_impl<32u>::array_default>&)
 > class data_adapter
         ^

它显然没有考虑我在array_impl的部分特化中定义的构造函数，因此结论是main.cpp中的data_adaptor实例化了类的非特化版本。这不是SFINAE问题，因为编译器会抱怨std :: enable_if中缺少:: type。即使如果我明确地实例化专用版本，它仍然无法正常工作。我在这里做错了什么？

编辑：这是一个我认为相当的最小版本：

#include <iostream>
#include <array>

template<
  typename T,
  template < typename >
  class Container
> struct Foo{
  void test() const {
    std::cout << "Unspecialized Foo" << std::endl;
  }
};

template< size_t N >
struct array_{
  template< typename T >
  using policy = std::array<T, N>;
};

template<
  typename T, size_t N
> struct Foo< T, array_<N>::template policy >{
  void test() const {
    std::cout << "Foo< T, array<" << N << ">::policy >" << std::endl;
  }
};

int main()
{
    Foo< int, array_<10>::template policy > foo;
    foo.test();
    return 0;
}

GCC 4.8.1的结果：

Unspecialized Foo

为什么要调用非专业版？

编辑2：当我用这种方式写它时它似乎有效：

#include <iostream>
#include <array>

template<
  typename container
> struct Foo{
  void test() const {
    std::cout << "Unspecialized Foo" << std::endl;
  }
};

template<
  typename T, size_t N
> struct Foo< std::array<T, N> >{
  void test() const {
    std::cout << "Foo< std::array< T, " << N << ">" << std::endl;
  }
};

int main()
{
    Foo< std::array<int, 10> > foo;
    foo.test();
    return 0;
}

对我来说看起来像GCC的错误。

Answer 1

这不是编译器错误。 §14.5.5.1[temp.class.spec.match] / p1-2指定

在需要的上下文中使用类模板时   实例化该类，有必要确定是否   实例化将使用主模板或其中一个生成   部分专业化。这是通过匹配模板来完成的   使用模板的类模板特化的参数   部分专业化的参数列表。


如果找到一个匹配的特化，则从该特化生成实例化。

如果找到多个匹配专业化，则部分订单规则   （14.5.5.2）用于确定是否其中之一   专业化比其他专业化更专业。如果没有   专业化比所有其他匹配更专业   特化，然后使用类模板是模糊的   该计划格式不正确。

如果未找到匹配项，则从主模板生成实例化。


部分特化匹配给定的实际模板参数列表   如果可以推导出部分特化的模板参数   来自实际的模板参数列表（14.8.2）。

这使用标准模板参数推导规则，以及::左侧的任何内容（技术术语是 qualified-id <中的嵌套名称说明符 / em>）是一个非推导的上下文（§14.8.2.5[temp.deduct.type] / p5），这意味着编译器将无法推导出N;由于演绎失败，部分特化不匹配，并使用基础模板。

部分模板参数应用的部分模板专用化不适用于GCC 4.8.1

1 个答案: