c++17

Consider this example which declares a variable as constexpr, captures it by copy in a lambda, and declares another constexpr variable which is the result of a constexpr function unwrapping a non-type template parameter from the original variable. #include <utility> template<int I> constexpr auto unwrap(std::integral_constant<int, I>) { return I; } int main() { constexpr auto i = std::integral_constant<int, 42>{}; constexpr auto l = [i]() { constexpr int x = unwrap(i); }; } Clang (trunk) accepts this code. ( wandbox ) GCC (trunk) fails with the following error message ( wandbox ): lambda

This question already has an answer here: How to avoid C++ anonymous objects 6 answers For many RAII "guard" classes, being instantiated as anonymous variables does not make sense at all: { std::lock_guard<std::mutex>{some_mutex}; // Does not protect the scope! // The unnamed instance is immediately destroyed. } { scope_guard{[]{ cleanup(); }}; // `cleanup()` is executed immediately! // The unnamed instance is immediately destroyed. } From this article : Anonymous variables in C++ have “expression scope”, meaning they are destroyed at the end of the expression in which they are created. Is

In reading this summary of the c++17 final features I was a bit surprised by the section on structured bindings (emphasis mine): structured bindings Until now, there was a known trick to abuse std::tie to assign a tuple or pair to different variables directly, instead of having to deal with the result type manually. This was a hack , and also the variables had to exist, now you can declare the variables and initialize them in one line: auto [a , b , c] = getvalues(); The braces are needed, getvalues returns a tuple. std::pair is not mentioned in the proposal, so its unclear if this works with

I've heard somewhere, that using new C++1z syntax, it is really easy to check if a type is passed in variadic template parameter pack - apparently you can do this with code that is near one-line long. Is this true? What are those relevant features? (I tried looking through fold expressions but I can't see how to use them in that problem...) Here's how I solved the problem in C++11 for reference: #include <type_traits> template<typename T, typename ...Ts> struct contains; template<typename T> struct contains<T> { static constexpr bool value = false; }; template<typename T1, typename T2,

I'm looking at std:variant/std::visit doc here: http://en.cppreference.com/w/cpp/utility/variant/visit and also googled a lot trying to understand the magic behind std::visit and std::variant . So my question is the following. In the provided example, both in the polymorphic lambda and the "overloaded" there is some "magic" happening that makes it possible to extract the correct type from std::variant . So looking at this: for (auto& v: vec) { std::visit(overloaded { [](auto arg) { std::cout << arg << ' '; }, [](double arg) { std::cout << std::fixed << arg << ' '; }, [](const std::string& arg)

There is a study group on ranges in the C++ committee: but I have not followed the history of this study group and I am not sure of what kind of delivery is expected for C++1z (furthermore I do not use boost.range so I do not have a clear view of existing practices). Will we have: ranges as a pair of first/last iterators? union and other set operations on ranges(for example [v.begin()+5, v.begin()+7[ U [v.begin()+10, v.begin()+15[ U [v.begin()+21, v.begin()+42[ ), namely: union, intersection, disjoint union, complement? iterator filters (in order to execute a for_each where a condition is

Can I initialize an array using the std::initializer_list object instead of brace-enclosed initializer? As known, we can do this: http://en.cppreference.com/w/cpp/language/aggregate_initialization unsigned char b[5]{"abc"}; // equivalent to unsigned char b[5] = {'a', 'b', 'c', '\0', '\0'}; int ar[] = {1,2,3}; std::array<int, 3> std_ar2{ {1,2,3} }; // std::array is an aggregate std::array<int, 3> std_ar1 = {1, 2, 3}; But I can't initialize an array by std::initializer_list il; : http://ideone.com/f6aflX #include <iostream> #include <initializer_list> #include <array> int main() { int arr1[] = {