std::iota
Von cppreference.com
| Definiert in der Header-Datei <numeric> |
||
| template< class ForwardIt, class T > void iota( ForwardIt first, ForwardIt last, T value ); |
(seit C++11) (constexpr seit C++20) |
|
Füllt den Bereich [first, last) mit sequenziell ansteigenden Werten, beginnend mit value und wiederholtem Auswerten von ++value.
Äquivalente Operation (angenommen ++value gibt den inkrementierten Wert zurück)
*first = value; *++first = ++value; *++first = ++value; *++first = ++value; // repeats until “last” is reached
Wenn eine der folgenden Bedingungen erfüllt ist, ist das Programm ill-formed (wohlgeformt):
-
Tist nicht in den Werttyp vonForwardItkonvertierbar. - Der Ausdruck ++val ist ill-formed, wobei val eine Variable vom Typ
Tist.
Inhalt |
[bearbeiten] Parameter
| first, last | - | das Paar von Iteratoren, das den Bereich der zu füllenden Elemente definiert, beginnend mit value |
| value | - | Anfangswert, der gespeichert werden soll |
[bearbeiten] Komplexität
Genau std::distance(first, last) Inkremente und Zuweisungen.
[bearbeiten] Mögliche Implementierung
template<class ForwardIt, class T> constexpr // since C++20 void iota(ForwardIt first, ForwardIt last, T value) { for (; first != last; ++first, ++value) *first = value; } |
[bearbeiten] Hinweise
Die Funktion ist nach der ganzzahligen Funktion ⍳ aus der Programmiersprache APL benannt. Sie war eine der STL-Komponenten, die nicht in C++98 enthalten waren, aber 2011 in die Standardbibliothek aufgenommen wurden.
[bearbeiten] Beispiel
Das folgende Beispiel wendet std::shuffle auf einen vector von Iteratoren von std::lists an. std::iota wird zum Füllen von Containern verwendet.
Führen Sie diesen Code aus
#include <algorithm> #include <iomanip> #include <iostream> #include <list> #include <numeric> #include <random> #include <vector> class BigData // inefficient to copy { int data[1024]; /* some raw data */ public: explicit BigData(int i = 0) { data[0] = i; /* ... */ } operator int() const { return data[0]; } BigData& operator=(int i) { data[0] = i; return *this; } /* ... */ }; int main() { std::list<BigData> l(10); std::iota(l.begin(), l.end(), -4); std::vector<std::list<BigData>::iterator> v(l.size()); std::iota(v.begin(), v.end(), l.begin()); // Vector of iterators (to original data) is used to avoid expensive copying, // and because std::shuffle (below) cannot be applied to a std::list directly. std::shuffle(v.begin(), v.end(), std::mt19937{std::random_device{}()}); std::cout << "Original contents of the list l:\t"; for (const auto& n : l) std::cout << std::setw(2) << n << ' '; std::cout << '\n'; std::cout << "Contents of l, viewed via shuffled v:\t"; for (const auto i : v) std::cout << std::setw(2) << *i << ' '; std::cout << '\n'; }
Mögliche Ausgabe
Original contents of the list l: -4 -3 -2 -1 0 1 2 3 4 5 Contents of l, viewed via shuffled v: -1 5 -4 0 2 1 4 -2 3 -3
[bearbeiten] Siehe auch
| (C++20) |
ein view, der eine Sequenz aus aufeinanderfolgenden Inkrementierungen eines Anfangswerts besteht(Klassen-Template) (Customization Point Objekt) |
| Weist jedem Element in einem Bereich den gegebenen Wert zu (Funktionstempelat) | |
| (C++20) |
Weist einem Elementbereich einen bestimmten Wert zu (Algorithmus-Funktionsobjekt) |
| Weist die Ergebnisse aufeinanderfolgender Funktionsaufrufe jedem Element in einem Bereich zu (Funktionstempelat) | |
| (C++20) |
Speichert das Ergebnis einer Funktion in einem Bereich (Algorithmus-Funktionsobjekt) |
| (C++23) |
füllt einen Bereich mit sukzessiven Inkrementen des Startwerts (Funktionsobjekt für Algorithmen) |
