Pourquoi `std::move` est-il autorisé sur les objets const en C 11 ?

Comprendre std::move sur les objets const

En C 11, il est permis d'invoquer std::move sur un objet const, une action qui peut sembler illogique étant donné l’immuabilité de tels objets. Ce comportement a soulevé des inquiétudes quant à son potentiel à conduire à des erreurs de programmation subtiles.

Cependant, il est crucial de noter que std::move(const) ne modifie pas l'objet réel. Au lieu de cela, il demande simplement au compilateur de tenter une opération de déplacement. Si l'objet ne prend pas en charge la sémantique de déplacement (par exemple, s'il n'a pas de constructeur compatible), le compilateur invoquera automatiquement le constructeur de copie à la place.

Ce comportement permet aux développeurs d'utiliser en toute sécurité std::move pour les objets qui peuvent ou peut ne pas prendre en charge la sémantique de déplacement. Si une opération de déplacement est réalisable, le compilateur transférera efficacement la propriété, optimisant ainsi les performances. Cependant, si un déplacement n'est pas pris en charge, le code fonctionnera toujours correctement, mais avec la pénalité de performances associée à la copie.

Dans l'exemple fourni :

struct Cat {
   Cat(){}
};

const Cat cat;
std::move(cat); //this is valid in C++11

std::move( cat) invoquera effectivement le constructeur de copie puisque Cat ne définit pas de constructeur de déplacement. Ainsi, la nature const de l'objet est conservée, et aucune erreur ou comportement inattendu ne se produira.

Dans le cas de la classe Annotation dans l'exemple de Scott Meyers :

class Annotation {
public:
    explicit Annotation(const std::string text)
     : value(std::move(text))
};

Le compilateur tentera d'invoquer le constructeur std::string(std::string&&), mais comme le texte est const, le type réel de std::move(text) sera const std::string&&, qui ne correspond pas au std::string&& requis. Par conséquent, le constructeur std::string(const std::string&) sera appelé à la place, entraînant une pénalité de performances mais pas une erreur.

Par conséquent, même s'il peut sembler contre-intuitif d'invoquer std:: se déplacer sur des objets const, cela ne conduit pas intrinsèquement à des erreurs ou à une instabilité. Au lieu de cela, il permet un code flexible et efficace en permettant au compilateur de déterminer l'action appropriée en fonction de la disponibilité de la sémantique de déplacement pour l'objet spécifique.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!