David Abrahams wrote:
Felipe Magno de Almeida <felipe.m.almeida@gmail.com> writes:
<snip> a giant message>
I can return a fresh NonCopyable and NonDefaultConstructible object from a function without often expensive heap operations.
Isnt that the boost::ref goal? Or am I missing something?
<snip> some more of the message
David, you are the man. Now I can answer this message! Well, I'm going to give rise to a new giant... Readers, please bother to crop it when replying. From Introduction section at http://www.boost.org/doc/html/ref.html I see that boost::ref I see that is isn't the boost::ref goal. Boost.Ref can save some CPU cycles only if I deal with hostile pieces of code such as std::foreach() which refuse to work with references. If I write all code myself, I don't need boost::ref. In complex cases type_traits can help me and compiler to handle references correctly. Consider the following rather typical scenarios when you return a std::string. These examples are a bit artificial, but in some circumstances default construction, dynamic memory and copying can be computationally too expensive or not available at all. The following versions are not ideal: std::string foo() { return "bar"; } ... std::string bar = foo(); -------- void foo( std::string & bar) { bar = "bar" ; } ... std::string bar; foo(bar); ---------- std::string * foo() { return new std::string("bar"); } ... std::auto_ptr<std::string> bar = foo(); ----------- Each of them includes some extra operations which aren't necessary. Version 1 is terrible, version 2 uses an extra default construction, version 3 uses an extra memory allocation. Here is a better version: void foo( std::string * bar ) { new (bar) std::string("bar"); } ... char bar_placeholder[sizeof(std::string]; std::string *bar = reinterpret_cast<std::string*>(bar_placeholder); foo(bar); ... bar->~std::string(); It uses just one constructor call, no extra default constructors and no dynamic memory allocation. So far after reading the documentation, it seems to me that boost::optional provides a nice encapsuation for this bulk of code. void foo(boost::optional<std::string> & bar) { bar = boost::in_place("bar"); } ... boost::optional<std::string> bar; foo(bar); But unlike raw code, this approach also creates a copy of "bar" char* stored in a temporary factory object. Does boost::optional have a way to avoid these temporaries too? Does it have something like bar.in_place("bar); or in_place(bar, "bar"); ? Andrey