move-semantics

问题 I have two objects where the second one requires the fist one to outlive it because it holds a reference to the first one. I need to move both of them into a thread, but the compiler is complaining that the first one doesn't live long enough. Here is the code: use std::thread; trait Facade: Sync { fn add(&self) -> u32; } struct RoutingNode<'a> { facade: &'a (Facade + 'a), } impl<'a> RoutingNode<'a> { fn new(facade: &'a Facade) -> RoutingNode<'a> { RoutingNode { facade: facade } } } fn main()

问题 According to http://www.boost.org/doc/libs/1_61_0/doc/html/boost_asio/reference/Handler.html, a handler provided to io_service::post must be copy constructible. However, this excludes a scenario where a socket is accepted, and the response handler is moved, guaranteeing me that there is only one handler for the job: auto socket = std::make_unique<socket>(); accepter.accept(*socket); service.post([s{std::move(socket)}] { asio::write(*s, buffer("response"), ignored_err); }); So why is this copy

问题 I have a simple class structure modelling a discrete simulation, with a vector of States, which each contain a number of Transitions, held as a vector of smart pointers. I've used smart pointers to hold the transitions as in my full application I need polymorphism. #include <vector> #include <memory> class Transition { public: Transition() {} }; class State { public: State(int num) : num(num), transitions() {} void add_transition(std::unique_ptr<Transition> trans) { transitions.push_back(std:

问题 I have a simple class structure modelling a discrete simulation, with a vector of States, which each contain a number of Transitions, held as a vector of smart pointers. I've used smart pointers to hold the transitions as in my full application I need polymorphism. #include <vector> #include <memory> class Transition { public: Transition() {} }; class State { public: State(int num) : num(num), transitions() {} void add_transition(std::unique_ptr<Transition> trans) { transitions.push_back(std:

问题 What is the definition of the default move constructor? I can't think of anything sensible. Maybe a swap on ptr members and copy on values/reference member? 回答1: That's what the standard says (12.8/15): The implicitly-defined copy/move constructor for a non-union class X performs a memberwise copy/move of its bases and members. [ Note: brace-or-equal-initializers of non-static data members are ignored. See also the example in 12.6.2. —end note ] The order of initialization is the same as the

问题 This code compiles and runs fine: #include <iostream> class Base { public: Base(int value) : clean_(true) { value_ = new int; *value_ = value; } ~Base() { if(clean_) delete value_; } Base(Base&& other) noexcept : value_{std::move(other.value_)}, clean_(true) { other.clean_=false; } Base& operator=(Base&& other) noexcept { value_ = std::move(other.value_); other.clean_=false; clean_=true; } void print() { std::cout << value_ << " : " << *value_ << std::endl; } int* value_; bool clean_; };

问题 My default behaviour for any objects in local scopes is to make it const . E.g.: auto const cake = bake_cake(arguments); I try to have as little non-functional code as I can as this increases readability (and offers some optimisation opportunities for the compiler). So it is logical to also reflect this in the type system. However, with move semantics, this creates the problem: what if my cake is hard or impossible to copy and I want to pass it out after I'm done with it? E.g.: if (tastes

问题 My default behaviour for any objects in local scopes is to make it const . E.g.: auto const cake = bake_cake(arguments); I try to have as little non-functional code as I can as this increases readability (and offers some optimisation opportunities for the compiler). So it is logical to also reflect this in the type system. However, with move semantics, this creates the problem: what if my cake is hard or impossible to copy and I want to pass it out after I'm done with it? E.g.: if (tastes

问题 My default behaviour for any objects in local scopes is to make it const . E.g.: auto const cake = bake_cake(arguments); I try to have as little non-functional code as I can as this increases readability (and offers some optimisation opportunities for the compiler). So it is logical to also reflect this in the type system. However, with move semantics, this creates the problem: what if my cake is hard or impossible to copy and I want to pass it out after I'm done with it? E.g.: if (tastes

问题 Prior to C++11, it has always been the case that copy assignment operator should always pass by const reference, like so: template <typename T> ArrayStack<T>& operator= (const ArrayStack& other); However, with the introduction of move assignment operators and constructors, it seems that some people are advocating using pass by value for copy assignment instead. A move assignment operator also needs to be added: template <typename T> ArrayStack<T>& operator= (ArrayStack other); ArrayStack<T>&