Namespaces
Variants

    cpp/named req/ValueSwappable: Difference between revisions

    From cppreference.com
    ← Older edit
    Space Mission (talk | contribs)
    19,873 edits
    m +C++11 in title
    Andreas Krug (talk | contribs)
    8,213 edits
    m fmt, .
     
    Line 6: Line 6:
    A type T is {{named req/core|ValueSwappable}} if
    A type T is {{named req/core|ValueSwappable}} if


    # {{tt|T}} satisfies the {{named req|Iterator}} requirements
    # {{tt|T}} satisfies the {{named req|Iterator}} requirements
    # For any dereferenceable object {{tt|x}} of type {{tt|T}} (that is, any value other than the end iterator), {{tt|*x}} satisfies the {{named req|Swappable}} requirements.
    # For any dereferenceable object {{tt|x}} of type {{tt|T}} (that is, any value other than the end iterator), {{tt|*x}} satisfies the {{named req|Swappable}} requirements.


    Line 13: Line 13:
    ===Example===
    ===Example===
    {{example
    {{example
    |
    |code=
    | code=
     
    #include <iostream>
    #include <iostream>
    #include <vector>
    #include <vector>


    class IntVector {
    class IntVector
    {
         std::vector<int> v;
         std::vector<int> v;
    //  IntVector& operator=(IntVector); // not assignable (C++98 way)
    //  IntVector& operator=(IntVector); // not assignable (C++98 way)
    public:
    public:
         IntVector& operator=(IntVector) = delete; // not assignable
         IntVector& operator=(IntVector) = delete; // not assignable
         void swap(IntVector& other) {
         void swap(IntVector& other)
    {
             v.swap(other.v);
             v.swap(other.v);
         }
         }
    };
    };
    void swap(IntVector& v1, IntVector& v2) {
     
    void swap(IntVector& v1, IntVector& v2)
    {
         v1.swap(v2);
         v1.swap(v2);
    }
    }
    Line 44: Line 46:
    ===See also===
    ===See also===
    {{dsc begin}}
    {{dsc begin}}
    {{dsc inc | cpp/iterator/dsc indirectly_swappable}}
    {{dsc inc|cpp/iterator/dsc indirectly_swappable}}
    {{dsc end}}
    {{dsc end}}


    {{langlinks|de|es|fr|it|ja|pt|ru|zh}}
    {{langlinks|de|es|fr|it|ja|pt|ru|zh}}

    Latest revision as of 11:11, 9 August 2023

     
    C++
     
    C++ named requirements
     

    Two objects of this type can be dereferenced and the resulting values can be swapped using unqualified function call swap() in the context where both std::swap and the user-defined swap()s are visible.

    Requirements

    A type T is ValueSwappable if

    1. T satisfies the LegacyIterator requirements.
    2. For any dereferenceable object x of type T (that is, any value other than the end iterator), *x satisfies the Swappable requirements.

    Many standard library functions expect their arguments to satisfy ValueSwappable, which means that any time the standard library performs a swap, it uses the equivalent of using std::swap; swap(*iter1, *iter2);.

    Example

    Run this code
    #include <iostream>
#include <vector>

class IntVector
{
    std::vector<int> v;
//  IntVector& operator=(IntVector); // not assignable (C++98 way)
public:
    IntVector& operator=(IntVector) = delete; // not assignable
    void swap(IntVector& other)
    {
        v.swap(other.v);
    }
};

void swap(IntVector& v1, IntVector& v2)
{
    v1.swap(v2);
}

int main()
{
    IntVector v1, v2;    // IntVector is Swappable, but not MoveAssignable
    IntVector* p1 = &v1;
    IntVector* p2 = &v2; // IntVector* is ValueSwappable
    std::iter_swap(p1, p2); // OK: iter_swap requires ValueSwappable
//  std::swap(v1, v2); // compiler error! std::swap requires MoveAssignable
}

    See also

    (C++20)
    		 specifies that the values referenced by two indirectly_readable types can be swapped
    (concept) [edit]