C++ 确定（c+；+；）迭代器是否为反向迭代器

我需要一种机制来在编译时确定迭代器是否是反向的

只能帮助处理迭代器类型的类别，我需要的是以下内容：

template<typename IterType>
struct IsReverseIterator
{
    enum { Yes = /* Implementation of the mechanism */ };
}

模板
结构IsReverseIterator
{
枚举{Yes=/*机制的实现*/}；
}

我有一个解决方案，有一个小缺点不过，还必须提供容器类型：

typedef char     TrueT;
typedef struct { TrueT _[2]; } FalseT;

template<typename Cont> TrueT  IsReverseIterator(typename Cont::const_reverse_iterator);    
template<typename Cont> FalseT IsReverseIterator(...);

typedef char-TrueT；
typedef结构{TrueT}FalseT；
模板TrueT是反向迭代器（typename Cont:：const\u reverse\u迭代器）；
模板假码为反迭代器（…）；

它显然使用了SFINAE，可以这样使用：

std::vector<int> v;

std::cout << (sizeof(IsReverseIterator<std::vector<int>>(v.begin())) ==  sizeof(TrueT)) << std::endl;
std::cout << (sizeof(IsReverseIterator<std::vector<int>>(v.rbegin())) ==  sizeof(TrueT)) << std::endl;    

std:：vector v；
std:：cout
#包括
#包括
模板
结构是_reverse_迭代器：std:：false_type{}；
模板
结构是\u反向\u迭代器
：std：：积分常数
{ };

您还可以为任何作为反向迭代器的用户定义迭代器专门化trait
#包括
模板
结构是_reverse_迭代器：std:：false_type{}；
模板
结构是\u反向\u迭代器
：std：：积分常数
{ };

---

您还可以为任何作为反向迭代器的用户定义迭代器专门化trait。

一个简单的方法。它易于使用，可以确定某个对象是否是反向迭代器，如果需要，还可以区分常量反向迭代器

#include <iostream>

template<typename Container, typename T>
using IsRegRevIter = std::is_same<T,typename Container::reverse_iterator>;

template<typename Container, typename T>
using IsConstRevIter = std::is_same<T,typename Container::const_reverse_iterator>;

template<typename Container, typename T>
struct IsRevIter
{
     const static bool value = IsRegRevIter<Container,T>::value
          || IsConstRevIter<Container,T>::value;
};

int main()
{
     using Container = std::list<int>;
     Container myList = {1,2,3,4,5,6};

     auto RI = myList.rbegin();
     auto I = myList.begin();

     std::cout << std::endl << std::boolalpha << IsRevIter<Container,decltype(RI)>::value; //true
     std::cout << std::endl << std::boolalpha << IsRegRevIter<Container,decltype(RI)>::value; //true
     std::cout << std::endl << std::boolalpha << IsConstRevIter<Container,decltype(RI)>::value; //false (it is not const).
     std::cout << std::endl << std::boolalpha << IsRevIter<Container,decltype(I)>::value; //false

return 0;

}

