Structured bindings seem like one of those things that was just forgotten in previous standards, I'm glad it's here now. The syntax is a matter of taste, I guess.
I'm also quite excited about variants, they probably won't be used much but sometimes they're just what one needs. Having them without requiring boost is nice.
if constexpr (false) { static_assert(false); }
if constexpr (foo) {
static_assert(!foo || /* assertion */);
} else {
static_assert(foo || /* assertion */);
}
template<typename T>
void func(T x) {
if constexpr ( std::is_same< T, ClassWithMemberF>::value ) {
x.f();
}
}
if (false constexpr) { random gibberish }
if constexpr ( COND) { CODE };
You can still do this sort of stuff with template overloads, but it's much more cumbersome.
if constexpr (condition) {
print("yes");
}
if constexpr (condition) {
print({
}
[1] http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p029...
template<class T>
class foo;
template<>
class foo<int> {
static_assert(false, "bad");
};
template<>
class foo<float> {};
template<class T>
foo<T> foo_fn(T v) {
if constexpr (std::is_same<T, int>::value) {
return foo<int>{};
}
else if constexpr (std::is_same<T, float>::value) {
return foo<float>{};
}
else {
return foo<T>{};
}
}
foo_fn(1.0); // <-- does not trigger static assert
foo_fn(1); // <-- triggers static assert
template<>
class foo<int> {
static_assert(false, "bad");
};
(Of course since this is a full specialization, there are no dependent names.)
See C++14 Standard §14.6.2 (Dependent Names) or http://en.cppreference.com/w/cpp/language/dependent_name (not sure how accurate that page is, though).
P.S: It might compile with Microsoft's Visual Studio, but only because that compiler doesn't implement two-phase name lookup, effectively turning every name into a dependent name.
Also this dependent name behavior of static_assert seems to be a precedent for always checking static_assert in constexpr if.