std:: assignable_from

El concepto assignable_from<LHS, RHS> especifica que una expresión del tipo y categoría de valor especificados por RHS puede ser asignada a una expresión lvalue cuyo tipo está especificado por LHS .

Requisitos semánticos

Dado

• lhs , un lvalue que se refiere a un objeto lcopy tal que decltype ( ( lhs ) ) es LHS ,
• rhs , una expresión tal que decltype ( ( rhs ) ) es RHS ,
• rcopy , un objeto distinto que es igual a rhs ,

assignable_from<LHS, RHS> se modela solo si

• std:: addressof ( lhs = rhs ) == std:: addressof ( lcopy ) (es decir, la expresión de asignación produce un lvalue que se refiere al operando izquierdo);
• Después de evaluar lhs = rhs :
  • lhs es igual a rcopy , a menos que rhs sea un xvalue no constante que se refiera a lcopy (es decir, la asignación es una auto-asignación de movimiento),
  • si rhs es un glvalue:
    • Si es un xvalue no constante, el objeto al que se refiere está en un estado válido pero no especificado;
    • En caso contrario, el objeto al que se refiere no se modifica;

Preservación de la igualdad

Las expresiones declaradas en las requires expressions de los conceptos de la biblioteca estándar deben ser equality-preserving (excepto cuando se indique lo contrario).

Notas

La asignación no necesita ser una función total. En particular, si asignar a algún objeto x puede causar que algún otro objeto y sea modificado, entonces x = y probablemente no esté en el dominio de = . Esto típicamente ocurre si el operando derecho es poseído directa o indirectamente por el operando izquierdo (por ejemplo, con punteros inteligentes a nodos en una estructura de datos basada en nodos, o con algo como std:: vector < std:: any > ).

Ejemplo

#include <atomic>
#include <concepts>
#include <string>
int main()
{
    // Uso básico normal, verifica la asignación de referencia 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>);
    // Los tipos fundamentales no admiten asignación a un rvalue
    static_assert(!std::is_assignable_v<int, int>);
    static_assert(!std::assignable_from<int, int>);
    // std::assignable_from no acepta todas las expresiones de asignación válidas:
    // asignación de referencia rvalue
    static_assert(std::is_assignable_v<std::string&&, std::string>);
    static_assert(!std::assignable_from<std::string&&, std::string>);
    // asignación rvalue
    static_assert(std::is_assignable_v<std::string, std::string>);
    static_assert(!std::assignable_from<std::string, std::string>);
    // std::atomic::operator= retorna por valor
    static_assert(std::is_assignable_v<std::atomic<int>&, int>);
    static_assert(!std::assignable_from<std::atomic<int>&, int>);
}

Referencias

Véase también