Here’s why copy elision doesn’t make sense for parameters. It’s really about the implementation of the concept at the compiler level. Copy elision works by essentially constructing the return value in-place. The value isn’t copied out; it’s created directly in its intended destination. It’s the caller who provides the space for the intended output, and … Read more
For the specific example you’ve provided, capturing by this is what you want. Conceptually, capturing this by reference doesn’t make a whole lot of sense, since you can’t change the value of this, you can only use it as a pointer to access members of the class or to get the address of the class … Read more
You’re not storing a lambda, you’re storing a reference to a std::function. In fact, that std::function is being created as a temporary when the lambda is implicitly converted to std::function. That std::function temporary dies after the line where the constructor is invoked. LambdaStore(const std::function<void(float)>& _fn) // _fn refers to a temporary : fn(_fn) { fn(11.1f); … Read more
With add_rvalue_reference: declval<Foo>() is of type Foo&&. declval<Foo&>() is of type Foo& (reference collapsing: “Foo& &&” collapses to Foo&). declval<Foo&&>() is of type Foo&& (reference collapsing: “Foo&& &&” collapses to Foo&&). With add_lvalue_reference: declval<Foo>() would be of type Foo&. declval<Foo&>() would be of type Foo& (reference collapsing: “Foo& &” collapses to Foo&). declval<Foo&&>() would be … Read more
Do I have to use atomic for “exit” bool variable? Yes. Either use atomic<bool>, or use manual synchronization through (for instance) an std::mutex. Your program currently contains a data race, with one thread potentially reading a variable while another thread is writing it. This is Undefined Behavior. Per Paragraph 1.10/21 of the C++11 Standard: The … Read more
Completely rewriting this answer because I totally misunderstood. This is a tricky thing to get right! The usual implementation of std::weak_ptr and std::shared_ptr that is consistent with the standard is to have two heap objects: the managed object, and a control block. Each shared pointer that refers to the same object contains a pointer to … Read more
Is bar an rvalue or an lvalue? The question answers itself. Whatever has a name is an lvalue(1). So bar is an lvalue. Its type is “rvalue reference to string“, but it’s an lvalue of that type. If you want to treat it as an rvalue, you need to apply std::move() to it. If you … Read more
You have to write your own, but it’s simple: template<typename> struct is_std_array : std::false_type {}; template<typename T, std::size_t N> struct is_std_array<std::array<T,N>> : std::true_type {};
I think the lvalue-to-rvalue conversion is more than just use an lvalue where an rvalue is required. It can create a copy of a class, and always yields a value, not an object. I’m using n3485 for “C++11” and n1256 for “C99”. Objects and values The most concise description is in C99/3.14: object region of … Read more
Just above that example, it says if e is an unparenthesized id-expression or a class member access (5.2.5), decltype(e) is the type of the entity named by e. if e is an lvalue, decltype(e) is T&, where T is the type of e; I think decltype(a->x) is an example of the “class member access” and … Read more