constexpr

I've implemented a constexpr array like this: template <typename T> class const_array { const T* p; unsigned n; public: template <unsigned N> constexpr const_array(const T(&a)[N]): p(a), n(N) { } constexpr unsigned size() const { return n; } }; int main(int argc, char* argv[]) { // works static_assert(const_array<double>{{1.,2.,3.}}.size() == 3); // doesn't compile constexpr const_array<double> a{{1.,2.,3.}}; static_assert(a.size() == 3); } Why is it that the first static_assert compiles, but initializing a fails?I'm using gcc 6.2.0. I'm getting : In function 'int main(int, char**)': : error:

I want to create a structure that allocates statically an array of 2^N bytes , but I don't want the users of this structure to specify this size as the exponent. Example: my_stupid_array<char, 32> a1; // I want this! my_stupid_array<char, 5> a2; // And not this... How do I check if this template parameter is a power of two and warn the user with a nice message about this? I've been able to check for this with a simple template: template<int N> struct is_power_of_two { enum {val = (N >= 1) & !(N & (N - 1))}; }; However, I'm unable to warn the user about this with a sane message. Any ideas? EDIT

Is there a way to achieve different behaviour of a constexpr function in the compilation phase and at runtime? Consider the following example (using a theoretical feature from D: static if ): constexpr int pow( int base , int exp ) noexcept { static if( std::evaluated_during_translation() ) { auto result = 1; for( int i = 0 ; i < exp ; i++ ) result *= base; return result; } else { // std::evaluated_during_runtime() return std::pow( base , exp ); } } If not, is there a way to restrict constexpr to be compile-time only? No, there is no such way. Sorry. N3583 is a paper proposing changes to allow

§5.19/3 in C++14 defines an integral constant expression and a converted constant expression: An integral constant expression is an expression of integral or unscoped enumeration type, implicitly converted to a prvalue, where the converted expression is a core constant expression. [ Note: Such expressions may be used as array bounds (8.3.4, 5.3.4), as bit-field lengths (9.6), as enumerator initializers if the underlying type is not fixed (7.2), and as alignments (7.6.2). —end note ] A converted constant expression of type T is an expression, implicitly converted to a prvalue of type T , where

Here is my code: class test{ public: constexpr test(){ } constexpr int operator+(const test& rhs){ return 1; } }; int main(){ test t; //constexpr word isn't necessary constexpr int b = t+test(); // works at compile time! int w = 10; // ERROR constexpr required constexpr int c = w + 2; // Requires w to be constexpr return 0; } I notice that it worked even though I didn't specify test to be constexpr . I tried replicating the result by doing the same with int but i get errors. Specifically, it wants my int w inside the constexpr int c = w + 2; to be constexpr . From my first attempt which is