clang++

Given the following code: #include <iostream> #include <optional> struct foo { explicit operator std::optional<int>() { return std::optional<int>( 1 ); } explicit operator int() { return 0; } }; int main() { foo my_foo; std::optional<int> my_opt( my_foo ); std::cout << "value: " << my_opt.value() << std::endl; } gcc 7.2.0 writes value: 1 . MSVC 2017 (15.3) and clang 4.0.0 however write value: 0 . Which one is correct according to the C++ standard? Since this is direct-initialization, we enumerate the constructors and just pick the best one. The relevant constructors for std::optional are :

Consider the simple C++11 code: template<int N> struct Foo {}; template <int N> constexpr int size(const Foo<N>&) { return N; } template <int N> void use_size(const Foo<N>& foo) { constexpr int n = size(foo); } int main() { Foo<5> foo; constexpr int x = size(foo); // works with gcc and clang // _but_ use_size(foo); // the same statement in the use_size() // function _only_ works for gcc } I can successfuly compile it with g++ -std=c++11 foo.cpp however if I use clang++, clang++ -std=c++11 foo.cpp I get foo.cpp:15:28: error: constexpr variable 'n' must be initialized by a constant expression

In a piece of code I reviewed lately, which compiled fine with g++-4.6 , I encountered a strange try to create a std::shared_ptr from std::unique_ptr : std::unique_ptr<Foo> foo... std::make_shared<Foo>(std::move(foo)); This seems rather odd to me. This should be std::shared_ptr<Foo>(std::move(foo)); afaik, though I'm not perfectly familiar with moves (and I know std::move is only a cast, nothing get's moved). Checking with different compilers on this SSC(NUC*)E #include <memory> int main() { std::unique_ptr<int> foo(new int); std::make_shared<int>(std::move(foo)); } Results of compilation: g++