Move

As explained in C++ Concurrency in Action, Second Edition

Move semantics are C++ language features that allow resources to be transferred from one object to another without copying them.

void some_function();
void some_other_function();
std::thread t1(some_function);
std::thread t2=std::move(t1);
t1=std::thread(some_other_function);
std::thread t3;
t3=std::move(t2);
t1=std::move(t3);          #1

How C++ Concurrency in Action, Second Edition covers it

How deep it goes

Explains explicit moves from named objects, implicit moves from temporaries, and termination when assignment overwrites a thread-owning destination.

Examples

Uses ownership transfers among three std::thread objects and shows returning or passing threads.

What you can do after

Apply it via std::move to transfer named std::thread ownership without assigning over an already-associated destination.

How it connects

Connects std::thread transfers to move-only standard-library resources and thread-owning wrappers.

liveBookmanning.com

Read C++ Concurrency in Action, Second Edition on liveBook Get the book at manning.com

Also explained in

• 

  liveBookmanning.com
  Learn Rust in a Month of LunchesMove semantics is the behavior in which transferring a non-Copy value transfers its ownership and prevents use of the original binding.
• 

  liveBookmanning.com
  Refactoring to RustMove semantics is Rust's ownership-transfer behavior, under which a value becomes inaccessible through its original binding after transfer.
• 

  liveBookmanning.com
  Rust in Action: Systems programming concepts and techniquesMove semantics define how transferring ownership of a value invalidates or relocates its previous binding instead of implicitly copying the value.
• 

  liveBookmanning.com
  Idiomatic RustMove semantics transfer ownership of a value into a new binding or operation rather than copying the value.

Compare how 5 books explain move →

Related concepts

• closureconfigures · A closure is a function or callable value together with access to bindings from the lexical environment in which it was created.
• ownershipuses · Ownership is a programming-language model that assigns responsibility for controlling a value or resource, including its lifetime and eventual cleanup.
• copy semanticscontrasts with · Copy semantics are the rules by which copying a value creates an independent representation while leaving the original usable.
• copycontrasts with · Copying is the creation of a separate representation of an existing value, object, or data, preserving some or all of its contents or state.
• big fiveused by · The rule of five is a C++ guideline that classes managing resources should consider defining a destructor, copy constructor, copy assignment operator, move constructor, and move assignment operator.
• referencealternative to · A reference is an indirect value or relationship that identifies or provides access to another value, object, resource, or source.

This explainer was generated by Manning's knowledge graph from the text of C++ Concurrency in Action, Second Edition. The section links point to the parts of the book it draws on.