c++ - 模板类的模板嵌套类作为完全专用函数的参数

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 类是一个辅助结构，创建特定的上下文(或 flavor )。容器及其迭代器需要该上下文。

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