c++17

I am able to update gcc on Linux to get -std=c++17 but cannot do the same on Mac. Is there a version of Clang I can update to or some other alternative to get C++17 on my Mac? Please help. Thanks. On my 10.11 El Capitan, Xcode 7.3.1, clang has been updated to: Apple LLVM version 7.3.0 (clang-703.0.31) which is almost equivalent to llvm version 3.8. clang++ hasn't -std=c++17 option, but -std=c++1z , working well at present, though only supporting some features of C++1z. For gcc, you can install a very new one by: brew install gcc --HEAD which will install gcc-6.1 now, (2016.8). This gcc has

This question already has an answer here: GNU GCC (g++): Why does it generate multiple dtors? 2 answers And objdump of my .o file reveals that I have two different destructors for the same class. Why? Disassembly of section .text._ZN1AD0Ev: 0000000000000000 <_ZN1AD0Ev>: 0: 53 push %rbx 1: be 00 00 00 00 mov $0x0,%esi 6: 48 89 fb mov %rdi,%rbx 9: 48 c7 07 00 00 00 00 movq $0x0,(%rdi) 10: ba 2c 00 00 00 mov $0x2c,%edx 15: bf 00 00 00 00 mov $0x0,%edi 1a: e8 00 00 00 00 callq 1f <_ZN1AD0Ev+0x1f> 1f: 48 89 df mov %rbx,%rdi 22: be 08 00 00 00 mov $0x8,%esi 27: 5b pop %rbx 28: e9 00 00 00 00 jmpq 2d

I read this answer about undefined behaviour, where I saw following statement: ++++++i; // UB, parsed as (++(++(++i))) I don't think it is undefined behaviour. I have a doubt, Is it really UB in C++? If yes, then How? Also, I made program and compiled using g++ prog.cpp -Wall -Wextra -std=gnu++1z -pedantic command, it's working fine without any warning. It's give an expected output. #include <iostream> using namespace std; int main() { int i = 0; cout<<++++++i<<endl; } In C++03 it is undefined behavior. In C++11 it is not. There is no sequence point between the various pre-increments. If i was

I discovered that gcc and clang allow to use decltype(auto) in non-type template parameter type clause. E.g.: template <decltype(auto)> struct X {}; int foo ; int main() { X<(foo)> x; static_cast<void>(x); } [live demo gcc] [live demo clang] Is it standard compliant feature or is it some gnu extension? This is standard. First, for a non-type template parameter: [temp.param/4] A non-type template-parameter shall have one of the following (optionally cv-qualified) types: ... a type that contains a placeholder type . Where placeholder types have the following specified: [dcl.spec.auto/1] The auto

Consider the following scenario: std::array<int, 8> a; auto p = reinterpret_cast<int(*)[8]>(a.data()); (*p)[0] = 42; Is this undefined behavior ? I think it is. a.data() returns a int* , which is not the same as int(*)[8] The type aliasing rules on cppreference seem to suggest that the reinterpret_cast is not valid As a programmer, I know that the memory location pointed by a.data() is an array of 8 int objects Is there any rule I am missing that makes this reinterpret_cast valid? An array object and its first element are not pointer-interconvertible * , so the result of the reinterpret_cast

Why does std::any_cast throw a std::bad_any_cast exception when an implicit conversion from the actual stored type to the requested type would be possible? For example: std::any a = 10; // holds an int now auto b = std::any_cast<long>(a); // throws bad_any_cast exception Why is this not allowed and is there a workaround to allow an implicit conversion (in case the exact type that std::any holds is unknown)? std::any_cast is specified in terms of typeid . To quote cppreference on this: Throws std::bad_any_cast if the typeid of the requested ValueType does not match that of the contents of