Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      std::unique_ptr<T,Deleter>::operator=

      From cppreference.com
      <cpp‎ |memory‎ |unique ptr
       
       
      Memory management library
      (exposition only*)
      Allocators
      Uninitialized memory algorithms
      Constrained uninitialized memory algorithms
      Memory resources
      Uninitialized storage(until C++20)
      (until C++20*)
      (until C++20*)
      Garbage collector support(until C++23)
      (C++11)(until C++23)
      (C++11)(until C++23)
      (C++11)(until C++23)
      (C++11)(until C++23)
      (C++11)(until C++23)
      (C++11)(until C++23)
       
       
      unique_ptr& operator=( unique_ptr&& r)noexcept;
      (1)(constexpr since C++23)
      template<class U,class E>
      unique_ptr& operator=( unique_ptr<U, E>&& r)noexcept;
      (2)(constexpr since C++23)
      unique_ptr& operator=(std::nullptr_t)noexcept;
      (3)(constexpr since C++23)
      unique_ptr& operator=(const unique_ptr&)= delete;
      (4)
      1) Move assignment operator. Transfers ownership fromr to*this as if by callingreset(r.release()) followed by assigningget_deleter() fromstd::forward<Deleter>(r.get_deleter()).
      This overload participates in overload resolution only ifstd::is_move_assignable<Deleter>::value istrue.
      IfDeleter is not a reference type, the behavior is undefined if
      Otherwise (Deleter is a reference type), the behavior is undefined if
      2) Converting assignment operator. Transfers ownership fromr to*this as if by callingreset(r.release()) followed by assigningget_deleter() fromstd::forward<E>(r.get_deleter()).
      This overload participates in overload resolution only if all following conditions are satisfied:
      • std::is_assignable<Deleter&, E&&>::value istrue.
      • For the primary template, all following conditions are satisfied:
        • U is not an array type.
        • unique_ptr<U, E>::pointer is implicitly convertible topointer, and.
      • For the array specialization (unique_ptr<T[]>), all following conditions are satisfied:
        • U is an array type.
        • pointer is the same type aselement_type*.
        • unique_ptr<U, E>::pointer is the same type asunique_ptr<U, E>::element_type*.
        • unique_ptr<U, E>::element_type(*)[] is convertible toelement_type(*)[].
      IfE is not a reference type, the behavior is undefined if assigningget_deleter() from anrvalue of typeE is ill-formed or would throw an exception.
      Otherwise (E is a reference type), the behavior is undefined if assigningget_deleter() from anlvalue of typeE is ill-formed or would throw an exception.
      3) Effectively the same as callingreset().
      4) Copy assignment operator is explicitly deleted.

      Contents

      [edit]Parameters

      r - smart pointer from which ownership will be transferred

      [edit]Return value

      *this

      [edit]Notes

      As a move-only type,unique_ptr's assignment operator only acceptsrvalues arguments (e.g. the result ofstd::make_unique or astd::move'dunique_ptr variable).

      [edit]Example

      Run this code
      #include <iostream>#include <memory> struct Foo{int id;    Foo(int id): id(id){std::cout<<"Foo "<< id<<'\n';}    ~Foo(){std::cout<<"~Foo "<< id<<'\n';}}; int main(){std::unique_ptr<Foo> p1(std::make_unique<Foo>(1)); {std::cout<<"Creating new Foo...\n";std::unique_ptr<Foo> p2(std::make_unique<Foo>(2));// p1 = p2; // Error ! can't copy unique_ptr        p1= std::move(p2);std::cout<<"About to leave inner block...\n"; // Foo instance will continue to live,// despite p2 going out of scope} std::cout<<"About to leave program...\n";}

      Output:

      Foo 1Creating new Foo...Foo 2~Foo 1About to leave inner block...About to leave program...~Foo 2

      [edit]Defect reports

      The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

      DRApplied toBehavior as publishedCorrect behavior
      LWG 2047C++11for overload(2),get_deleter() was assigned from
      std::forward<Deleter>(r.get_deleter())
      corrected to
      std::forward<E>(r.get_deleter())
      LWG 2118C++11unique_ptr<T[]>::operator=
      rejected qualification conversions
      accepts
      LWG 2228
      (N4366)
      C++11the converting assignment operator
      was missing the assignability constraint
      added the constraint
      LWG 2246C++11the assignment target of the converted
      deleter ofr was not specified
      specified asget_deleter()
      LWG 2899C++11the move assignment operator was not constrainedconstrained
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/memory/unique_ptr/operator%3D&oldid=178191"

      [8]ページ先頭

      ©2009-2025 Movatter.jp