std::distance

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Iterator-Bibliothek

Iterator-Konzepte
indirectly_readable (C++20) indirectly_writable (C++20) weakly_incrementable (C++20) incrementable (C++20) is-integer-like is-signed-integer-like (C++20)(C++20)	sentinel_for (C++20) sized_sentinel_for (C++20) input_iterator (C++20) output_iterator (C++20) input_or_output_iterator (C++20)	forward_iterator (C++20) bidirectional_iterator (C++20) random_access_iterator (C++20) contiguous_iterator (C++20)
Iterator-Primitive
input_iterator_tagoutput_iterator_tagforward_iterator_tagbidirectional_iterator_tagrandom_access_iterator_tagcontiguous_iterator_tag (C++20)	iter_value_titer_difference_titer_reference_titer_const_reference_titer_rvalue_reference_titer_common_reference_t (C++20)(C++20)(C++20)(C++23)(C++20)(C++20)	iterator (veraltet in C++17) iterator_traits incrementable_traits (C++20) indirectly_readable_traits (C++20)
Algorithmus-Konzepte und Hilfsprogramme
Indirekte aufrufbare Konzepte
indirectly_unary_invocableindirectly_regular_unary_invocable (C++20)(C++20)	indirect_unary_predicate (C++20) indirect_binary_predicate (C++20)	indirect_equivalence_relation (C++20) indirect_strict_weak_order (C++20)
Gemeinsame Algorithmus-Anforderungen
indirectly_movable (C++20) indirectly_movable_storable (C++20) indirectly_copyable (C++20)	indirectly_copyable_storable (C++20)   indirectly_swappable (C++20) indirectly_comparable (C++20)	permutable (C++20) mergeable (C++20) sortable (C++20)
Dienstprogramme
indirect_result_t (C++20)	projected (C++20)	projected_value_t (C++26)
Iterator-Adapter
reverse_iterator make_reverse_iterator (C++14) move_iterator (C++11) make_move_iterator (C++11) default_sentinel_tdefault_sentinel (C++20)(C++20) unreachable_sentinel_tunreachable_sentinel (C++20)(C++20)	front_insert_iterator back_insert_iterator inserter insert_iterator front_inserter back_inserter move_sentinel (C++20)	common_iterator (C++20) counted_iterator (C++20) basic_const_iterator (C++23) const_iterator (C++23) const_sentinel (C++23) make_const_iterator (C++23) make_const_sentinel (C++23)
Stream-Iteratoren istream_iterator    ostream_iterator istreambuf_iterator ostreambuf_iterator	Iterator-Anpassungspunkte ranges::iter_move (C++20) ranges::iter_swap (C++20)
Iterator-Operationen advance distance prev (C++11)   next (C++11) ranges::advance (C++20) ranges::distance (C++20) ranges::prev (C++20) ranges::next (C++20)	Bereichszugriff begincbegin (C++11)(C++14) rbegincrbegin (C++14)(C++14)   endcend (C++11)(C++14) rendcrend (C++14)(C++14)   sizessize (C++17)(C++20) empty (C++17) data (C++17)

 

Definiert in Header <iterator>
template< class InputIt > typename std::iterator_traits<InputIt>::difference_type     distance( InputIt first, InputIt last );		(constexpr seit C++17)

Gibt die Anzahl der Schritte von first nach last zurück.

Wenn InputIt kein LegacyRandomAccessIterator ist, ist das Verhalten undefiniert, wenn last von first aus nicht erreichbar ist.

Wenn InputIt ein LegacyRandomAccessIterator ist, ist das Verhalten undefiniert, wenn first und last nicht gegenseitig erreichbar sind.

Parameter

first	-	Iterator, der auf das erste Element zeigt
last	-	Iterator, der auf das Ende des Bereichs zeigt
Typanforderungen
- InputIt muss die Anforderungen eines LegacyInputIterator erfüllen. Die Operation ist effizienter, wenn InputIt zusätzlich die Anforderungen eines LegacyRandomAccessIterator erfüllt.

Rückgabewert

Die Anzahl der Inkremente, die benötigt werden, um von first nach last zu gelangen.

Der Wert kann negativ sein, wenn Random-Access-Iteratoren verwendet werden und first von last aus erreichbar ist.

(seit C++11)

Komplexität

Linear.

Wenn InputIt zusätzlich die Anforderungen von LegacyRandomAccessIterator erfüllt, ist die Komplexität konstant.

Mögliche Implementierung

Siehe auch die Implementierungen in libstdc++ und libc++.

C++98-Implementierung über Tag-Dispatch, ohne constexpr
namespace detail { template<class It> constexpr // required since C++17 typename std::iterator_traits<It>::difference_type do_distance(It first, It last, std::input_iterator_tag) { typename std::iterator_traits<It>::difference_type result = 0; while (first != last) { ++first; ++result; } return result; }   template<class It> constexpr // required since C++17 typename std::iterator_traits<It>::difference_type do_distance(It first, It last, std::random_access_iterator_tag) { return last - first; } } // namespace detail   template<class It> constexpr // since C++17 typename std::iterator_traits<It>::difference_type distance(It first, It last) { return detail::do_distance(first, last, typename std::iterator_traits<It>::iterator_category()); }
C++17-Implementierung über if constexpr
template<class It> constexpr typename std::iterator_traits<It>::difference_type distance(It first, It last) { using category = typename std::iterator_traits<It>::iterator_category; static_assert(std::is_base_of_v<std::input_iterator_tag, category>);   if constexpr (std::is_base_of_v<std::random_access_iterator_tag, category>) return last - first; else { typename std::iterator_traits<It>::difference_type result = 0; while (first != last) { ++first; ++result; } return result; } }

Beispiel

Führen Sie diesen Code aus

#include <iostream>
#include <iterator>
#include <vector>
 
int main() 
{
    std::vector<int> v{3, 1, 4};
    std::cout << "distance(first, last) = "
              << std::distance(v.begin(), v.end()) << '\n'
              << "distance(last, first) = "
              << std::distance(v.end(), v.begin()) << '\n';
              // the behavior is undefined (until LWG940)
 
    static constexpr auto il = {3, 1, 4};
    // Since C++17 `distance` can be used in constexpr context.
    static_assert(std::distance(il.begin(), il.end()) == 3);
    static_assert(std::distance(il.end(), il.begin()) == -3);
}

Ausgabe

distance(first, last) = 3
distance(last, first) = -3

Defect Reports

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
LWG 940	C++98	die Formulierung war unklar für den Fall, dass first von last aus erreichbar ist	wurde klargestellt

Siehe auch

advance	bewegt einen Iterator um die angegebene Distanz vorwärts (Funktionsvorlage)
countcount_if	Gibt die Anzahl der Elemente zurück, die bestimmte Kriterien erfüllen (Funktionstempelat)
ranges::distance (C++20)	gibt die Distanz zwischen einem Iterator und einem Sentinel zurück oder die Distanz zwischen dem Anfang und dem Ende eines Bereichs (Algorithmus-Funktionsobjekt)