No. “Polymorphic lambdas” is what this feature was referred to during the C++ committee discussions, and it was not standardized. The parameter types of a lambda must be specified. You can use decltype though: std::for_each(ints.begin(), ints.end(), [](decltype(*ints.begin())& val){ val = 7; });
An implementation must allow a pointer to one past the end to exist. How it does this is its business. On many machines, you can safely put any value into a pointer, without risk (unless you dereference it); on such systems, the one past the end pointer may point to unmapped memory—I’ve actually encountered a … Read more
Indeed you are doing it wrong. If you have simple inheritance, just inherit from enable_shared_from this in the base class, and derived class get it for free. (of course you’ll need to downcast the result) If you have multiple inheritance (like it seems), you must use the trick described here and also here : /* … Read more
The claim that unique_ptr performs as well as a raw pointer after optimization mostly applies only to the basic operations on a single pointer, such as creation, dereferencing, assignment of a single pointer and deletion. Those operations are defined simply enough that an optimizing compiler can usually make the required transformations such that the resulting … Read more
If you pass an rvalue reference to an object of type X to a template function that takes type T&& as its parameter, template argument deduction deduces T to be X. Therefore, the parameter has type X&&. If the function argument is an lvalue or const lvalue, the compiler deduces its type to be an … Read more
No, data members cannot be captured by value. A lambda can capture only two kinds of things: the this pointer, and nonstatic local variables (that is, variables with automatic storage duration). As has been noted by ildjarn in the comments, you can create a local variable with a copy of the value of the data … Read more
You should specify the lambda return type to be int&. If you leave the return type off [and the lambda is of form return expression; it will automatically deduce the return type. #include <iostream> class Item { public: int& f(){return data_;} private: int data_ = 0; }; int main() { Item item; auto lambda = … Read more
There is no timeout for std::thread::join(). However you can view std::thread::join() as merely a convenience function. Using condition_variables you can create very rich communication and cooperation between your threads, including timed waits. For example: #include <chrono> #include <thread> #include <iostream> int thread_count = 0; bool time_to_quit = false; std::mutex m; std::condition_variable cv; void f(int id) … Read more
Don’t use raw pointers, use std::unique_ptr like this: std::vector<std::unique_ptr<Fruit>> m_fruits; And as you can’t copy construct a std::unique_ptr you must use emplace_back (although you can use push_back with std::move). m_fruits.emplace_back(new Pear()); m_fruits.emplace_back(new Tomato()); Edit: As it appears that using std::vector<std::unique_ptr<T>>::emplace_back and new can leak if the std::vector needs and fails to reallocate memory, my recommended … Read more
If you know that the key is in the map, you can utilize operator[] which returns a reference to the mapped value. Hence it will be map[key] = new_value. Be careful, however, as this will insert a (key, new_value) if the key does not already exist in the map. You can also use find which … Read more