std::ranges::uninitialized_default_construct_n
Depuis fr.cppreference.net
| Défini dans l'en-tête <memory>
|
||
| Signature d'appel |
||
template< /*nothrow-forward-iterator*/ I >
requires std::default_initializable<std::iter_value_t<I>>
I uninitialized_default_construct_n( I first,
std::iter_difference_t<I> count );
|
(1) | (depuis C++20) (constexpr depuis C++26) |
template< /*execution-policy*/ Ep, /*nothrow-random-access-iterator*/ I >
requires std::default_initializable<std::iter_value_t<I>>
I uninitialized_default_construct_n( Ep&& policy, I first,
std::iter_difference_t<I> count );
|
(2) | (depuis C++26) |
Pour la définition de /*execution-policy*/, voir cette page; pour la définition d'autres concepts d'exposition seulement, voir cette page.
1) Construit des éléments dans la plage de destination
first + [0, count) par initialisation par défaut comme si par
return ranges::uninitialized_default_construct(std::counted_iterator(first, count),
std::default_sentinel).base();
Si une exception est levée pendant l'initialisation, les objets déjà construits sont détruits dans un ordre non spécifié.
2) Identique à (1), mais exécuté selon
policy.Les entités de type fonction décrites sur cette page sont objets fonction d'algorithme (informellement connus comme niebloids), c'est-à-dire :
- Les listes d'arguments de modèle explicites ne peuvent pas être spécifiées lors de l'appel de l'un d'eux.
- Aucun d'eux n'est visible par recherche dépendante des arguments.
- Lorsque l'un d'eux est trouvé par recherche normale non qualifiée comme le nom à gauche de l'opérateur d'appel de fonction, recherche dépendante des arguments est inhibée.
Paramètres
| first | - | le début de la plage d'éléments à initialiser |
| count | - | le nombre d'éléments à construire |
| policy | - | la politique d'exécution à utiliser |
Valeur de retour
Comme décrit ci-dessus.
Exceptions
Toute exception levée lors de la construction des éléments dans la plage de destination.
2) Pendant le processus d'exécution :
- Si les ressources mémoire temporaires nécessaires à la parallélisation ne sont pas disponibles, std::bad_alloc est levée.
- Si une exception non capturée est levée lors de l'accès aux objets via un argument d'algorithme, le comportement est déterminé par la politique d'exécution (pour les politiques standard, std::terminate est invoquée).
Remarques
Une implémentation peut ignorer la construction de l'objet (sans changer l'effet observable) si aucun constructeur par défaut non trivial n'est appelé lors de l'initialisation par défaut d'un objet std::iter_value_t<I>, ce qui peut être détecté par std::is_trivially_default_constructible.
| test de fonctionnalité macro | Valeur | Norme | Fonctionnalité |
|---|---|---|---|
__cpp_lib_parallel_algorithm |
202506L |
(C++26) | Algorithmes de plage parallèles |
__cpp_lib_raw_memory_algorithms |
202411L |
(C++26) | constexpr pour spécialisés <memory> algorithmes, (1)
|
Implémentation possible
struct uninitialized_default_construct_n_fn
{
template</*nothrow-forward-iterator*/ I>
requires std::default_initializable<std::iter_value_t<I>>
constexpr I operator()(I first, std::iter_difference_t<I> count) const
{
auto iter = std::counted_iterator(first, count);
return ranges::uninitialized_default_construct(iter, std::default_sentinel).base();
}
};
inline constexpr uninitialized_default_construct_n_fn uninitialized_default_construct_n{};
|
Exemple
Exécuter ce code
#include <cstring>
#include <iostream>
#include <memory>
#include <string>
int main()
{
struct S { std::string m{"█▓▒░ █▓▒░ "}; };
constexpr int n{4};
alignas(alignof(S)) char out[n * sizeof(S)];
try
{
auto first{reinterpret_cast<S*>(out)};
auto last = std::ranges::uninitialized_default_construct_n(first, n);
auto count{1};
for (auto it{first}; it != last; ++it)
std::cout << count++ << ' ' << it->m << '\n';
std::ranges::destroy(first, last);
}
catch (...)
{
std::cout << "Exception!\n";
}
// For scalar types, uninitialized_default_construct_n
// generally does not zero-fill the given uninitialized memory area.
constexpr int sample[]{1, 2, 3, 4, 5, 6};
int v[]{1, 2, 3, 4, 5, 6};
std::ranges::uninitialized_default_construct_n(std::begin(v), std::size(v));
if (std::memcmp(v, sample, sizeof(v)) == 0)
{
// Maybe undefined behavior, pending CWG 1997:
// for (const int i : v) { std::cout << i << ' '; }
for (const int i : sample)
std::cout << i << ' ';
}
else
std::cout << "Unspecified!";
std::cout << '\n';
}
Résultat possible :
1 █▓▒░ █▓▒░
2 █▓▒░ █▓▒░
3 █▓▒░ █▓▒░
4 █▓▒░ █▓▒░
1 2 3 4 5 6
Voir aussi
| construit des objets par initialisation par défaut dans une zone mémoire non initialisée, définie par une plage (objet fonction d'algorithme) | |
| construit des objets par initialisation par valeur dans une zone mémoire non initialisée, définie par une plage (objet fonction d'algorithme) | |
| construit des objets par initialisation par valeur dans une zone mémoire non initialisée, définie par un début et un nombre (objet fonction d'algorithme) | |
| construit des objets par initialisation par défaut dans une zone mémoire non initialisée, définie par un début et un nombre (modèle de fonction) |