• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76
• 77
• 78
• 79
• 80
• 81
• 82
• 83
• 84
• 85
• 86
• 87
• 88
• 89
• 90
• 91
• 92
• 93
• 94
• 95
• 96
• 97
• 98
• 99
• 100
• 101
• 102
• 103
• 104
• 105
• 106
• 107
• 108
• 109
• 110
• 111
• 112
• 113
• 114
• 115
• 116
• 117
• 118
• 119
• 120
• 121
• 122
• 123
• 124
• 125
• 126
• 127
• 128
• 129
• 130
• 131
• 132
• 133
• 134
• 135
• 136
• 137
• 138
• 139
• 140
• 141
• 142
• 143
• 144
• 145
• 146
• 147
• 148
• 149
• 150
• 151
• 152
• 153
• 154
• 155
• 156
• 157
• 158
• 159
• 160
• 161
• 162
• 163
• 164
• 165
• 166
• 167
• 168
• 169
• 170
• 171
• 172
• 173
• 174
• 175
• 176
• 177
• 178
• 179
• 180
• 181
• 182
• 183
• 184
• 185
• 186
• 187
• 188
• 189
• 190
• 191
• 192
• 193
• 194
• 195
• 196
• 197
• 198
• 205
• 206
• 219
• 222
• 224
• 225
• 226
• 227
• 228
• 229
• 230

https://www.boost.org/doc/libs/1_65_1/doc/html/tribool.html

http://thbecker.net/articles/rvalue_references/section_01.html

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

rvalue further reading:

https://www.artima.com/cppsource/rvalue.html

Why implicit move must go:

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3153.htm

https://www.justsoftwaresolutions.co.uk/cplusplus/rvalue_references_and_perfect_forwarding.html

• rvalue references
• perfect forwarding

http://thbecker.net/articles/rvalue_references/section_05.html

Things that are declared as rvalue reference can be lvalues or rvalues. The distinguishing criterion is: if it has a name, then it is an lvalue. Otherwise, it is an rvalue.

https://www.geeksforgeeks.org/writing-power-function-for-large-numbers/

https://www.slideshare.net/andreialexandrescu1/three-optimization-tips-for-c-15708507

https://www.facebook.com/notes/facebook-engineering/three-optimization-tips-for-c/10151361643253920/

https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb&disable_polymer=true

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72

If you implement:

void foo(X&);

but not:

void foo(X&&);

then of course the behavior is unchanged: foo can be called on l-values, but not on r-values.

If you implement:

void foo(X const &);

but not:
void foo(X&&);

then again, the behavior is unchanged:
foo can be called on l-values and r-values, but it is not possible to make it distinguish between l-values and r-values. That is possible only by implementing:

void foo(X&&);

as well. Finally, if you implement:

void foo(X&&);

but neither one of

void foo(X&);
and
void foo(X const &);

then, according to the final version of C++11, foo can be called on r-values, but trying to call it on an l-value will trigger a compile error.

https://infogram.com/codingame-2019-developer-survey-which-programming-languages-do-you-like-vs-dislike-1hmr6ggv1lxo6nl

Full: http://publications.codingame.com/codingame-developer-survey-report-2019/cover/?utm_source=cg-blog&utm_medium=post&utm_campaign=developer-survey-2019&utm_content=today-developer

Distinguish between prefix and postfix forms of increment and decrement operators.

https://accu.org/index.php/journals/227

https://isocpp.org/blog/2012/11/universal-references-in-c11-scott-meyers

https://www.boost.org/doc/libs/1_65_1/libs/multi_array/doc/user.html

https://www.boost.org/doc/libs/1_65_1/doc/html/tribool.html

http://www.techiedelight.com/remove-whitespaces-string-cpp/

https://www.youtube.com/watch?v=ZbVCGCy3mGQ

https://dev.krzaq.cc/post/stop-assigning-string-literals-to-char-star-already/

https://www.artima.com/cppsource/rvalue.html

• Introduction
• The rvalue reference
  Move Semantics
• Eliminating spurious copies
• Overloading on lvalue/rvalue
• Moveable but Non-Copyable Types
• Perfect Forwarding

http://thbecker.net/articles/rvalue_references/section_07.html

template<typename T, typename Arg>
shared_ptr factory(Arg const & arg)
{
return shared_ptr(new T(arg));
}

There are two problems with this approach. Firstly, if factory had not one, but several arguments, you would have to provide overloads for all combinations of non-const and const reference for the various arguments. Thus, the solution scales extremely poorly to functions with several arguments.

Secondly, this kind of forwarding is less than perfect because it blocks out move semantics: the argument of the constructor of T in the body of factory is an lvalue. Therefore, move semantics can never happen even if it would without the wrapping function.

It turns out that rvalue references can be used to solve both these problems. They make it possible to achieve truly perfect forwarding without the use of overloads. In order to understand how, we need to look at two more rules for rvalue references.

http://thbecker.net/articles/rvalue_references/section_08.html

Suppose that we call std::move on an lvalue of type X:

X x;
std::move(x);

By the new special template deduction rule, the template argument T will resolve to X&. Therefore, what the compiler ends up instantiating is

typename remove_reference<X&>::type&&
std::move(X& && a) noexcept
{
typedef typename remove_reference<X&>::type&& RvalRef;
return static_cast(a);
}

After evaluating the remove_reference and applying the new reference collapsing rules, this becomes

X&& std::move(X& a) noexcept
{
return static_cast<X&&>(a);
}

That does the job: our lvalue x will bind to the lvalue reference that is the argument type, and the function passes it right through, turning it into an unnamed rvalue reference.

I leave it to you to convince yourself that std::move actually works fine when called on an rvalue. But then you may want to skip that: why would anybody want to call std::move on an rvalue, when its only purpose is to turn things into rvalues? Also, you have probably noticed by now that instead of

std::move(x);
you could just as well write
static_cast<X&&>(x);
However, std::move is strongly preferred because it is more expressive.

https://courses.cs.washington.edu/courses/cse451/06au/slides/os-distsys.ppt

https://akrzemi1.wordpress.com/2018/05/16/rvalues-redefined/

https://msdn.microsoft.com/en-us/library/f90831hc.aspx

http://thbecker.net/articles/rvalue_references/section_06.html

Consider the following function definition:

X foo()
{
X x;
// perhaps do something to x
return x;
}

Now suppose that as before, X is a class for which we have overloaded the copy constructor and copy assignment operator to implement move semantics. If you take the function definition above at face value, you may be tempted to say, wait a minute, there is a value copy happening here from x to the location of foo's return value.

Let me make sure we're using move semantics instead:

X foo()
{
X x;
// perhaps do something to x
return std::move(x); // making it worse!
}

Unfortunately, that would make things worse rather than better. Any modern compiler will apply return value optimization to the original function definition. In other words, rather than constructing an X locally and then copying it out, the compiler would construct the X object directly at the location of foo's return value. Rather obviously, that's even better than move semantics.

So as you can see, in order to really use rvalue references and move semantics in an optimal way, you need to fully understand and take into account today's compilers’ “special effects” such as return value optimization and copy elision. For a detailed discussion see Items 25 and 41 of Scott Meyers' book “Effective Modern C++”. It gets get pretty subtle, but hey, we chose C++ as our language of choice for a reason, right? We made our beds, so now let's lie in them.

https://www.bfilipek.com/2018/05/using-optional.html