Identical literal strings are not guaranty to be identical, but you can build type from it which can compare identical (without comparing string), something like: // Sequence of char template <char…Cs> struct char_sequence { template <char C> using push_back = char_sequence<Cs…, C>; }; // Remove all chars from char_sequence from ‘\0’ template <typename, char…> struct … Read more
The factorial can be printed in compiler-generated message as: template<int x> struct _; int main() { _<Factorial<10>::value> __; return 0; } Error message: prog.cpp:14:32: error: aggregate ‘_<3628800> __’ has incomplete type and cannot be defined _::value> __; ^ Here 3628800 is factorial of 10. See it at ideone : http://ideone.com/094SJz So are you looking for … Read more
You can’t make the compiler differentiate between the two uses of operator[], because they are the same thing. Operator[] returns a reference, so the assignment version is just assigning to that reference. Personally, I never use operator[] for maps for anything but quick and dirty demo code. Use insert() and find() instead. Note that the … Read more
A compile-time dependency is generally required at runtime. In maven, a compile scoped dependency will be added to the classpath on runtime (e.g. in wars they will be copied to WEB-INF/lib). It is not, however, strictly required; for instance, we may compile against a certain API, making it a compile-time dependency, but then at runtime … Read more
There’s no inter-compiler standard, but each compiler tends to be quite consistent. You can build a header for yourself that’s something like this: #if MSVC #ifdef _M_X86 #define ARCH_X86 #endif #endif #if GCC #ifdef __i386__ #define ARCH_X86 #endif #endif There’s not much point to a comprehensive list, because there are thousands of compilers but only … Read more
“You’re all ignoring the actual definition and focusing on the note, The standard imposes no requirements.” – @R.MartinhoFernandes The message above was written by the given user in Lounge<C++> and makes a very valid argument; the standard doesn’t impose any requirements when it comes to code that invokes undefined behavior. ! ! ! undefined-behavior stretches … Read more
It is possible to detect if a given function-call expression is a constant expression, and thereby select between two different implementations. Requires C++14 for the generic lambda used below. (This answer grew out this answer from @Yakk to a question I asked last year). I’m not sure how far I’m pushing the Standard. This is … Read more
As stated earlier, the only “real” way to detect Big Endian is to use runtime tests. However, sometimes, a macro might be preferred. Unfortunately, I’ve not found a single “test” to detect this situation, rather a collection of them. For example, GCC recommends : __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ . However, this only works with latest versions, … Read more
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, string_view const& s) { return o.write(s.data, s.size); } template<class T> constexpr string_view get_name() { char const* p = __PRETTY_FUNCTION__; while (*p++ != ‘=’); for (; *p == ‘ ‘; ++p); char const* … Read more
You can leverage std::function here which will give you an alias for the functions return type. This does require C++17 support, since it relies on class template argument deduction, but it will work with any callable type: using ReturnTypeOfFoo = decltype(std::function{foo})::result_type; We can make this a little more generic like template<typename Callable> using return_type_of_t = … Read more