It’s called exactly to avoid problems. A new object serving as result is initialized from the locally-defined object, then the locally defined object is destroyed. In case of deep-copy user-defined constructor it’s all the same. First storage is allocated for the object that will serve as result, then the copy constructor is called. It uses … Read more
Yes, that’s a bad idea. All member variables of user-defined types will be initialized first, and then immediately overwritten. That swap trick is this: Foo& operator=(Foo rhs) // note the copying { rhs.swap(*this); //swap our internals with the copy of rhs return *this; } // rhs, now containing our old internals, will be deleted
Yes. There are two common options. One – which is generally discouraged – is to call the operator= from the copy constructor explicitly: MyClass(const MyClass& other) { operator=(other); } However, providing a good operator= is a challenge when it comes to dealing with the old state and issues arising from self assignment. Also, all members … Read more
The copy constructor generated by the compiler does member-wise copying. Sometimes that is not sufficient. For example: class Class { public: Class( const char* str ); ~Class(); private: char* stored; }; Class::Class( const char* str ) { stored = new char[srtlen( str ) + 1 ]; strcpy( stored, str ); } Class::~Class() { delete[] stored; … Read more
Yes. There are two common options. One – which is generally discouraged – is to call the operator= from the copy constructor explicitly: MyClass(const MyClass& other) { operator=(other); } However, providing a good operator= is a challenge when it comes to dealing with the old state and issues arising from self assignment. Also, all members … Read more
Yes, if the uninitialized member is not an unsigned narrow character type or std::byte, then copying a struct containing this indeterminate value with the implicitly defined copy constructor is technically undefined behavior, as it is for copying a variable with indeterminate value of the same type, because of [dcl.init]/12. This applies here, because the implicitly … Read more
Let’s put templates aside for a second. If a class doesn’t declare a copy constructor, an implicitly defaulted one is generated. It may be defined as deleted, but it’s defaulted nonetheless. A member template is not a member function. Members are instantiated from it only when needed. So how can a compiler know from the … Read more
Yes, that’s a bad idea. All member variables of user-defined types will be initialized first, and then immediately overwritten. That swap trick is this: Foo& operator=(Foo rhs) // note the copying { rhs.swap(*this); //swap our internals with the copy of rhs return *this; } // rhs, now containing our old internals, will be deleted
This is LWG2116. The choice between moving and copying the elements is often expressed as std::is_nothrow_move_constructible, i.e. noexcept(T(T&&)), which also erroneously checks the destructor.
std::thread takes its arguments by value. You can get reference semantics back by using std::reference_wrapper: std::thread newThread(session, &sock, std::ref(logger)); Obviously you must make sure that logger outlives the thread.