模板嵌套类模板类作为与完全专业函数的参数

我构建了一个自定义的模板迭代器作为模板的嵌套类：

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 );
}
/* ... */

这甚至可能吗？我的猜测被编译器拒绝：/我认为，包装器结构可能是一个可能的解决方案，但我想避免使用。也是迭代基类，阴影模板迭代类似乎是可行的，但从概念的角度来看。