9

In this talk by Sutter at 1:15:26 it was presented a code like below,

class employee{
 std::string name_;

public:
template<class String, class=
 std::enable_if_t< !std::is_same<std::decay_t<String>, std::string>::value > >
void set_name(String && name)
   noexcept(std::isnothrow_assignable<std::string &, String>::value)
  {
    name_ = std::forward<String>(name);
  }
}

I know how std::forward works, if name is a lvalue, name_ will get copy constructed; and if name is a rvalue, name_ will get move constructed. But in the slide it also says that Optimized to steal from rvalues (and more), what is more?

And later it shows that this code seems the fastest among all the four implementations, especially for char *, anybody has the patience to walk through this code and explain what more is being optimized and why it is the fastest, particularly in the case of char * ?

Allanqunzi
  • 3,230
  • 1
  • 26
  • 58
  • Note the functions he is comparing against take a `std::string` in one form or another. If your goal was just to write code that was fast for `char *` you don't _have_ to use perfect forwarding. – Chris Drew Aug 26 '15 at 02:47

1 Answers1

10

First of all, note that the code contains a typo and that the enable_if constraint does not do what's discussed even with the typo removed; In particular the function just won't work with char*, so obviously it's not the fastest with char*. You can see a question I asked about this here along with a 'corrected' perfect forwarding setter (along with the endorsement of this version from Howard Hinnant).

template <class String>
auto set_name(String&& name) 
-> decltype(name_ = std::forward<String>(name), void()) {
    name_ = std::forward<String>(name);
}

The benchmark that's used for the presentation is calling set_name repeatedly on an employee in order to show the case where the member string gets to reuse its capacity instead of there being a memory allocation every iteration. The difference between the tall bars and the short bars shown in the benchmarks is the difference between reusing capacity vs. doing an allocation every iteration.

The reason the corrected perfect forwarder is fast with char* is because the instantiation of the template for char* just forwards a char* instead of needing to construct a string param in order to call set_name with an actual string object parameter. The assignment inside the setter is fast because string implements operator=(char*) that does the efficient memcpy into its existing storage and extra allocations are avoided.

So the claim Optimized to steal from rvalues (and more) is because perfect forwarding does nothing but forwarding. Not only does it pass through an rvalue if it gets an rvalue, but it also doesn't convert types, meaning that optimizations the "forwardee" implements such as string's operator=(char*) get exposed as well.

Community
  • 1
  • 1
bames53
  • 86,085
  • 15
  • 179
  • 244
  • I see. Upvote for "Not only does it pass through an rvalue if it gets an rvalue, but it also doesn't unnecessary convert types". – Allanqunzi Aug 26 '15 at 03:18
  • your `set_name()` doesn't return anything, and it has a return type – BЈовић Aug 26 '15 at 07:47
  • 1
    @BЈовић: The return type (after SFINAE) is `decltype(void())` so `void`. – Jarod42 Aug 26 '15 at 08:31
  • @bames53, one more question, what is the purpose of `name_ = std::forward(name)` inside `decltype`, and with the same one inside the function body, which `name_ = std::forward(name)` will get executed first? – Allanqunzi Aug 26 '15 at 14:07
  • 1
    @bames53, I almost understand it now, `name_ = std::forward(name)` inside `decltype` is to [use SFINAE to detect operator support](http://stackoverflow.com/questions/5839357/detect-operator-support-with-decltype-sfinae), but `name_ = std::forward(name)` will get executed twice? one time inside `decltype`, and second time inside the function body? – Allanqunzi Aug 26 '15 at 15:09
  • 1
    @Allanqunzi No, the expression inside the `decltype` is not evaluated – Praetorian Aug 26 '15 at 15:45
  • @Praetorian, thanks, more detailed explanation on this is [here](http://stackoverflow.com/questions/32231075/is-expression-inside-decltype-executed-or-just-being-checked-for-validation) – Allanqunzi Aug 26 '15 at 15:58