std::move

 

C++

Langage

Concepts

Bibliothèque d'utilitaires

Bibliothèque pour les chaînes de caractères

Bibliothèque de conteneurs

Bibliothèque d'algorithmes

Bibliothèque d'itérateurs

Bibliothèque pour le calcul numérique

Bibliothèque pour les entrées/sorties

Bibliothèque pour la régionalisation

Bibliothèque pour les expressions régulières (C++11)

Bibliothèque pour les opérations atomiques (C++11)

Bibliothèque pour les processus légers (threads) (C++11)

 

Bibliothèque d'utilitaires

Soutien des types fondamentaux (basic types, RTTI, type traits)

Gestion dynamique de la mémoire

Gestion d'erreur

Soutien à l'exécution

Fonctions variadic

Date et heure

Foncteurs

initializer_list (C++11)

bitset

hash (C++11)

Opérateurs relationnels

rel_ops::operator!= rel_ops::operator> rel_ops::operator<= rel_ops::operator>=

Paires et tuples

pair

tuple (C++11)

piecewise_construct_t (C++11)

piecewise_construct (C++11)

swap, forward et move

swap

forward (C++11)

move (C++11)

move_if_noexcept (C++11)

declval (C++11)

 

Déclaré dans l'en-tête <utility>
template< class T > typename std::remove_reference<T>::type&& move( T&& t );		(depuis C++11)

std::move obtient une référence rvalue à son argument. Références rvalue sont autrement que produites par des objets temporaires, alors le code de bibliothèque qui est passé d'une référence rvalue à un objet de ressource-propriétaire a la possibilité (mais n'est pas obligé) à mouvement' la ressource de l'argument pour exécuter plus rapidement, laissant l'argument avec une valeur vide. Le code de la bibliothèque est nécessaire de laisser une valeur valide dans l'argument, mais à moins que les documents de type ou d'une fonction autrement, il n'y a pas d'autres contraintes sur la valeur de l'argument qui en résulte. Cela signifie qu'il est plus sage en général d'éviter d'utiliser un déplacé de nouveau l'argument. Si vous devez l'utiliser à nouveau, n'oubliez pas de ré-initialiser avec une valeur connue avant de le faire .

Original:

std::move obtains an rvalue reference to its argument. Rvalue references are otherwise only produced by temporary objects, so library code that's passed an rvalue reference to a resource-owning object has the option (but isn't required) to move the resource out of the argument in order to run more quickly, leaving the argument with an empty value. The library code is required to leave a valid value in the argument, but unless the type or function documents otherwise, there are no other constraints on the resulting argument value. This means that it's generally wisest to avoid using a moved from argument again. If you have to use it again, be sure to re-initialize it with a known value before doing so.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Paramètres

t

-

l'objet à déplacer Original: the object to be moved The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

Retourne la valeur

static_cast<typename std::remove_reference<T>::type&&>(t)

Exceptions

noexcept specification:  

noexcept

   (depuis C++11)

Exemple

#include <iostream>
#include <utility>
#include <vector>
#include <string>
int main()
{
    std::string str = "Hello";
    std::vector<std::string> v;
 
    // uses the push_back(const T&) overload, which means 
    // we'll incur the cost of copying str
    v.push_back(str);
    std::cout << "After copy, str is \"" << str << "\"\n";
 
    // uses the rvalue reference push_back(T&&) overload, 
    // which means no strings will copied; instead, the contents
    // of str will be moved into the vector.  This is less
    // expensive, but also means str might now be empty.
    v.push_back(std::move(str));
    std::cout << "After move, str is \"" << str << "\"\n";
 
    std::cout << "The contents of the vector are \"" << v[0]
                                         << "\", \"" << v[1] << "\"\n";
}

Résultat :

After copy, str is "Hello"
After move, str is ""
The contents of the vector are "Hello", "Hello"

Complexité

Constante

Original:

Constant

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Voir aussi

forward (C++11)	avant un argument de fonction Original: forwards a function argument The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (fonction générique)
move_if_noexcept (C++11)	obtient une référence rvalue si le constructeur mouvement ne jette pas Original: obtains an rvalue reference if the move constructor does not throw The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (fonction générique)