std::uninitialized_move
De fr.cppreference.net
| Défini dans l'en-tête <memory>
|
||
template< class InputIt, class NoThrowForwardIt >
NoThrowForwardIt uninitialized_move( InputIt first, InputIt last,
NoThrowForwardIt d_first );
|
(1) | (depuis C++17) (constexpr depuis C++26) |
template< class ExecutionPolicy,
class ForwardIt, class NoThrowForwardIt >
NoThrowForwardIt uninitialized_move( ExecutionPolicy&& policy,
ForwardIt first, ForwardIt last,
NoThrowForwardIt d_first );
|
(2) | (depuis C++17) |
1) Construit les éléments dans la plage de destination commençant à
d_first à partir des éléments de la plage source [first, last) comme par
for (; first != last; ++d_first, (void) ++first)
::new (voidify(*d_first))
typename std::iterator_traits<NoThrowForwardIt>::value_type(deref-move(*iter));
return d_first;
Si une exception est levée lors de l'initialisation, certains objets dans
[first, last) 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é.2) Identique à (1), mais exécuté selon
policy. Cette surcharge ne participe à la résolution de surcharge que si la valeur de l'expression suivante est
true:
|
|
(jusqu'à C++20) |
|
|
(depuis C++20) |
|
Si |
(depuis C++20) |
Paramètres
| first, last | - | la paire d'itérateurs définissant l'intervalle des éléments à déplacer |
| d_first | - | le début de l'intervalle de destination |
| 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
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 à des 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).
Notes
Lorsque l'itérateur d'entrée déréférence une valeur r, le comportement de std::uninitialized_move est le même que std::uninitialized_copy.
| 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 NoThrowForwardIt> constexpr NoThrowForwardIt uninitialized_move(InputIt first, InputIt last, NoThrowForwardIt d_first) { using ValueType = typename std::iterator_traits<NoThrowForwardIt>::value_type; auto current = d_first; try { for (; first != last; ++first, (void) ++current) { 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); } return current; } catch (...) { std::destroy(d_first, current); throw; } } |
Exemple
Exécuter ce code
#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[]{"Home", "Work!"};
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(std::begin(in), std::end(in), 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);
}
}
Résultat possible :
initially, in: "Home" "Work!"
after move, in: "" ""
after move, out: "Home" "Work!"
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
|
copie une plage d'objets vers une zone mémoire non initialisée
(modèle de fonction) |
|
|
(C++17)
|
déplace un nombre d'objets vers une zone mémoire non initialisée
(modèle de fonction) |
|
(C++20)
|
déplace une plage d'objets vers une zone mémoire non initialisée
(objet fonction algorithme) |