move-semantics

I've got an API that looks like this: void WriteDefaultFileOutput(std::wostream &str, std::wstring target) { //Some code that modifies target before printing it and such... } I'm wondering if it'd be sensible to enable move semantics by doing this: void WriteDefaultFileOutput(std::wostream &str, std::wstring&& target) { //As above } void WriteDefaultFileOutput(std::wostream &str, std::wstring const& target) { std::wstring tmp(target); WriteDefaultFileOutput(str, std::move(tmp)); } or is this just boilerplate that the compiler should be able to figure out anyway? "Pass by value" can mean either

Consider the following class: class A { public: std::string field_a; std::string field_b; } Now consider the following copy construction: A a1(a2); The copy construction will adequately copy A despite the lack of of an explicit copy constructor because the copy constructors for std::string will be called by the compiler generated implicit copy constructor. What I wish to know is, is the same true for move construction? EDIT : Testing here shows that: A a2(std::move(a1)); Will actually result in a copy construction, unless the specific move constructor: A( A && other ) : a(std::move(other.a)) {

Being not declared constexpr , std::forward will discard constexpr-ness for any function it forwards arguments to. Why is std::forward not declared constexpr itself so it can preserve constexpr-ness? Example: (tested with g++ snapshot-2011-02-19) #include <utility> template <typename T> constexpr int f(T x) { return -13;} template <typename T> constexpr int g(T&& x) { return f(std::forward<T>(x));} int main() { constexpr int j = f(3.5f); // next line does not compile: // error: ‘constexpr int g(T&&) [with T = float]’ is not a constexpr function constexpr int j2 = g(3.5f); } Note: technically,

The function std::move() is defined as template<typename T> typename std::remove_reference<T>::type&& move(T && t) { return static_cast<typename std::remove_reference<T>::type&&>( t ); } There are four places where I can imagine the move constructor to be called: When the parameter is passed. When the cast is performed. When the result is returned. Not in the std::move() function itself but possibly at the place where the returned reference ultimately arrives. I would bet for number 4, but I'm not 100% sure, so please explain your answer. There is no move construction going on. std::move()

http://www.drdobbs.com/cpp/practical-c-error-handling-in-hybrid-env/197003350?pgno=4 In this article Herb Sutter explains that throwing an exception requires a copy of the exception as it's created as a temporary and therefore uses an std::auto_ptr to get round the copy overhead. In light of move semantics being made available in C++11 is this still necessary? I have just checked, and the Standard allows omitting the copy or move of an object specified by the operand of a throw expression into the exception object omitting the copy or move of the exception object into the catch clause variable

I have a struct Foo : struct Foo { v: String, // Other data not important for the question } I want to handle a data stream and save the result into Vec<Foo> and also create an index for this Vec<Foo> on the field Foo::v . I want to use a HashMap<&str, usize> for the index, where the keys will be &Foo::v and the value is the position in the Vec<Foo> , but I'm open to other suggestions. I want to do the data stream handling as fast as possible, which requires not doing obvious things twice. For example, I want to: allocate a String only once per one data stream reading not search the index

I know shared_ptr , unique_ptr , weak_ptr are guaranteed to be empty after used as RVR argument in the constructor of the same type, but I wonder does standard specifies this for some other std:: types beside the ones I mentioned. Please note that I know that elements after move are left in valid but unspecified state, I am here interested for which types state is specified. A rule of thumb As a rule of thumb: The move-only types or types with shared reference semantics leave their moved-from object in an empty state. All other types leave unspecified values. Move-only types Move-only types