std::uninitialized_move_n
| Défini dans l'en-tête <memory>
|
||
template< class InputIt, class Size, class NoThrowForwardIt >
std::pair<InputIt, NoThrowForwardIt>
uninitialized_move_n( InputIt first, Size count,
NoThrowForwardIt d_first );
|
(1) | (depuis C++17) (constexpr depuis C++26) |
template< class ExecutionPolicy,
class ForwardIt, class Size, class NoThrowForwardIt >
std::pair<ForwardIt, NoThrowForwardIt>
uninitialized_move_n( ExecutionPolicy&& policy, ForwardIt first,
Size count, NoThrowForwardIt d_first );
|
(2) | (depuis C++17) |
d_first à partir des count premiers éléments de la plage source commençant à first comme si par
for (; count > 0; ++d_first, (void) ++first, --count)
::new (voidify(*d_first))
typename std::iterator_traits<NoThrowForwardIt>::value_type(deref-move(*iter));
return {first, d_first};
first + [0, count) sont laissés dans un état valide mais non spécifié, et les objets déjà construits sont détruits dans un ordre non spécifié.policy.true:
|
|
(jusqu'à C++20) |
|
|
(depuis C++20) |
|
Si |
(depuis C++20) |
Paramètres
| first | - | le début de la plage des éléments à déplacer |
| d_first | - | le début de la plage de destination |
| count | - | le nombre d'éléments à déplacer |
| policy | - | la politique d'exécution à utiliser |
| Exigences de type | ||
-
InputIt
doit satisfaire aux exigences de
LegacyInputIterator
.
|
||
-
ForwardIt
doit satisfaire aux exigences de
LegacyForwardIterator
.
|
||
-
NoThrowForwardIt
doit satisfaire aux exigences de
LegacyForwardIterator
.
|
||
-
NoThrowForwardIt
ne peut lever d'exceptions.
|
||
Valeur de retour
Comme décrit ci-dessus.
Exceptions
- 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 interceptée est levée lors de l'accès à des objets via un argument d'algorithme, le comportement est déterminé par la politique d'exécution (pour standard policies, std::terminate est invoqué).
Notes
Lorsque l'itérateur d'entrée déréférence une rvalue, le comportement de std::uninitialized_move_n est le même que celui de std::uninitialized_copy_n.
| Test de fonctionnalité macro | Valeur | Norme | Fonctionnalité |
|---|---|---|---|
__cpp_lib_raw_memory_algorithms |
202411L |
(C++26) | constexpr pour spécialisés <memory> algorithmes, (1)
|
Implémentation possible
template<class InputIt, class Size, class NoThrowForwardIt> constexpr std::pair<InputIt, NoThrowForwardIt> uninitialized_move_n(InputIt first, Size count, NoThrowForwardIt d_first) { using ValueType = typename std::iterator_traits<NoThrowForwardIt>::value_type; NoThrowForwardIt current = d_first; try { for (; count > 0; ++first, (void) ++current, --count) { auto addr = static_cast<void*>(std::addressof(*current)); if constexpr (std::is_lvalue_reference_v<decltype(*first)>) ::new (addr) ValueType(std::move(*first)); else ::new (addr) ValueType(*first); } } catch (...) { std::destroy(d_first, current); throw; } return {first, current}; } |
` et ``, et contient des termes spécifiques au C++ qui doivent être préservés. Seul le texte environnant aurait été traduit s'il y en avait eu.
Exemple
#include <cstdlib> #include <iomanip> #include <iostream> #include <memory> #include <string> void print(auto rem, auto first, auto last) { for (std::cout << rem; first != last; ++first) std::cout << std::quoted(*first) << ' '; std::cout << '\n'; } int main() { std::string in[]{"One", "Definition", "Rule"}; print("initially, in: ", std::begin(in), std::end(in)); if (constexpr auto sz = std::size(in); void* out = std::aligned_alloc(alignof(std::string), sizeof(std::string) * sz)) { try { auto first{static_cast<std::string*>(out)}; auto last{first + sz}; std::uninitialized_move_n(std::begin(in), sz, first); print("after move, in: ", std::begin(in), std::end(in)); print("after move, out: ", first, last); std::destroy(first, last); } catch (...) { std::cout << "Exception!\n"; } std::free(out); } }
Sortie possible :
initially, in: "One" "Definition" "Rule" after move, in: "" "" "" after move, out: "One" "Definition" "Rule"
Rapports de défauts
Les rapports de défauts suivants, modifiant le comportement, ont été appliqués rétroactivement aux normes C++ précédemment publiées.
| DR | Appliqué à | Comportement tel que publié | Comportement correct |
|---|---|---|---|
| LWG 3918 | C++17 | la construction par déplacement est toujours effectuée même si l'itérateur d'entrée déréférence une prvalue |
aucune construction par déplacement dans ce cas |
Voir aussi
|
(C++17)
|
déplace une plage d'objets vers une zone mémoire non initialisée
(modèle de fonction) |
|
(C++11)
|
copie un nombre d'objets vers une zone mémoire non initialisée
(modèle de fonction) |
|
(C++20)
|
déplace un nombre d'objets vers une zone mémoire non initialisée
(objet fonction algorithme) |