compile-time

I would like to use the name of a type at compile time. For example, suppose I've written: constexpr size_t my_strlen(const char* s) { const char* cp = s; while(*cp != '\0') { cp++; }; return cp - s; } and now I want to have: template <typename T> constexpr auto type_name_length = my_strlen(typeid(T).name()); But alas, typeid(T).name() is just const char* , not constexpr... is there some other, constexpr way to get a type's name? Well, you could, sort of, but probably not quite portable: struct string_view { char const* data; std::size_t size; }; inline std::ostream& operator<<(std::ostream& o

How can I print the result of sizeof() at compile time in C? For now I am using a static assert (home brewed based on other web resources) to compare the sizeof() result to various constants. While this works... it is far from elegant or fast. I can also create an instance of the variable/struct and look in the map file but this is also less elegant and fast than a direct call/command/operator. Further, this is an embedded project using multiple cross-compilers... so building and loading a sample program to the target and then reading out a value is even more of a hassle than either of the

We can pass reference of an array to a function like: void f(int (&a)[5]); int x[5]; f(x); //okay int y[6]; f(y); //error - type of y is not `int (&)[5]`. Or even better, we can write a function template: template<size_t N> void f(int (&a)[N]); //N is size of the array! int x[5]; f(x); //okay - N becomes 5 int y[6]; f(y); //okay - N becomes 6 Now my question is, how to return reference of an array from a function? I want to return array of folllowing types from a function: int a[N]; int a[M][N]; int (*a)[N]; int (*a)[M][N]; where M and N is known at compile time! What are general rules for

I'm currently trying to create a C source code which properly handles I/O whatever the endianness of the target system. I've selected "little endian" as my I/O convention, which means that, for big endian CPU, I need to convert data while writing or reading. Conversion is not the issue. The problem I face is to detect endianness, preferably at compile time (since CPU do not change endianness in the middle of execution...). Up to now, I've been using this : #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ ... #else ... #endif It's documented as a GCC pre-defined macro, and Visual seems to

template<unsigned int n> struct Factorial { enum { value = n * Factorial<n-1>::value}; }; template<> struct Factorial<0> { enum {value = 1}; }; int main() { std::cout << Factorial<5>::value; std::cout << Factorial<10>::value; } above program computes factorial value during compile time. I want to print factorial value at compile time rather than at runtime using cout. How can we achive printing the factorial value at compile time? I am using VS2009. Thanks! The factorial can be printed in compiler-generated message as: template<int x> struct _; int main() { _<Factorial<10>::value> __; return 0

I understand the difference between runtime and compile-time and how to differentiate between the two, but I just don't see the need to make a distinction between compile-time and runtime dependencies . What I'm choking on is this: how can a program not depend on something at runtime that it depended on during compilation? If my Java app uses log4j, then it needs the log4j.jar file in order to compile (my code integrating with and invoking member methods from inside log4j) as well as runtime (my code has absolutely no control over what happens once code inside log4j.jar is ran). I'm reading up