move-semantics

Is it possible to replace one std::function from within itself with another std::function ? The following code does not compile: #include <iostream> #include <functional> int main() { std::function<void()> func = []() { std::cout << "a\n"; *this = std::move([]() { std::cout << "b\n"; }); }; func(); func(); func(); } Can it be modified to compile? The error message right now is: 'this' was not captured for this lambda function - which I completely understand. I don't know, however, how I could capture func 's this -pointer. I guess, it is not even a std::function inside the lambda, yet?! How

Trying to provide a solution to std::string_view and std::string in std::unordered_set , I'm playing around with replacing std::unordered_set<std::string> with std::unordered_map<std::string_view, std::unique_ptr<std::string>> (the value is std::unique_ptr<std::string> because the small string optimization would mean that the address of the string 's underlying data will not always be transferred as a result of std::move . My original test code, that seems to work, is (omitting headers): using namespace std::literals; int main(int argc, char **argv) { std::unordered_map<std::string_view, std:

Take for example this code: #include <type_traits> #include <iostream> struct Foo { Foo() = default; Foo(Foo&&) = delete; Foo(const Foo&) noexcept { std::cout << "copy!" << std::endl; }; }; struct Bar : Foo {}; static_assert(!std::is_move_constructible_v<Foo>, "Foo shouldn't be move constructible"); // This would error if uncommented //static_assert(!std::is_move_constructible_v<Bar>, "Bar shouldn't be move constructible"); int main() { Bar bar {}; Bar barTwo { std::move(bar) }; // prints "copy!" } Because Bar is derived from Foo, it doesn't have a move constructor. It is still constructible

C++11 introduced new value categories, one of them is xvalue . It is explained by Stroustrup as something like ( im category): "it is a value, which has identity, but can be moved from". Another source, cppreference explains: a glvalue is an expression whose evaluation determines the identity of an object, bit-field, or function; And xvalue is a glvalue , so this is statement is true for xvalue too. Now, I thought that if an xvalue has identity, then I can check if two xvalue s refer to the same object, so I take the address of an xvalue . As it turned out, it is not allowed: int main() { int

I only have access to C++03 and I often want to move a vector into a function the way you can do it in C++11. The question how to do it not to confuse the user of the code too much. So my question is how did programmers do it before C++11. I know that vector can be "moved" using swap function. So here is what I have come up with: class Foo { public: Foo(std::vector<int>& vec) { using std::swap; swap(vec, m_vec); // "move" vec into member vector } private: std::vector<int> m_vec; }; // usage: std::vector<int> v(100, 1337); Foo foo(v); // v.empty() == true The problem with this approach is that

This question already has an answer here: How to enforce move semantics when a vector grows? 3 answers Given class X below (special member functions other than the one explicitly defined are not relevant for this experiment): struct X { X() { } X(int) { } X(X const&) { std::cout << "X(X const&)" << std::endl; } X(X&&) { std::cout << "X(X&&)" << std::endl; } }; The following program creates a vector of objects of type X and resizes it so that its capacity is exceeded and reallocation is forced: #include <iostream> #include <vector> int main() { std::vector<X> v(5); v.resize(v.capacity() + 1); }