std::iterator_traits

(removed in C++20)

User specializations may define the nested type iterator_concept to one of iterator category tags, to indicate conformance to the iterator concepts.

(since C++20)

• 1 Template parameters
• 2 Member types
• 3 Specializations
  • 3.1 T* specialization nested types
  • 3.2 const T* specialization nested types
  • 3.3 Specializations for library types
• 4 Example
• 5 See also

Iter - the iterator type to retrieve properties for

Nested type Definition

difference_type Iter::difference_type

value_type Iter::value_type

pointer Iter::pointer

reference Iter::reference

iterator_category Iter::iterator_category

If Iter does not have any of the five nested types above, then this template has no members by any of those names (std::iterator_traits is SFINAE-friendly).

(since C++17)
(until C++20)

If Iter does not have pointer, but has all four remaining nested types, then these four nested types are declared as follows:

Otherwise, if Iter satisfies the exposition-only concept __LegacyInputIterator, the nested types are declared as follows:

Otherwise, if Iter satisfies the exposition-only concept __LegacyIterator, the nested types are declared as follows:

Otherwise, this template has no members by any of those names (std::iterator_traits is SFINAE-friendly).

(since C++20)

The standard library also provides partial specializations for some standard iterator adaptors.

(since C++20)

Only specialized if std::is_object_v <T> is true.

(since C++20)

Nested type Definition

difference_type std::ptrdiff_t

value_type T(until C++20)std::remove_cv_t <T>(since C++20)

pointer T*

reference T&

iterator_category std::random_access_iterator_tag

iterator_concept (since C++20) std::contiguous_iterator_tag

const T* specialization nested types

(until C++20)

provides uniform interface to the properties of the std::common_iterator type
(class template specialization) [edit]

provides uniform interface to the properties of the std::counted_iterator type
(class template specialization) [edit]

#include <iostream>
#include <iterator>
#include <list>
#include <vector>
 
template<class BidirIt>
void my_reverse(BidirIt first, BidirIt last)
{
 typename std::iterator_traits<BidirIt>::difference_type n = std::distance (first, last);
 for (--n; n > 0; n -= 2)
 {
 typename std::iterator_traits<BidirIt>::value_type tmp = *first;
 *first++ = *--last;
 *last = tmp;
 }
}
 
int main()
{
 std::vector <int> v{1, 2, 3, 4, 5};
 my_reverse(v.begin(), v.end());
 for (int n : v)
 std::cout << n << ' ';
 std::cout << '\n';
 
 std::list <int> l{1, 2, 3, 4, 5};
 my_reverse(l.begin(), l.end());
 for (int n : l)
 std::cout << n << ' ';
 std::cout << '\n';
 
 int a[]{1, 2, 3, 4, 5};
 my_reverse(a, a + std::size (a));
 for (int n : a)
 std::cout << n << ' ';
 std::cout << '\n';
 
// std::istreambuf_iterator<char> i1(std::cin), i2;
// my_reverse(i1, i2); // compilation error: i1, i2 are input iterators
}

5 4 3 2 1
5 4 3 2 1
5 4 3 2 1

base class to ease the definition of required types for simple iterators
(class template) [edit]

empty class types used to indicate iterator categories
(class) [edit]

computes the associated types of an iterator
(alias template)[edit]