constexpr

Suppose I have a constexpr array (of known bound) of static storage duration: constexpr T input[] = /* ... */; And I have an output class template that needs a pack: template<T...> struct output_template; I want to instantiate output_template like: using output = output_template<input[0], input[1], ..., input[n-1]>; One way to do this is: template<size_t n, const T (&a)[n]> struct make_output_template { template<size_t... i> static constexpr output_template<a[i]...> f(std::index_sequence<i...>) { return {}; }; using type = decltype(f(std::make_index_sequence<n>())); }; using output = make

Why doesn't this compile: Could there be a problem with a string as a return type? constexpr std::string fnc() { return std::string("Yaba"); } The constructor of std::string that takes a pointer to char is not constexpr . In constexpr functions you can only use functions that are constexpr . 来源： https://stackoverflow.com/questions/7779013/function-returning-constexpr-does-not-compile

I'm using gcc 4.6.1 and am getting some interesting behavior involving calling a constexpr function. This program runs just fine and straight away prints out 12200160415121876738 . #include <iostream> extern const unsigned long joe; constexpr unsigned long fib(unsigned long int x) { return (x <= 1) ? 1 : (fib(x - 1) + fib(x - 2)); } const unsigned long joe = fib(92); int main() { ::std::cout << "Here I am!\n"; ::std::cout << joe << '\n'; return 0; } This program takes forever to run and I've never had the patience to wait for it to print out a value: #include <iostream> constexpr unsigned long

g++ (4.7.2) and similar versions seem to evaluate constexpr surprisingly fast during compile-time. On my machines in fact much faster than the compiled program during runtime. Is there a reasonable explanation for that behavior? Are there optimization techniques involved which are only applicable at compile-time, that can be executed quicker than actual compiled code? If so, which? Here`s my test program and the observed results. #include <iostream> constexpr int mc91(int n) { return (n > 100)? n-10 : mc91(mc91(n+11)); } constexpr double foo(double n) { return (n>2)? (0.9999)*((unsigned int)

I wonder whether for long loops we can take advantage of tail recursion for constexpr in C++11? By the rules in [implimits] , an implementation is permitted to put a recursion depth limit on constexpr calculations. The two compilers which have complete constexpr implementations (gcc and clang) both apply such a limit, using the default of 512 recursive calls as suggested by the standard. For both of these compilers, as well as any other implementation which follows the standard's suggestion, a tail recursion optimization would be essentially undetectable (unless the compiler would otherwise

I'm testing out user defined literals. I want to make _fac return the factorial of the number. Having it call a constexpr function works, however it doesn't let me do it with templates as the compiler complains that the arguments are not and cannot be constexpr . I'm confused by this - aren't literals constant expressions? The 5 in 5_fac is always a literal that can be evaluated during compile time, so why can't I use it as such? First method: constexpr int factorial_function(int x) { return (x > 0) ? x * factorial_function(x - 1) : 1; } constexpr int operator "" _fac(unsigned long long x) {

Why constexpr does not work with std::cout , but works with printf ? #include <iostream> constexpr void f() { std::cout << ""; } //error constexpr void g() { printf(""); } //ok And why std::cout works with lambdas constexpr ? #include <iostream> int main () { auto h = []() constexpr { std::cout << ""; }; //ok } Technically, it doesn't work with any of them. From [dcl.constexr] : For a constexpr function or constexpr constructor that is neither defaulted nor a template, if no argument values exist such that an invocation of the function or constructor could be an evaluated subexpression of a