std:: assignable_from

Le concept assignable_from<LHS, RHS> spécifie qu'une expression du type et de la catégorie de valeur spécifiés par RHS peut être assignée à une expression lvalue dont le type est spécifié par LHS .

Exigences sémantiques

Étant donné

• lhs , une lvalue qui fait référence à un objet lcopy tel que decltype ( ( lhs ) ) est LHS ,
• rhs , une expression telle que decltype ( ( rhs ) ) est RHS ,
• rcopy , un objet distinct qui est égal à rhs ,

assignable_from<LHS, RHS> est modélisé seulement si

• std:: addressof ( lhs = rhs ) == std:: addressof ( lcopy ) (c'est-à-dire que l'expression d'assignation produit une lvalue se référant à l'opérande gauche) ;
• Après l'évaluation de lhs = rhs :
  • lhs est égal à rcopy , sauf si rhs est une xvalue non constante qui se réfère à lcopy (c'est-à-dire que l'assignation est une auto-affectation par déplacement) ;
  • si rhs est une glvalue :
    • Si c'est une xvalue non constante, l'objet auquel elle se réfère est dans un état valide mais non spécifié ;
    • Sinon, l'objet auquel elle se réfère n'est pas modifié ;

Préservation de l'égalité

Les expressions déclarées dans les requires expressions des concepts de la bibliothèque standard doivent être equality-preserving (sauf indication contraire).

Notes

L'assignation n'a pas besoin d'être une fonction totale. En particulier, si l'assignation à un objet x peut entraîner la modification d'un autre objet y , alors x = y n'appartient probablement pas au domaine de = . Cela se produit typiquement lorsque l'opérande droit est possédé directement ou indirectement par l'opérande gauche (par exemple, avec des pointeurs intelligents vers des nœuds dans une structure de données à base de nœuds, ou avec quelque chose comme std:: vector < std:: any > ).

Exemple

#include <atomic>
#include <concepts>
#include <string>
int main()
{
    // Utilisation basique normale, vérifie l'assignation par référence lvalue
    static_assert(std::is_assignable_v<int&, int>);
    static_assert(std::assignable_from<int&, int>);
    static_assert(std::is_assignable_v<std::string&, std::string>);
    static_assert(std::assignable_from<std::string&, std::string>);
    // Les types fondamentaux ne supportent pas l'assignation à une rvalue
    static_assert(!std::is_assignable_v<int, int>);
    static_assert(!std::assignable_from<int, int>);
    // std::assignable_from n'accepte pas toutes les expressions d'assignation valides :
    // assignation par référence rvalue
    static_assert(std::is_assignable_v<std::string&&, std::string>);
    static_assert(!std::assignable_from<std::string&&, std::string>);
    // assignation rvalue
    static_assert(std::is_assignable_v<std::string, std::string>);
    static_assert(!std::assignable_from<std::string, std::string>);
    // std::atomic::operator= retourne par valeur
    static_assert(std::is_assignable_v<std::atomic<int>&, int>);
    static_assert(!std::assignable_from<std::atomic<int>&, int>);
}

Références

Voir aussi