From: s.gesemann@googlemail.com   
      
   On Tuesday, May 13, 2014 12:50:00 AM UTC+2, fran...@googlemail.com wrote:   
   >   
   >     Derived1 && build(void)   
   >     {   
   >         return std::move(Derived1());   
   >     }   
      
   I'd like to stress that rvalue references are not some magical powder   
   that you can spinkle on something to make it OK to return references   
   to function-local objects. The compiler does not do anything magical.   
   It returns a reference and this reference immediately becomes a   
   dangling reference because the temporary object ceases to exist.   
      
   Also, I'd like to mention that the use of std::move in cases where it   
   is not necessary, is a bad idea. In this case, it pretty much disables   
   the compiler warning about returning a reference to a function-local   
   object because the compiler is not aware of std::move returning   
   something that refers to the same object as its parameter does. (If   
   you're interested in a language that tracks lifetimes at compiletime   
   as part of the type system, you might want to look into Rust.)   
   Specifically, in a return statement with a temporary or function-local   
   object std::move is not necessary and actually prevents the RVO   
   optimization.   
      
   If you're interested in writing a class that should be able to move,   
   it's your job as a class author to tell the compiler via a move   
   constructor how a move is supposed to happen -- or better yet: Try   
   to write the class in a way that the special functions are created for   
   you by the compiler (referred to as "rule of zero" these days).   
      
   However, in your case you're interested in runtime polymorphism. This   
   demands an indirection, yes, but not using a reference as return type   
   for your factory functions. The natural choice would be a unique_ptr   
   from the std namespace via #include :   
      
      unique_ptr build(string const& what);   
      
   And if you don't have a special reason to turn your factory into a   
   class, then you should probably use a function. To quote John Carmack,   
   "Sometimes the elegant implementation is just a function. Not a   
   method. Not a class. Not a framework. Just a function."   
      
   Cheers!   
   sg   
      
      
   --   
         [ See http://www.gotw.ca/resources/clcm.htm for info about ]   
         [ comp.lang.c++.moderated.    First time posters: Do this! ]   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)