c++17

I'd like to replace boost::variant s with C++17 std::variant and get rid of boost::recursive_wrapper , to remove dependency on boost completely in following code. How may I do that? #include <boost/variant.hpp> #include <type_traits> using v = boost::variant<int, boost::recursive_wrapper<struct s> >; struct s { v val; }; template<template <typename...> class R, typename T, typename ... Ts> auto reduce(T t, Ts ... /*ts*/) { return R<T, Ts...>{t}; } template<typename T, typename F> T adapt(F f) { static_assert(std::is_convertible_v<F, T>, ""); return f; } int main() { int val1 = 42; s val2; auto

C++ (and C) strict aliasing rules include that a char* and unsigned char* may alias any other pointer. AFAIK there is no analogous rule for uint8_t* . Thus my question: What are the aliasing rules for a std::byte pointer? The C++ reference currently just specifies : Like the character types (char, unsigned char, signed char) it can be used to access raw memory occupied by other objects (object representation), but unlike those types, it is not a character type and is not an arithmetic type. DeiDei From the current Standard draft ([basic.types]/2): For any object (other than a base-class

UPDATE1: C++17 added type deduction for constructors - which does not imply that the free function is an inferior solution. UPDATE2: C++17 added guaranteed copy elision (the copy does not even take place conceptually). So with C++17 my code actually works and with optimal performance. But Martinho's code using brace initialisation for the return value is still the cleaner solution I believe. But checkout this answer from Barry and the comment from T.C. OLD POST: Type deduction does not work for constructors (at least until and including C++11). The common solution is to rely on RVO (Return

Update: conditional explicit has made it into the C++20 draft. more on cppreference The cppreference std::tuple constructor page has a bunch of C++17 notes saying things like: This constructor is explicit if and only if std::is_convertible<const Ti&, Ti>::value is false for at least one i How can one write a constructor that is conditionally explicit? The first possibility that came to mind was explicit(true) but that's not legal syntax. An attempt with enable_if was unsuccessful: // constructor is explicit if T is not integral struct S { template <typename T, typename = typename std::enable

What exactly is the point of the construct std::observer_ptr in the library fundamentals technical specification V2? It seems to me that all it does is wrap a bare T* , which seems like a superfluous step if it adds no dynamic memory safety. In all of my code I use std::unique_ptr where I need to take explicit ownership of an object and std::shared_ptr where I can share ownership of an object. This works very well and prevents accidental dereferencing of an already destroyed object. std::observer_ptr makes no guarantee about the lifetime of the object observed, of course. If it were to be