模板类的模板嵌套类作为参数来完全专门化函数

Question

template< typename T, class U, typename V >
class aContainer {
  public:
    template< bool ABool, bool BBool >
    class aIterator {
      public:
        using iterator_category = std::forward_iterator_tag;
        using value_type = T;
        using difference_type = std::ptrdiff_t;
        using referenc = T&;
        using pointer = T*;
       /** iterator related operations */
    };
  protected:
    T const * const _begin;
    T const * const _end;
  public:
    explicit aContainer( T const * const begin, std::size_t count ):
      __begin{ begin }, __end{ __begin + count } { }
    auto begin_a() const { return aIterator< true, false >{ __begin }; }
    auto end_a() const { return aIterator< true, false >{ __end }; }

    auto begin_b() const { return aIterator< false, true >{ __begin }; }
    auto end_b() const { return aIterator< false, true >{ __end }; }
};

template< typename T, template< class > class U >
T max( T* data );

template<>
int max< int, aU >( int* data ) {
  return old_c_style_max_int( data, aU< T >::size );
}

template<>
float max< float, bU >( float* data ) {
  return old_c_style_max_float( data, bU< T >::size );
}

也许这看起来有点奇怪，但这很好地掩盖了不同的旧C风格函数调用。

类U是一个帮助器结构，创建一个特定的上下文（或味道）。容器及其迭代器需要该上下文。

template< typename T >
class aU {
  using constexpr std::size_t size = 10;
  using value_t = T;
  /** ... */
};
template< typename T >
class bU {
  using constexpr std::size_t size = 20;
  using value_t = T;
  /** ... */
};

我想要实现的是将迭代器作为参数传递到函数中：

/* ... */
aContainer< int, aClass, bool > container( start );
auto iterator = container.begin_a();
for( ; iterator != container.end_a(); ++iterator ) {
  foo< int, aClass >( iterator );
}
/* ... */

Answer 1

您可以向foo添加另一个类型参数：

template<typename T, class U, typename Itr> void foo(Itr itr);

如果您想在T、U和迭代器之间通过acontainer...嗯，您仍然需要一个额外的参数...几个额外的论点：

template<typename T, class U, bool flag, bool a, bool b> void foo(typename aContainer<T, U, flag>::template aIterator<a, b> itr);

但是这一次，您需要向编译器提供关于外部类型的完整信息，换句话说，也提供标志（将推导迭代器自己的参数A和B):

foo<int, aClass, true>( iterator );