rvalue-reference

I have used std::move and std::forward in C++. My question is: how are these functions actually implemented by the standard library? If an lvalue is something you can get the address of, and an rvalue is exclusively not an lvalue, how can you actually implement these references? Do these new facilities allow for something like: auto x = &(3); or something like that? Can you get a reference to an rvalue that isn't just a std::move / forward returned lvalue? Hopefully these questions make sense. I couldn't find good information on Google, just tutorials on perfect forwarding, etc. Jonathan Mee I

local lvalue references-to-const and rvalue references can extend the lifetime of temporaries: const std::string& a = std::string("hello"); std::string&& b = std::string("world"); Does that also work when the initializer is not a simple expression, but uses the conditional operator? std::string&& c = condition ? std::string("hello") : std::string("world"); What if one of the results is a temporary object, but the other one isn't? std::string d = "hello"; const std::string& e = condition ? d : std::string("world"); Does C++ mandate the lifetime of the temporary be extended when the condition is

#include <set> #include <string> #include <cassert> using namespace std::literals; int main() { auto coll = std::set{ "hello"s }; auto s = "hello"s; coll.insert(std::move(s)); assert("hello"s == s); // Always OK? } Does the C++ standard guarantee that a failed insertion into an associative container will not modify the rvalue-reference argument? SergeyA Explicit and unequivocal NO . Standard doesn't have this guarantee, and this is why try_emplace exists. See notes: Unlike insert or emplace, these functions do not move from rvalue arguments if the insertion does not happen , which makes it

I was learning passing by reference, and here is the test I did: #include <iostream> using namespace std; int i = 0; //If this is uncommented, compiler gives ambiguous definition error. //void paramCheck (string s) { // cout << ++i << ". Param is var.\n"; //} void paramCheck (const string& s) { cout << ++i << ". Param is const ref.\n"; } void paramCheck (string& s) { cout << ++i << ". Param is non-const ref.\n"; } void paramCheck (const string&& s) { cout << ++i << ". Param is const rvalue-reference.\n"; } void paramCheck (string&& s) { cout << ++i << ". Param is non-const rvalue-reference.\n"

I have recently wrapped my mind around the C++0x's concepts of glvalues, xvalues and prvalues, as well as the rvalue references. However, there's one thing which still eludes me: What is "an rvalue reference to function type" ? It is literally mentioned many times in the drafts. Why was such a concept introduced? What are the uses for it? I hate to be circular, but an rvalue reference to function type is an rvalue reference to function type. There is such a thing as a function type, e.g. void () . And you can form an rvalue reference to it. In terms of the classification system introduced by

I'm using MSVC, Visual Studio 2013. Suppose I have a struct: struct my_pair { int foo, bar; }; And I want to add a bunch of these efficiently, without too creating a temporary and then discarding it: vector<my_pair> v; v.push_back(41, 42); // does not work [a] v.push_back({41,42}); // works [b] v.emplace_back(41,42); // does not work [c] v.emplace_back({41,42}); // does not work [d] v.emplace_back(my_pair{41,42}); //works [e] Now if I add a constructor and copy constructor to my code: my_pair(int foo_, int bar_) : foo(foo_), bar(bar_) { cout << "in cstor" << endl; } my_pair(const my_pair& copy