constexpr

This previously answered question explains why the code I have posted below does not work. I have a follow-up question: is there a workaround that is conceptually equivalent, i.e., achieves compile-time string concatenation, but is implemented in a way that is actually supported by C++11? Using std::string is completely non-essential. constexpr std::string foo() { return std::string("foo"); } constexpr std::string bar() { return std::string("bar"); } constexpr std::string foobar() { return foo() + bar(); } Compile-time "string" concatenation : #include <iostream> #include <string> template

Here is my code and I need clarification on what's happening: constexpr int funct(int x){ return x + 1; } int main(){ int x = funct(10); return 0; } constexpr 's allows compile time calculation, and based on my code above, since funct is declared as constexpr , it is allowed to do compile time calculations if the arguments are constants or constexpr's themselves. The part that I am confused with lies in this part, the int x . Since it is not declared as constexpr , would it mean that int x will get the value at runtime? Does that mean that declaring it to be constexpr int x will mean that int

Is there anything in the world of C++ that would make what I'm trying to do possible? template < typename T , size_t Size > struct array { constexpr T buf[Size]; constexpr size_t size() const { return Size; } }; template < typename T , size_t Size > constexpr array<T,Size+1> push_back(array<T,Size> const& arr, T const& val) { array<T,Size+1> arr_out = {{arr.buf, val}}; return arr_out; } What I'm trying to do is create a new array initialized with the data in the other, and put a new element on the end. Minus the constexpr I can get it to work by loop initializing in the push_back function. It

I am trying to use an integer as a template parameter for a class. Here is a sample of the code: template< int array_qty > class sample_class { public: std::array< std::string, array_qty > sample_array; } If I do so something like this, it works: sample_class< 10 > sample_class_instance; However, let's say that I do not know the value of array_qty (the template parameter) when compiling, and will only know it during run-time. In this case, I would essentially be passing an int variable as the template argument. For the sake of demonstration, the following code does not work: int test_var = 2;

Most C++ compilers support SIMD(SSE/AVX) instructions with intrisics like _mm_cmpeq_epi32 My problem with this is that this function is not marked as constexpr , although "semantically" there is no reason for this function to not be constexpr since it is a pure function. Is there any way I could write my own version of (for example) _mm_cmpeq_epi32 that is constexpr ? Obviously I would like that the function at runtime uses the proper asm, I know I can reimplement any SIMD function with slow function that is constexpr . If you wonder why I care about constexpr of SIMD functions. Non