clang++

I want to experiment with migrating a project from gcc to clang++. I admit ignorance on my part, I'm not sure why the following bit of code template <typename T> constexpr T pi{std::acos(T(-1.0))}; compiles silently with g++ but clang++ produces the error trig.hpp:3:13: error: constexpr variable 'pi<float>' must be initialized by a constant expression constexpr T pi{std::acos(T(-1.0))}; and I was hoping someone who knows more about it than I do could enlighten me. NB: Tried with -std=C++14 and C++1y. Fails under clang version 3.6.2 (tags/RELEASE_362/final). Works with g++ (GCC) 5.2.0. Shafik

I am uncertain if it is a bug in Clang 3.2 or a violation of C++03, but it appears that explicit instantiation of templated constructors for template classes fails, but explicit instantiation of templated member functions of template classes succeeds. For instance, the following compiles without a problem with both clang++ and g++: template<typename T> class Foo { public: template<typename S> void Bar( const Foo<S>& foo ) { } }; template class Foo<int>; template class Foo<float>; template void Foo<int>::Bar( const Foo<int>& foo ); template void Foo<int>::Bar( const Foo<float>& foo ); template

Using Clang 3.5, 3.6, or 3.7, with the flag std=c++1y the following code does not compile : #include <iostream> auto foo(auto bar) { return bar; } int main() { std::cout << foo(5.0f) << std::endl; } The error given is : error: 'auto' not allowed in function prototype I do not have errors using g++ 4.9. Is this error produced because Clang has not yet implemented this functionnality yet or is it because I am not allowed to do that and GCC somehow permits it ? As we see from the ISO C++ discussion mailing: decltype(auto) parameters vs. perfect forwarding auto parameters of non-lambdas is part of

class AAA { public: AAA() {} AAA(const AAA&) {} }; class BBB { public: BBB() {} operator AAA() { AAA a; return a; } }; int main() { BBB b; AAA a = {b}; } The above code compiles on g++ and vc++, but not clang++. The traditional syntax AAA a = b; compiles ok on all three. class AAA {}; class BBB { public: BBB() {} operator AAA() { AAA a; return a; } }; int main() { BBB b; AAA a = {b}; } The above code doesn't compile on any of g++, vc++, clang++. The only difference against the first code snippet is that I removed the two user-provided constructors of AAA. Again, the traditional syntax AAA a =

Consider the following code: class A { public: int i; A() {} }; class B { public: A a; int i; }; int main() { B* p = new B {}; std::cout << p->i << " " << p->a.i << "\n"; } Compiled with -std=c++11 in clang++, p->i turns out to be zero, but p->a.i doesn't. Shouldn't the whole object be zeroed as long as its class doesn't have user-provided constructor? EDIT: Since there are some extensive discussion in the comments, I think it's better to add some excerpt from the standard here: To value-initialize an object of type T means: if T is a (possibly cv-qualified) class type (Clause 9) with a user

There's something quite non-obvious going on in this code: float a = 1.; const float & x = true ? a : 2.; // Note: `2.` is a double a = 4.; std::cout << a << ", " << x; both clang and gcc output: 4, 1 One would naively expect the same value printed twice but this isn't the case. The issue here has nothing to do with the reference. There are some interesting rules dictating the type of ? : . If the two arguments are of different type and can be casted, they will by using a temporary. The reference will point to the temporary of ? : . The example above compiles fine and it might or might not