constexpr

As far as I can see, a very common situation is something like template<int i> class Class { public: static constexpr int I = i; static constexpr int J = constexprFunction(i); // further Class implementation }; Almost as common I see the mistake (in fact most of my questions here are because I forgot it and did not know, what the proper question had been) to forget the additional definition if the member are odr-used: template<int i> constexpr int Class<i>::I; template<int i> constexpr int Class<i>::J; Now I read cppreference: Definitions and ODR and cppreference: static members , which state,

If I want to do something like iterate over a tuple, I have to resort to crazy template metaprogramming and template helper specializations. For example, the following program won't work: #include <iostream> #include <tuple> #include <utility> constexpr auto multiple_return_values() { return std::make_tuple(3, 3.14, "pi"); } template <typename T> constexpr void foo(T t) { for (auto i = 0u; i < std::tuple_size<T>::value; ++i) { std::get<i>(t); } } int main() { constexpr auto ret = multiple_return_values(); foo(ret); } Because i can't be const or we wouldn't be able to implement it. But for

C++1z will introduce "constexpr if" - an if that will have one of branches removed, based on the condition. Seems reasonable and useful. However, is it not possible to do without constexpr keyword? I think that during compilation, compiler should know wheter condition is known during compilation time or not. If it is, even the most basic optimization level should remove unnecessary branch. For example (see in godbolt: https://godbolt.org/g/IpY5y5 ): int test() { const bool condition = true; if (condition) { return 0; } else { // optimized out even without "constexpr if" return 1; } } Godbolt

I would like a class C to have a static constexpr member of type C. Is this possible in C++11? Attempt 1: struct Foo { constexpr Foo() {} static constexpr Foo f = Foo(); }; constexpr Foo Foo::f; g++ 4.7.0 says: 'invalid use of incomplete type' referring to the Foo() call. Attempt 2: struct Foo { constexpr Foo() {} static constexpr Foo f; }; constexpr Foo Foo::f = Foo(); Now the problem is the lack of an initializer for the constexpr member f inside the class definition. Attempt 3: struct Foo { constexpr Foo() {} static const Foo f; }; constexpr Foo Foo::f = Foo(); Now g++ complains about a

Using C++11, Ubuntu 14.04, GCC default toolchain . This code fails: constexpr std::string constString = "constString"; error: the type ‘const string {aka const std::basic_string}’ of constexpr variable ‘constString’ is not literal... because... ‘std::basic_string’ has a non-trivial destructor Is it possible to use std::string in a constexpr ? (apparently not...) If so, how? Is there an alternative way to use a character string in a constexpr ? tenfour No, and your compiler already gave you a comprehensive explanation. But you could do this: constexpr char constString[] = "constString"; At

How come that the following works on gcc but doesn't on clang , ( see it live ): constexpr int giveMeValue() { return 42; } struct TryMe { static constexpr int arr[1] = { giveMeValue() }; }; int main() { int val = TryMe::arr[0]; return val; } I get an unresolved external symbol with clang. Is TryMe::arr[0] an object? If it is, is it odr-used? TryMe::arr is odr-used but you don't provide a definition ( see it live ): constexpr int TryMe::arr[1]; Why is the result inconsistent between gcc and clang ? This is because odr violations do not require a disagnostic, from both the C++11 and C++14 draft