clang++

Clang 3.9 extremely reuses memory used by temporaries. This code is UB (simplified code): template <class T> class my_optional { public: bool has{ false }; T value; const T& get_or_default(const T& def) { return has ? value : def; } }; void use(const std::string& s) { // ... } int main() { my_optional<std::string> m; // ... const std::string& s = m.get_or_default("default value"); use(s); // s is dangling if default returned } We have tons of code something like above ( my_optional is just a simple example to illustrate it). Because of UB all clang compiler since 3.9 starts to reuse this

I have the following C++11 code. #include <type_traits> using IntType = unsigned long long; template <IntType N> struct Int {}; template <class T> struct is_int : std::false_type {}; template <long long N> struct is_int<Int<N>> : std::true_type {}; int main() { static_assert (is_int<Int<0>>::value, ""); return 0; } Clang++ 3.3 compiles the code but on g++ 4.8.2 static assertion fails $ g++ -std=c++11 main.cpp main.cpp: In function ‘int main()’: main.cpp:15:5: error: static assertion failed: static_assert (is_int<Int<0>>::value, ""); ^ $ The problem is caused by different integral template

This question already has an answer here: Do I really need to implement user-provided constructor for const objects? 4 answers Consider following example: #include <iostream> #include <type_traits> struct A { //A() = default; // does neither compile with, nor without this line //A(){}; // does compile with this line int someVal{ 123 }; void foobar( int ) { }; }; int main() { const A a; std::cout << "isPOD = " << std::is_pod<A>::value << std::endl; std::cout << "a.someVal = " <<a.someVal << std::endl; } See Live example This does compile with g++ but does not compile with clang++, tried with

Somebody had asked the other day why something compiles with clang, but not with gcc. I intuitively understood what was happening and was able to help the person, but it got me wondering -- according to the standard, which compiler was correct? Here is a boiled down version of the code: #include <iostream> #include <string> class foo { public: foo(const std::string& x): name(x) { } foo& operator()(const std::string& x) { std::cout << name << ": " << x << std::endl; return (*this); } std::string name; }; int main() { std::string x = "foo"; foo(x)("bar")("baz"); return 0; } This compiles fine

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>

There is different behaviour in clang++ and g++ for the next program: #include <type_traits> #include <utility> template< std::size_t index, typename type > struct ref { type & value; }; template< std::size_t index, typename type > type && get(ref< index, type > const & r) { return std::forward< type >(r.value); } template< typename F, typename ...types, std::size_t ...indices > decltype(auto) apply_inverse(F & f, types &... values, std::index_sequence< indices... >) { struct : ref< indices, types >... {} refs{{values}...}; constexpr std::size_t top = sizeof...(indices) - 1; return std: