constexpr

Consider a simple int Wrapper class with overloaded multiplication operator*= and operator* . For "old-style" operator-overloading, one can define operator* in terms of operator*= , and there are even libraries like Boost.Operators and its modern incarnation df.operators by @DanielFrey that reduce the boilerplate for you. However, for compile-time computations using the new C++11 constexpr , this convenience disappears. A constexpr operator* cannot call operator*= because the latter modifies its (implicit) left argument. Furthermore, there is no overloading on constexpr , so adding an extra

I am very well aware that passing directly a const char* as a template non-type parameter is erroneous, since two identical string literals defined in two different translation units may have different addresses (although most of the time the compilers use the same address). There is a trick one may use, see code below: #include <iostream> template<const char* msg> void display() { std::cout << msg << std::endl; } // need to have external linkage // so that there are no multiple definitions extern const char str1[] = "Test 1"; // (1) // Why constexpr is enough? Does it have external linkage?

Any function that consists of a return statement only could be declared constexpr and thus will allow to be evaluated at compile time if all arguments are constexpr and only constexpr functions are called in its body. Is there any reason not to declare any such function constexpr ? Example: constexpr int sum(int x, int y) { return x + y; } constexpr i = 10; static_assert(sum(i, 13) == 23, "sum correct"); Could anyone provide an example where declaring a function constexpr would do any harm? Some initial thoughts: Even if there should be no good reason for ever declaring a function not

We know that C++ template metaprogramming is Turing complete , but preprocessor metaprogramming is not . C++11 gives us a new form of metaprogramming: computation of constexpr functions. Is this form of computation Turing-complete? I am thinking that since recursion and the conditional operator (?:) are allowed in constexpr functions, it would be, but I would like someone with more expertise to confirm. Richard Smith tl;dr: constexpr in C++11 was not Turing-complete, due to a bug in the specification of the language, but that bug has been addressed in later drafts of the standard, and clang

If I want to use some convenience stuff like make_array I have no chance to declare my array first and later make the definition as done in "earlier" times because the type of my var is not available before definition. So I found this answer: Undefined reference to static constexpr char[] In the following example I wrote this solution which compiles fine with gcc and I am not sure that this is really valid c++ code, because it is more or less a declaration with definition and later a definition without any content. Is this allowed? ( Compiles fine is not a guarantee that the code is valid c++