Namespaces
Variants

    swap(std::expected)

    De es.cppreference.net
     
    C++
    Soporte de compiladores
    Independiente y alojado
    Lenguaje
    Biblioteca estándar
    Encabezados de la biblioteca estándar
    Requisitos nombrados
    Macros de prueba de características (C++20)
    Biblioteca de soporte de lenguaje
    Biblioteca de conceptos (C++20)
    Biblioteca de diagnóstico
    Biblioteca de gestión de memoria
    Biblioteca de metaprogramación (C++11)
    Biblioteca de utilidades generales
    Biblioteca de contenedores
    Biblioteca de iteradores
    Biblioteca de rangos (C++20)
    Biblioteca de algoritmos
    Biblioteca de cadenas
    Biblioteca de procesamiento de texto
    Biblioteca numérica
    Biblioteca de fecha y hora
    Biblioteca de entrada/salida
    Biblioteca del sistema de archivos (C++17)
    Biblioteca de soporte de concurrencia (C++11)
    Biblioteca de control de ejecución (C++26)
    Especificaciones técnicas
    Índice de símbolos
    Bibliotecas externas
     
    Biblioteca de utilidades
    Soporte de lenguaje
    Soporte de tipos (tipos básicos, RTTI)
    Macros de prueba de características de biblioteca (C++20)
    Utilidades de programa
    Funciones variádicas
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Soporte de corrutinas (C++20)
    Soporte de contratos (C++26)
    Comparación de tres vías
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Utilidades generales
    Operadores relacionales (obsoleto en C++20)
     
    std::expected
     
    friend constexpr void swap( expected& lhs, expected& rhs ) noexcept(/*see below*/);
    		(desde C++23)

    Sobrecarga el algoritmo std::swap para std::expected. Intercambia el estado de lhs con el de rhs. Efectivamente llama a lhs.swap(rhs).

    Esta sobrecarga participa en la resolución de sobrecarga solo si lhs.swap(rhs) es válido.

    Esta función no es visible para la búsqueda no calificada o calificada ordinaria, y solo se puede encontrar mediante búsqueda dependiente de argumentos cuando std::expected<T, E> es una clase asociada de los argumentos.

    Parámetros

    lhs, rhs - expected objetos cuyos estados intercambiar

    Valor de retorno

    (ninguno)

    Excepciones

    noexcept especificación:
    noexcept ( noexcept ( lhs. swap ( rhs ) ) )

    Ejemplo

    Ejecutar este código 
    #include <expected>
#include <iostream>
#include <string_view>
using Ex = std::expected<std::string, int>;
void show(const Ex& ex1, const Ex& ex2, std::string_view term = "\n")
{
    for (int i{}; i != 2; ++i)
    {
        std::cout << (i ? "ex2" : "ex1");
        if (const Ex& ex = (i ? ex2 : ex1); ex.has_value())
            std::cout << ".value() = " << *ex << "  ";
        else
            std::cout << ".error() = " << ex.error() << "  ";
    {
    std::cout << term;
}
int main()
{
    Ex ex1("\N{SMILING FACE WITH SUNGLASSES}");
    Ex ex2{"\N{SLIGHTLY SMILING FACE}"};
    show(ex1, ex2, "after swap(ex1, ex2):\n");
    std::swap(ex1, ex2);
    show(ex1, ex2, "\n\n");
    ex2 = std::unexpected(13);
    show(ex1, ex2, "after swap(ex1, ex2):\n");
    std::swap(ex1, ex2);
    show(ex1, ex2, "\n\n");
    ex2 = std::unexpected(37);
    show(ex1, ex2, "after swap(ex1, ex2):\n");
    std::swap(ex1, ex2);
    show(ex1, ex2);
}

    Salida: 

    ex1.value() = 😎  ex2.value() = 🙂  after swap(ex1, ex2):
ex1.value() = 🙂  ex2.value() = 😎  
ex1.value() = 🙂  ex2.error() = 13  after swap(ex1, ex2):
ex1.error() = 13  ex2.value() = 🙂  
ex1.error() = 13  ex2.error() = 37  after swap(ex1, ex2):
ex1.error() = 37  ex2.error() = 13

    Véase también

    		intercambia los contenidos
    (función miembro pública)