constexpr

I'm trying to fill a 2D array on compile time with a given function. Here is my code: template<int H, int W> struct Table { int data[H][W]; //std::array<std::array<int, H>, W> data; // This does not work constexpr Table() : data{} { for (int i = 0; i < H; ++i) for (int j = 0; j < W; ++j) data[i][j] = i * 10 + j; // This does not work with std::array } }; constexpr Table<3, 5> table; // I have table.data properly populated at compile time It works just fine, table.data is properly populated at compile time. However, if I change plain 2D array int[H][W] with std::array<std::array<int, H>, W> , I

I'm having trouble with the following code: template<typename T> constexpr int get(T vec) { return vec.get(); } struct coord { constexpr int get() const { return x; } int x; }; struct foo { struct coord2 { constexpr int get() const { return x; } int x; }; constexpr static coord f = { 5 }; constexpr static int g = get(f); // works constexpr static coord2 h = { 5 }; constexpr static int i = get(h); // doesn't work }; constexpr coord foo::f; constexpr foo::coord2 foo::h; int main(){} Essentially, get(f) is considered a constant expression, but get(h) is not. The only thing changed is that one

Just because a function (or constructor)... is declared constexpr and the function definition meets the constexpr requirements ...doesn't mean that the compiler will evaluate the constexpr function during translation. I've been looking through the C++11 FDIS (N3242, available at http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/ ) to try and determine two things: When is the compiler obligated to evaluate a constexpr function during translation? When is the compiler allowed to evaluate a constexpr function during translation? Section 5.19 Paragraph 1 says that constant expressions can be

Background For a long time, gcc has been providing a number of builtin bit-twiddling functions, in particular the number of trailing and leading 0-bits (also for long unsigned and long long unsigned , which have suffixes l and ll ): — Built-in Function: int __builtin_clz (unsigned int x) Returns the number of leading 0-bits in x , starting at the most significant bit position. If x is 0, the result is undefined. — Built-in Function: int __builtin_ctz (unsigned int x) Returns the number of trailing 0-bits in x , starting at the least significant bit position. If x is 0, the result is undefined.

The below code calculates Fibonacci numbers by an exponentially slow algorithm: #include <cstdlib> #include <iostream> #define DEBUG(var) { std::cout << #var << ": " << (var) << std::endl; } constexpr auto fib(const size_t n) -> long long { return n < 2 ? 1: fib(n - 1) + fib(n - 2); } int main(int argc, char *argv[]) { const long long fib91 = fib(91); DEBUG( fib91 ); DEBUG( fib(45) ); return EXIT_SUCCESS; } And I am calculating the 45th Fibonacci number at run-time, and the 91st one at compile time. The interesting fact is that GCC 4.9 compiles the code and computes fib91 in a fraction of a

This is valid code: struct S { constexpr S(int x, int y): xVal(x), yVal(y) {} constexpr S(int x): xVal(x) {} constexpr S() {} const int xVal { 0 }; const int yVal { 0 }; }; But here I'd really like to declare xVal and yVal constexpr --like this: struct S { constexpr S(int x, int y): xVal(x), yVal(y) {} constexpr S(int x): xVal(x) {} constexpr S() {} constexpr int xVal { 0 }; // error! constexpr int yVal { 0 }; // error! }; As indicated, the code won't compile. The reason is that (per 7.1.5/1), only static data members may be declared constexpr . But why ? Think about what constexpr means. It