std::ranges::fill_n
Von de.cppreference.net
| Definiert in Header <algorithm>
|
||
| Aufrufsignatur |
||
template< class T, std::output_iterator<const T&> O >
constexpr O fill_n( O first, std::iter_difference_t<O> n, const T& value );
|
(seit C++20) (bis C++26) |
|
template< class O, class T = std::iter_value_t<O> >
requires std::output_iterator<O, const T&>
constexpr O fill_n( O first, std::iter_difference_t<O> n, const T& value );
|
(seit C++26) | |
Weist dem value den angegebenen [first, first + n) zu.
Die auf dieser Seite beschriebenen funktionsähnlichen Entitäten sind Algorithmus-Funktionsobjekte (informell bekannt als Niebloids), das heißt:
- Explizite Vorlagenargumentlisten können nicht angegeben werden, wenn eine von ihnen aufgerufen wird.
- Keine von ihnen sind für argumentabhängige Namenssuche sichtbar.
- Wenn eine von ihnen durch normale unqualifizierte Namenssuche als Name links vom Funktionsaufrufoperator gefunden wird, wird argumentabhängige Namenssuche unterbunden.
Parameter
| first | - | der Anfang des Bereichs der zu ändernden Elemente |
| n | - | Anzahl der zu ändernden Elemente |
| value | - | der zuzuweisende Wert |
Rückgabewert
Ein Ausgabeiterator, der gleich first + n ist.
Komplexität
Genau n Zuweisungen.
Mögliche Implementierung
struct fill_n_fn
{
template<class O, class T = std::iter_value_t<O>>
requires std::output_iterator<O, const T&>
constexpr O operator()(O first, std::iter_difference_t<O> n, const T& value) const
{
for (std::iter_difference_t<O> i {}; i != n; ++first, ++i)
*first = value;
return first;
}
};
inline constexpr fill_n_fn fill_n {};
|
Hinweise
| Feature-Test-Makro | Wert | Std | Feature |
|---|---|---|---|
__cpp_lib_algorithm_default_value_type |
202403 |
(C++26) | Listeninitialisierung für Algorithmen |
Beispiel
Diesen Code ausführen
#include <algorithm>
#include <complex>
#include <iostream>
#include <string>
#include <vector>
void println(const auto& v)
{
for (const auto& elem : v)
std::cout << ' ' << elem;
std::cout << '\n';
}
int main()
{
constexpr auto n{8};
std::vector<std::string> v(n, "▓▓░░");
println(v);
std::ranges::fill_n(v.begin(), n, "░░▓▓");
println(v);
std::vector<std::complex<double>> nums{{1, 3}, {2, 2}, {4, 8}};
println(nums);
#ifdef __cpp_lib_algorithm_default_value_type
std::ranges::fill_n(nums.begin(), 2, {4, 2});
#else
std::ranges::fill_n(nums.begin(), 2, std::complex<double>{4, 2});
#endif
println(nums);
}
Ausgabe:
▓▓░░ ▓▓░░ ▓▓░░ ▓▓░░ ▓▓░░ ▓▓░░ ▓▓░░ ▓▓░░
░░▓▓ ░░▓▓ ░░▓▓ ░░▓▓ ░░▓▓ ░░▓▓ ░░▓▓ ░░▓▓
(1,3) (2,2) (4,8)
(4,2) (4,2) (4,8)
Siehe auch
(C++20) |
weißt einem Bereich von Elementen einen bestimmten Wert zu (Algorithmus-Funktionsobjekt) |
(C++20) |
kopiert eine Anzahl von Elementen an eine neue Position (Algorithmus-Funktionsobjekt) |
(C++20) |
speichert das Ergebnis einer Funktion in einem Bereich (Algorithmus-Funktionsobjekt) |
(C++20) |
wendet eine Funktion auf einen Bereich von Elementen an (Algorithmus-Funktionsobjekt) |
(C++26) |
füllt einen Bereich mit Zufallszahlen aus einem gleichmäßigen Zufallsbitgenerator (Algorithmus-Funktionsobjekt) |
| weist per Kopierzuweisung den angegebenen Wert N Elementen in einem Bereich zu (Funktionsschablone) |