c++17

Consider the following header and assume it is used in several TUs: static int x = 0; struct A { A() { ++x; printf("%d\n", x); } }; As this question explains, this is an ODR violation and, therefore, UB. Now, there is no ODR violation if our inline function refers to a non- volatile const object and we do not odr-use it within that function (plus the other provisions), so this still works fine in a header: constexpr int x = 1; struct A { A() { printf("%d\n", x); } }; But if we do happen to odr-use it, we are back at square one with UB: constexpr int x = 1; struct A { A() { printf("%p\n", &x);

There is a study group in the C++ standardization committee to provide compile-time reflection in C++1z or after. I would like to know what is exactly the purpose and how powerful the expected tools will be? For example will it be possible to name functions or classes using these tools? struct A {int f() {return 42;}}; struct B {int (std::reflect<A>::member<0>::declname)() {return 43;}}; // equivalent to struct B {int f() {return 43;}}; If it would not be as powerful as this, what the typical use cases will be? Reflection use cases are outlined in N3814: http://www.open-std.org/jtc1/sc22/wg21

I want to understand which version of clang Apple installed in my macbook, to see with c++11 and/or c++14 features are available. I typed this command: clang --version //----response Apple LLVM version 7.0.0 (clang-700.1.76) Target: x86_64-apple-darwin15.0.0 Thread model: posix But I am not able to understand what (clang-700.1.76) mean. How can I convert this code to a clang version? This is the site where you could check c++ features available in clang version http://clang.llvm.org/cxx_status.html Daniel Frey The (Apple) version number of the compiler is mostly useless, since you also need to

Is the compiler allowed to optimize this (according to the C++17 standard): int fn() { volatile int x = 0; return x; } to this? int fn() { return 0; } If yes, why? If not, why not? Here's some thinking about this subject: current compilers compile fn() as a local variable put on the stack, then return it. For example, on x86-64, gcc creates this: mov DWORD PTR [rsp-0x4],0x0 // this is x mov eax,DWORD PTR [rsp-0x4] // eax is the return register ret Now, as far as I know the standard doesn't say that a local volatile variable should be put on the stack. So, this version would be equally good:

This answer describes how to stream a standalone std::variant . However, it doesn't seem to work when std::variant is stored in a std::unordered_map . The following example : #include <iostream> #include <string> #include <variant> #include <complex> #include <unordered_map> // https://stackoverflow.com/a/46893057/8414561 template<typename... Ts> std::ostream& operator<<(std::ostream& os, const std::variant<Ts...>& v) { std::visit([&os](auto&& arg) { os << arg; }, v); return os; } int main() { using namespace std::complex_literals; std::unordered_map<int, std::variant<int, std::string, double,

I found the original proposal for *C++ structured bindings here . It proposes a way to easily bind multiple return values, i.e.: auto {a, b} = minmax(data); But now I see that everyone points to the C++17/C++1z proposal syntax of auto [a, b] = minmax(data); Now that I learned "lists are written { like, this }" there comes a new list-syntax? Why? What is the problem with curly braces here? This is still under debate. It's difficult to be certain which syntax will be least confusing given how many uses there are for [] and {} already. There's also the risk that "least confusing" and "easiest to

constexpr functions are not supposed to contain: A definition of a variable of non-literal type But in this answer a lambda is defined in one: https://stackoverflow.com/a/41616651/2642059 template <typename T> constexpr auto make_div(const T quot, const T rem) { return [&]() { decltype(std::div(quot, rem)) result; result.quot = quot; result.rem = rem; return result; }(); } and in my comment I define a div_t in one: How can I Initialize a div_t Object? template <typename T> constexpr decltype(div(T{}, T{})) make_div(const T quot, const T rem) { decltype(div(T{}, T{})) x{}; x.quot = quot; x.rem