user-defined-literals

I'm moving some code over to GCC 4.7 (from 4.6) and ran into a few compiler errors and found the problem documented in the GCC 4.7 porting guide : User-defined literals and whitespace The C++ compiler in ISO C11 mode std={c++11,c++0x,gnu++11,gnu++0x} supports user defined literals, which are incompatible with some valid ISO C++03 code. In particular, whitespace is now needed after a string literal and before something that could be a valid user defined literal. Take the valid ISO C++03 code const char *p = "foobar"__TIME__; In C++03, the TIME macro expands to some string literal and is

C++14 includes standard-defined literals for, amongst other things, std::string and various timespans from the <chrono> header. To use them you must say using namespace std::literals; (or some variation depending on exactly which literals you want, as they're in a variety of inline namespaces). All this is good, but I'm curious as to why the using declaration is required. UDLs without a leading underscore are reserved for the implementation, so there is no possibility that "hello world"s could ever mean anything else in a standard-conforming programme. So why isn't #include <string> sufficient

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) {

The strings topic in the SO Documentation used to say, in the Remarks section: Since C++14, instead of using "foo" , it is recommended to use "foo"s , as s is a string literal, which converts the const char * "foo" to std::string "foo" . The only advantage I see using std::string str = "foo"s; instead of std::string str = "foo"; is that in the first case the compiler can perform copy-elision (I think), which would be faster than the constructor call in the second case. Nonetheless, this is (not yet) guaranteed, so the first one might also call a constructor, the copy constructor. Ignoring

Using gcc 4.9 I found that types generated with type literal for complex numbers are not the same as when created by conventional means, i.e.: typeid(complex<double>(0.0,1.0)) != typeid(1.0i) Am I making a mistake here? Is this a compiler bug or intended standard behavior? If intended standard behavior: What is the rationale behind? Adding the missing MCVE #include <complex> using std::complex; using namespace std::literals::complex_literals; #include <iostream> using std::cout; using std::endl; #include <typeinfo> int main(int argc, char* argv[]) { if (typeid(complex<double>(0.0, 1.0)) ==