My reading of the standard is that std::memcpy is safe whenever the type is trivially copyable. From 9 Classes, we can see that unions are class types and so trivially copyable applies to them. A union is a class defined with the class-key union; it holds only one data member at a time (9.5). A … Read more
A lambda is a functor – just defined with a shorter syntax. The problem is that this syntax is limited. It doesn’t always allow you to solve a problem in the most efficient and flexible way – or at all. Until C++14, the operator() couldn’t even be a template. Furthermore, a lambda has exactly one … Read more
Ok i found out a pretty decent solution: basically i need to unpack one extra lambda case and apply the using clause to the unpacked lambda and the rest, but in this case, since i apparently i cannot make a variadic list of using declarations (at least i don’t know the syntax, if its possible), … Read more
Strictly speaking, the question was about checking the lockedness of std::mutex directly. However, if encapsulating it in a new class is allowed, it’s very easy to do so: class mutex : public std::mutex { public: #ifndef NDEBUG void lock() { std::mutex::lock(); m_holder = std::this_thread::get_id(); } #endif // #ifndef NDEBUG #ifndef NDEBUG void unlock() { m_holder … Read more
You have to join std::threads, just like you have to join pthreads. int main( int argc, char *argv[] ) { std::thread t( doSomeWork ); t.join(); return 0; } UPDATE: This Debian bug report pointed me to the solution: add -pthread to your commandline. This is most probably a workaround until the std::thread code stabilizes and … Read more
Why is this a narrowing conversion? Because the definition includes (with my emphasis): C++11 8.5.4/7 A narrowing conversion is an implicit conversion […] from an integer type […] to a floating-point type, except where the source is a constant expression and the actual value after conversion will fit into the target type and will produce … Read more
As Howard already said in the question, the final draft was completed on March 25, 2011. There will now be some months of editorial changes, voting and ISO red tape before it officially becomes a standard, but on the 25th, the standards committee themselves officially signed off on it. Sources: https://www.ibm.com/developerworks/mydeveloperworks/blogs/5894415f-be62-4bc0-81c5-3956e82276f3/entry/the_c_0x_standard_has_been_approved_to_ship23?lang=en http://herbsutter.com/2011/03/25/we-have-fdis-trip-report-march-2011-c-standards-meeting/ http://twitter.com/#!/sdt_intel/status/51328822066417665 and of … Read more
No, you cannot put it into decltype because A lambda-expression shall not appear in an unevaluated operand You can do the following though auto n = [](int l, int r) { return l > r; }; std::set<int, decltype(n)> s(n); But that is really ugly. Note that each lambda expression creates a new unique type. If … Read more
Others have already answered that it can be done via std::tuple. If you want to access the Nth type of a parameter pack, you may find the following metafunction handy: template<int N, typename… Ts> using NthTypeOf = typename std::tuple_element<N, std::tuple<Ts…>>::type; Usage: using ThirdType = NthTypeOf<2, Ts…>;
rval is not a Rvalue. It is an Lvalue inside the body of the move constructor. That’s why we have to explicitly invoke std::move. Refer this. The important note is Note above that the argument x is treated as an lvalue internal to the move functions, even though it is declared as an rvalue reference … Read more