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

但是这次你需要给你的编译器提供有关外部类型的完整信息，换句话说，也提供flag（迭代器自己的参数a和{{ 1}}将被推断）：

模板嵌套类模板类作为完全专用函数

1 个答案: