模板类的模板嵌套类作为完全专门功能的参数

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 );
}

也许看起来有点奇怪，但这很好地掩盖了不同的old-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);

但是这一次，您需要为编译器提供有关外部类型的完整信息，换句话说，也要提供flag （将推导出迭代器自己的参数a和b ）：

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