compile-time

I was toying a little bit with the indices trick to see where I could go to with and came across a strange error... First, the plain not-so-old indices: template<std::size_t...> struct indices {}; template<std::size_t N, std::size_t... Indices> struct make_indices: make_indices<N-1, N-1, Indices...> {}; template<std::size_t... Indices> struct make_indices<0, Indices...>: indices<Indices...> {}; I created a compile-time array class derived from a std::initializer_list and had it indexable (assume that N3471 is support by your compiler. It will be in the next standard anyway). Here it is:

This is different from checking if a specific function is defined. Here, for this check to return true , the function has to be defined and passing the arguments of a certain type should result in a valid call. Example: for a function f and an argument of type T && , the check should return true if f is a valid function that accepts—either directly or through implicit conversion—an argument of type T && . void f(int &) {}; int main(int argc, char **av) { isFunctionCallable<int>(f); // true because `int i; f(i);` is valid. isFunctionCallable<int &&>(f); // false because `int i; f(std::move(i));

I need to implement self contained compile-time function for checking type equality (function template without arguments bool eqTypes<T,S>() ). self contained means not relying on library. I'm not good in all this. That's what I tried, but it's not what I need. template<typename T> bool eq_types(T const&, T const&) { return true; } template<typename T, typename U> bool eq_types(T const&, U const&) { return false; } It's quite simple. Just define a type trait and a helper function: template<typename T, typename U> struct is_same { static const bool value = false; }; template<typename T> struct

I'm working on an open-source project that can optionally use a closed-source framework. If the closed-source framework is included in the project, there will be additional functionality. But if the framework isn't included in the project, the project should still compile properly. How do I check at compile-time if the framework is included in the project? Basically, I want to do something like this: #ifdef _MY_FRAMEWORK_EXISTS #import <MyFramework/MyFramework.h> #endif I've seen older questions from 2 years ago like this one , but no answer has surfaced so I might be missing something new now

Why does the C++ compiler makes it possible to declare a function as constexpr, which can not be constexpr? For example: http://melpon.org/wandbox/permlink/AGwniRNRbfmXfj8r #include <iostream> #include <functional> #include <numeric> #include <initializer_list> template<typename Functor, typename T, size_t N> T constexpr reduce(Functor f, T(&arr)[N]) { return std::accumulate(std::next(std::begin(arr)), std::end(arr), *(std::begin(arr)), f); } template<typename Functor, typename T> T constexpr reduce(Functor f, std::initializer_list<T> il) { return std::accumulate(std::next(il.begin()), il.end(