c++17

std::optional is in C++ 17, where it was std::experimental::optional before. I tried compiling a file which included <optional> , with the command: g++ -std=c++17 <filename>.cpp (in the Bash terminal). I get the following error: <filename>.cpp:5:20 fatal error: optional: No such file or directory #include <optional> ^ compilation terminated But I can #include <experimental/optional> just fine. Am I missing some header files? How can I include the optional header? I also can't include <any> , <string_view> or <variant> , getting the same error. You can't. GCC 6.2's support for C++17 is

std::optional<int&> xx; just doesn't compile for the latest gcc-7.0.0 snapshot. Does the C++17 standard include std::optional for references? And why if it doesn't? (The implementation with pointers in a dedicated specialization whould cause no problems i guess.) Nicol Bolas Because optional , as standardized in C++17, does not permit reference types. This was excluded by design. There are two reasons for this. The first is that, structurally speaking, an optional<T&> is equivalent to a T* . They may have different interfaces, but they do the same thing. The second thing is that there was

Yakk - Adam Nevraumont said : Non-type template parameters of type void* are not allowed in at least some versions of the standard. Is this true? If it is true, in which versions of the standard are non-type template parameters of type void* not allowed? (Note: as noted in a comment to answer another comment , this is about non-type template parameters , not template type arguments , which can be any valid type-id per [temp.arg.type] , including void* . TL;DR Template parameters of type void* are valid since C++20. They are invalid prior to C++20. C++20 C++20 relaxed the restrictions on the

Consider the following: struct X { X() {} X(X&&) { puts("move"); } }; X x = X(); In C++14, the move could be elided despite the fact that the move constructor has side effects thanks to [class.copy]/31, This elision of copy/move operations ... is permitted in the following circumstances ... when a temporary class object that has not been bound to a reference (12.2) would be copied/moved to a class object with the same cv-unqualified type In C++17 this bullet was removed. Instead the move is guaranteed to be elided thanks to [dcl.init]/17.6.1: If the initializer expression is a prvalue and the

I'd like to use std::is_invocable, however we are using c++11 standard, while is_invocable is available only from c++17. Is there any way to emulate the functionality using c++11? Thank you You can try this implementation:) Taken from boost C++ libraries. I've tested it with VS2017 with standard C++14. template <typename F, typename... Args> struct is_invocable : std::is_constructible< std::function<void(Args ...)>, std::reference_wrapper<typename std::remove_reference<F>::type> > { }; template <typename R, typename F, typename... Args> struct is_invocable_r : std::is_constructible< std:

The following code: variant<string> x = "abc"; cout << get<string>(x) << "\n"; works fine under g++ (version 7.2). However, when compiled under clang++ (version 5.0) using libstdc++, I get the following error in the get method: /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/7.2.0/../../../../include/c++/7.2.0/variant:238:46: fatal error: cannot cast 'std::variant<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >' to its private base class 'std::__detail::__variant::_Variant_storage<false, std:: __cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>