如何将std :: pair的迭代器传递给函数模板，并推导迭代器类型？

如何解决如何将std :: pair的迭代器传递给函数模板，并推导迭代器类型？

我试图将两个迭代器包装到std :: pair中，并将其传递给函数参数，但希望迭代器的类型通用。

它在迭代器类型上模板化的对本身...

template<typename Iterator>
using iteratorPair = std::pair<Iterator,Iterator>;

...然后模板函数本身具有签名...

template<typename T,typename U,template<typename> class IteratorPair,template<typename> class IteratorPairInt>
void
sortUsingIndicesToTargetContainerPair(
    const IteratorPair<T>& rangeToSortSource,const IteratorPair<T>& rangeToSortTarget,const IteratorPairInt<U>& indicesRange)
{ ...}

我正在做所有这些事情，以便可以通过钎焊初始化来调用该函数...

std::vector<int> vecs{0,1,2,3,4,5,6,7,8,9};
std::vector<int> indices{9,0};

auto copy = vecs;
sortUsingIndicesToTargetContainerPair({vecs.begin(),vecs.end()},{copy.begin(),copy.end()},{indices.begin(),indices.end()});

如果我在调用函数时通过使用名称来显式构造类型，则可以使它起作用，但是如果可能的话，希望使用括号初始化。

任何帮助将不胜感激！ 谢谢

解决方法

我可以建议以下解决方案。 想法：不要尝试直接推导类型，而是添加一个适配器函数，该函数将参数数组转换为成对的迭代器：

template<typename T,typename TIndex,std::size_t N>
constexpr void FAdaptor
(
    const T(&rangeToSortSource)[N],const T(&rangeToSortTarget)[N],const TIndex(&indicesRange)[N]
)
{ 
  static_assert(2 == N,"must be pair");    
  
  sortUsingIndicesToTargetContainerPair
  (
    IteratorPair<T>(rangeToSortSource[0],rangeToSortSource[1]),IteratorPair<T>(rangeToSortTarget[0],rangeToSortTarget[1]),IteratorPair<TIndex>(indicesRange[0],indicesRange     [1])
  );  
}

完整示例：

#include <iostream>
#include <initializer_list>
#include <vector>
#include <utility>

template<typename Iterator>
using IteratorPair = std::pair<Iterator,Iterator>;


template<typename T,typename TIndex>
void sortUsingIndicesToTargetContainerPair
(
    const IteratorPair<T>& rangeToSortSource,const IteratorPair<T>& rangeToSortTarget,const IteratorPair<TIndex>& indicesRange)
{ 
    
}

template<typename T,std::size_t N>
constexpr void sortUsingIndicesToTargetContainerPair2
(
    const T(&rangeToSortSource)[N],indicesRange     [1])
  );  
}


int main() {
  std::vector<int> vecs{0,1,2,3,4,5,6,7,8,9};
  std::vector<int> indices{9,0};

  auto copy = vecs;
  sortUsingIndicesToTargetContainerPair(std::make_pair(vecs.begin(),vecs.end()),std::make_pair(copy.begin(),copy.end()),std::make_pair(indices.begin(),indices.end()));

  sortUsingIndicesToTargetContainerPair2({vecs.begin(),vecs.end()},{copy.begin(),copy.end()},{indices.begin(),indices.end()});
 
  std::cout << "ok\n";
  return 0;
}

,

如果您已经定义了iteratorPair<Iterator>，则不需要template<typename> class IteratorPair。

我还建议按值采用（成对的）迭代器。您是否通过const引用获取（成对的）指针？

template<typename T,typename U>
void sortUsingIndicesToTargetContainerPair(
    iteratorPair<T>& rangeToSortSource,iteratorPair<T>& rangeToSortTarget,iteratorPair<U>& indicesRange);

,

您有几个问题：

• 71331 62KV 8M01 9R22 1N5350 12345678 123456 没有类型，只能推导为{..}或std::initializer_list<T>。

• template参数不能推断出别名为别名，

  即T(&)[N]（又名iteratorPair<SomeType>）与std::pair<SomeType,SomeType>不匹配。

  我们收到了带有默认模板（template <typename> class Pair为std::vector<T,Allocator /*=SomeDefault<T>*/>）的类似“问题”，该问题已在C ++ 17中解决。我认为对于可能存在“冲突” /重复项的别名，无法解决该问题。

  正如Caleth所提到的，您可能还是不想对此进行推论。

• 您的template <typename T> Container似乎定义了一个范围，但是您的常量性具有误导性。 iteratorPair允许修改基础容器。使用真正的范围类型似乎更合适。

要允许调用语法，您可以放弃const iteratorPair<std::vector<int>::iterator>并执行以下操作：

std::pair

但是，为了保持对范围的了解，您甚至可以这样做

// SourceIt might be different than TargetIt (iterator and const_iterator mainly)
template <typename SourceIt,typename TargetIt,typename IndexesIt>
void sortUsingIndicesToTargetContainerPair(
    const SourceIt (&rangeToSortSource)[2],const TargetIt (&rangeToSortTarget)[2],const IndexesIt (&indicesRange)[2])
{ /*...*/ }

您甚至拥有更简单的调用语法：

template <typename Source,typename Target,class Indexes>
void
sortUsingIndicesToTargetContainerPair(
    const Source& rangeToSortSource,Target& rangeToSortTarget,/*const*/ Indexes& indicesRange)
{ /*...*/}