#包括
模板
使用IsRegRevIter=std:：是相同的；
模板
使用IsConstRevIter=std:：是相同的；
模板
结构ISrevier
{
常量静态布尔值=IsRegRevIter:：值
||IsConstRevIter:：value；
};
int main（）
{
使用Container=std:：list；
容器myList={1,2,3,4,5,6}；
auto RI=myList.rbegin（）；
自动I=myList.begin（）；
std:：cout一个简单的方法。它易于使用，可以确定某个对象是否是反向迭代器，如果需要，还可以区分常量反向迭代器

#include <iostream>

template<typename Container, typename T>
using IsRegRevIter = std::is_same<T,typename Container::reverse_iterator>;

template<typename Container, typename T>
using IsConstRevIter = std::is_same<T,typename Container::const_reverse_iterator>;

template<typename Container, typename T>
struct IsRevIter
{
     const static bool value = IsRegRevIter<Container,T>::value
          || IsConstRevIter<Container,T>::value;
};

int main()
{
     using Container = std::list<int>;
     Container myList = {1,2,3,4,5,6};

     auto RI = myList.rbegin();
     auto I = myList.begin();

     std::cout << std::endl << std::boolalpha << IsRevIter<Container,decltype(RI)>::value; //true
     std::cout << std::endl << std::boolalpha << IsRegRevIter<Container,decltype(RI)>::value; //true
     std::cout << std::endl << std::boolalpha << IsConstRevIter<Container,decltype(RI)>::value; //false (it is not const).
     std::cout << std::endl << std::boolalpha << IsRevIter<Container,decltype(I)>::value; //false

return 0;

}

#包括
模板
使用IsRegRevIter=std:：是相同的；
模板
使用IsConstRevIter=std:：是相同的；
模板
结构ISrevier
{
常量静态布尔值=IsRegRevIter:：值
||IsConstRevIter:：value；
};
int main（）
{
使用Container=std:：list；
容器myList={1,2,3,4,5,6}；
auto RI=myList.rbegin（）；
自动I=myList.begin（）；
std：：cout关于
反向迭代器
呢？@GIJoe他知道一个是什么；他想知道，给定一个迭代器，一个是否是。（不过我可能误解了你的评论。@WhozCraig:我想这是我的观点。.他已经知道他需要一个反向迭代器。如果你首先传递一个反向迭代器，我看不到任何其他东西会被接受的可能性。你为什么在意呢？你能检查一下
.base（）
（看看它是否返回一个迭代器）？你所说的“Isa reverse iterator”到底是什么意思？我可以编写一个类，它可以满足所有的目的，但不是由
std:：reverse_iterator
返回的。如何定义实现是可以的？那
reverse_iterator
呢？@GIJoe他知道一个是什么；他想知道，给定一个迭代器，一个是否是。（不过我可能误解了你的评论。@WhozCraig:我想这是我的观点。.他已经知道他需要一个反向迭代器。如果你首先传递一个反向迭代器，我看不到任何其他东西会被接受的可能性。你为什么在意呢？你能检查一下
.base（）
（看看它是否返回一个迭代器）？你所说的“是一个反向迭代器”到底是什么意思？我可以编写一个类，它是一个所有目的的类，但不是由
std:：reverse_iterator
返回的。实现是如何定义的？这太完美了，让我想知道为什么它不在标准库中。Thnx伙计，我很高兴我问了这个问题。因为没有人需要它，您的函数应该是
指向最后一个元素（Cont const&container、It iter、It end）
并检查
iter==end
，不管它是否是反向迭代器，我想如果我有了end，就根本没有必要了。如何从迭代器
it iter
和容器
Cont
的调用函数中获取
end
迭代器？是
begin（）
还是
rbegin（）
（我将此作为一条评论发布，以避免问题变得混乱）您是如何获得iter的？无论它来自哪里，您都知道如何获得过去和结束迭代器的（过去-现在不再是了）问题是我不能在那里添加代码，我只能是该代码的用户/客户端，它如此完美以至于我想知道为什么它不在标准库中。Thnx man我很高兴我问了这个问题。因为没有人需要它，所以你的函数应该是
指向最后一个元素（Cont const&container，it iter，it end）
并检查
iter==end
，不管它是否是反向迭代器，我想如果我有了end，就根本没有必要了。如何从迭代器
it iter
和容器
Cont
的调用函数中获取
end
迭代器？是
begin（）
还是
rbegin（）
（我将此作为一条评论发布，以避免问题变得混乱）您是如何获得
iter
？无论它来自何处，您都知道如何获得过去的结束迭代器。问题是（过去-现在不再是）我无法在那里添加代码，我只能是该代码的用户/客户
#include <iostream>

template<typename Container, typename T>
using IsRegRevIter = std::is_same<T,typename Container::reverse_iterator>;

template<typename Container, typename T>
using IsConstRevIter = std::is_same<T,typename Container::const_reverse_iterator>;

template<typename Container, typename T>
struct IsRevIter
{
     const static bool value = IsRegRevIter<Container,T>::value
          || IsConstRevIter<Container,T>::value;
};

int main()
{
     using Container = std::list<int>;
     Container myList = {1,2,3,4,5,6};

     auto RI = myList.rbegin();
     auto I = myList.begin();

     std::cout << std::endl << std::boolalpha << IsRevIter<Container,decltype(RI)>::value; //true
     std::cout << std::endl << std::boolalpha << IsRegRevIter<Container,decltype(RI)>::value; //true
     std::cout << std::endl << std::boolalpha << IsConstRevIter<Container,decltype(RI)>::value; //false (it is not const).
     std::cout << std::endl << std::boolalpha << IsRevIter<Container,decltype(I)>::value; //false

return 0;

}