The reason we don’t have polymorphic lambdas is explained pretty well in this posting. It has to do with the concepts feature that was pulled from C++11: essentially, polymorphic lambdas are ordinary, unconstrained function templates and we didn’t know how to typecheck a concept-constrained template that used an unconstrained template. However, solving that problem turns … Read more
Why does this happen? Because the function-call operator of a lambda, Unless the keyword mutable was used in the lambda-expression, the function-call operator is const-qualified and the objects that were captured by copy are non-modifiable from inside this operator(). and Is it possible to capture the std::unique_ptr in another way which allows to call reset() … Read more
std::map::insert has an overload for R-values: std::pair<iterator,bool> insert(value_type&&); Any expression which binds to this overload will invoke R-value constructors. Since std::map<K,V>::value_type is std::pair<const key_type, mapped_type>, and std::pair has a constructor that takes R-values: template<class U1, class U2> pair(U1&& x, U2&& y); then you are guaranteed that R-value constructors for key_type and mapped_type will be invoked, … Read more
Yes, of course: typedef decltype(&A::foo) PFN_FOO; You can also define type alias via using keyword (Thanks to Matthieu M.): using PFN_FOO = decltype(&A::foo);
You don’t need any virtuals or templates here. Just add a SomeInfo* pointer and its length to Base, and provide a protected constructor to initialize them (and since there’s no default constructor, it won’t be possible to forget to initialize them). The constructor being protected is not a hard requirement, but since Base is not … Read more
Here’s a version that doesn’t use an index sequence: template <size_t I> struct visit_impl { template <typename T, typename F> static void visit(T& tup, size_t idx, F fun) { if (idx == I – 1) fun(std::get<I – 1>(tup)); else visit_impl<I – 1>::visit(tup, idx, fun); } }; template <> struct visit_impl<0> { template <typename T, typename … Read more
queue<int> q({1, 2, 3});
It’s a deliberate design choice/trade-off. First, it’s not necessarily possible to find out whether the functionoid passed to async takes its arguments by reference or not. (If it’s not a simple function but a function object, it could have an overloaded function call operator, for example.) So async cannot say, “Hey, let me just check … Read more
I know that the atomic types do not have copy constructors, and I assume that explains why this code does not work. Yes, the error says that quite clearly. Does anybody know a way to actually get this code to work? Instead of copy-initialising from a temporary, which requires an accessible copy constructor: std::atomic<int> order::c … Read more
Compile time. In C++, runtime type information is stripped during compilation(without RTTI or virtual inheritance). It is not possible, in fact, to inspect the primitive type at runtime.