constexpr

If I have a variable inside a function (say, a large array), does it make sense to declare it both static and constexpr ? constexpr guarantees that the array is created at compile time, so would the static be useless? void f() { static constexpr int x [] = { // a few thousand elements }; // do something with the array } Is the static actually doing anything there in terms of generated code or semantics? rici The short answer is that not only is static useful, it is pretty well always going to be desired. First, note that static and constexpr are completely independent of each other. static

Requirements I want a constexpr value (i.e. a compile-time constant) computed from a constexpr function. And I want both of these scoped to the namespace of a class, i.e. a static method and a static member of the class. First attempt I first wrote this the (to me) obvious way: class C1 { constexpr static int foo(int x) { return x + 1; } constexpr static int bar = foo(sizeof(int)); }; g++-4.5.3 -std=gnu++0x says to that: error: ‘static int C1::foo(int)’ cannot appear in a constant-expression error: a function call cannot appear in a constant-expression g++-4.6.3 -std=gnu++0x complains: error:

Consider the following inlined function : // Inline specifier version #include<iostream> #include<cstdlib> inline int f(const int x); inline int f(const int x) { return 2*x; } int main(int argc, char* argv[]) { return f(std::atoi(argv[1])); } and the constexpr equivalent version : // Constexpr specifier version #include<iostream> #include<cstdlib> constexpr int f(const int x); constexpr int f(const int x) { return 2*x; } int main(int argc, char* argv[]) { return f(std::atoi(argv[1])); } My question is : does the constexpr specifier imply the inline specifier in the sense that if a non-constant

Suppose I have some constexpr function f: constexpr int f(int x) { ... } And I have some const int N known at compile time: Either #define N ...; or const int N = ...; as needed by your answer. I want to have an int array X: int X[N] = { f(0), f(1), f(2), ..., f(N-1) } such that the function is evaluated at compile time, and the entries in X are calculated by the compiler and the results are placed in the static area of my application image exactly as if I had used integer literals in my X initializer list. Is there some way I can write this? (For example with templates or macros and so on)

I have a hard time understanding how this code (an example from the C++14 draft standard [conv.lval] ) invokes undefined behavior for g(false) . Why does constexpr make the program valid? Also, what does it mean by "does not access y.n "? In both calls to g() we are returning the n data member so why does the last line say it doesn't access it? struct S { int n; }; auto f() { S x { 1 }; constexpr S y { 2 }; return [&](bool b) { return (b ? y : x).n; }; } auto g = f(); int m = g(false); // undefined behavior due to access of x.n outside its // lifetime int n = g(true); // OK, does not access y