move-constructor

问题 Following up a comment from this question: how can I find move constructors in C++ codebase using Clang AST tools? (find definitions / declarations only) 回答1: The Clang AST matcher now provides this functionality with the isMoveConstructor matcher. Here's an example program: #include <iostream> #include "clang/AST/AST.h" #include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/Basic/SourceManager.h" #include "clang/Basic/SourceLocation.h"

问题 This question already has answers here : Closed 7 years ago . Possible Duplicate: Why copy constructor is not called in this case? What are copy elision and return value optimization? Can anybody explain to me why the following program yields output "cpy: 0" (at least when compiled with g++ 4.5.2): #include<iostream> struct A { bool cpy; A() : cpy (false) { } A (const A & a) : cpy (true) { } A (A && a) : cpy (true) { }; }; A returnA () { return A (); } int main() { A a ( returnA () ); std:

问题 This program: test_header.hpp #include <boost/signal.hpp> #include <utility> class Sensor; class Recorder : public ::boost::signals::trackable { public: explicit Recorder(int id) : id_(id) {} // Cannot be copied Recorder(const Recorder &) = delete; Recorder &operator =(const Recorder &) = delete; // But can be moved so it can be stored in a vector. // There's a proposal for having a compiler generated default for this that would be // very convenient. Recorder(Recorder &&b) : id_(b.id_) { b

问题 I'd like to detect (and use the result in std::enable_if ) whether a C++ class has a move constructor defined. The following program prints MOVE , so using std::is_move_constructible is not the way to do it: #include <stdio.h> #include <type_traits> class C { public: C() { puts("C()"); } C(int) { puts("C(int)"); } ~C() { puts("~C()"); } C(const C&) { puts("C(const C&)"); } // C(C&&) { puts("C(C&&)"); } C& operator=(const C&) { puts("C="); return *this; } }; int main(int argc, char** argv) {

问题 Just came from is_assignable and std::unique_ptr. @Angew tells me that because std::unique_ptr<int, do_nothing> and std::unique_ptr<int> are different types, so static_assert(not std::is_assignable<std::unique_ptr<int>, std::unique_ptr<int, do_nothing>>::value, ""); . So, I tried: template<typename T, typename D> struct MoveAssignOnly_V2 { MoveAssignOnly_V2& operator=(MoveAssignOnly_V2&) = delete; MoveAssignOnly_V2& operator=(MoveAssignOnly_V2&&) noexcept {} }; int main() { static_assert(not

问题 I have a struct that i want to be non copyable, only movable, but as it contains a lot of POD, writing move constructor would be long and forgetting a variable would be hard to debug. Example: struct myStruct{ int a,b,c,d; double e,f,g,h; std::complex<double> value1,value2; std::unique_ptr<Calculator> calc; myStruct(){} myStruct(const myStruct &)=delete; myStruct(myStruct && other); }; What would be the problems with this kind of move constructor: myStruct::myStruct(myStruct && other){ std:

问题 //code from https://skillsmatter.com/skillscasts/2188-move-semanticsperfect-forwarding-and-rvalue-references class Widget { public: Widget(Widget&& rhs) : pds(rhs.pds) // take source’s value { rhs.pds = nullptr; // why?? } private: struct DataStructure; DataStructure *pds; }; I can't understand the reason for setting rhd.pds to nullptr . What will happen if we remove this line : rhs.pds = nullptr; 回答1: Some details of the class have been removed. In particular, the constructor dynamically

问题 I have this simple class: struct Worker { Worker() : done{false} {} Worker(const Worker& rhs) : done{rhs.done}, qworker{} {} Worker(Worker &&rhs) : done{rhs.done} { qworker = std::move(rhs.qworker); } ... } this compile fine with gcc-4.7.2 but if I try to use this version I obtain an error struct Worker { Worker() : done{false} {} Worker(const Worker& rhs) : done{rhs.done}, qworker{} {} Worker(Worker &&rhs) : done{rhs.done} , qworker{std::move(rhs.qworker)} // <- ERROR { } ... } Why? In file

问题 I've already tried to ask this question but I wasn't clear enough. So here is one more try. And I am very sorry for my English ;) Let's see the code: #include <iostream> #include <memory> using namespace std; struct A { unique_ptr<int> ref; void printRef() { if (ref.get()) cout<<"i="<<*ref<<endl; else cout<<"i=NULL"<<endl; } A(const int i) : ref(new int(i)) { cout<<"Constructor with "; printRef(); } ~A() { cout<<"Destructor with"; printRef(); } }; int main() { A a[2] = { 0, 1 }; return 0; }

问题 The MSDN article, How to: Write a Move Constuctor, has the following recommendation. If you provide both a move constructor and a move assignment operator for your class, you can eliminate redundant code by writing the move constructor to call the move assignment operator. The following example shows a revised version of the move constructor that calls the move assignment operator: // Move constructor. MemoryBlock(MemoryBlock&& other) : _data(NULL) , _length(0) { *this = std::move(other); }