User defined literals definitions - c++

Question

I was taking a look at the cppreference page for user defined literals, and I think I understand everything except a few examples
template <char...> double operator "" _π(); // OK
How does this operator work? How can you call it?
double operator"" _Z(long double); // error: all names that begin with underscore
// followed by uppercase letter are reserved
double operator""_Z(long double); // OK: even though _Z is reserved ""_Z is allowed
What is the difference between the above two functions? What would be the difference in calling the first function as opposed to the second if the first were not an error?
Thanks!

Answer 1

template <char...> double operator "" _π(); // OK
How does this operator work? How can you call it?
1.234_π will call operator "" _π<'1', '.', '2', '3', '4'>(). This form allows you to detect differences in spelling that would ordinarily be undetectable (1.2 vs 1.20, for example), and allows you to avoid rounding issues due to 1.2 not being exactly representable in even long double.
double operator"" _Z(long double); // error: all names that begin with underscore
// followed by uppercase letter are reserved
double operator""_Z(long double); // OK: even though _Z is reserved ""_Z is allowed
What is the difference between the above two functions?
The C++ standard defines the grammar in terms of tokens, which you can sort of interpret as words. "" _Z is two tokens, "" and _Z. ""_Z is a single token.
This distinction matters: given #define S " world!", and then "Hello" S, the whitespace is what makes S a standalone token, preventing it from being seen as a user-defined literal suffix.
For easier coding, both "" _Z and ""_Z syntaxes are generally allowed when defining these functions, but the "" _Z syntax requires _Z to be seen as an identifier. This can cause problems when an implementation predefines _Z as a macro, or declares it as a custom keyword.

Answer 2

As far as I understand there is not difference between the two signitures.
The issue is that the identifier _Z is technically reserved by the standard. The main difference is that there is a space:
double operator""/*space*/_Z(long double);
double operator""_Z(long double);
Removing the space is basically a workaround that in theory would suppress the error (or more likely a warning).
As far as how you use them, did you look at the examples from the link you listed?
#include <iostream>
// used as conversion
constexpr long double operator"" _deg ( long double deg )
{
return deg*3.141592/180;
}
// used with custom type
struct mytype
{
mytype ( unsigned long long m):m(m){}
unsigned long long m;
};
mytype operator"" _mytype ( unsigned long long n )
{
return mytype(n);
}
// used for side-effects
void operator"" _print ( const char* str )
{
std::cout << str;
}
int main(){
double x = 90.0_deg;
std::cout << std::fixed << x << '\n';
mytype y = 123_mytype;
std::cout << y.m << '\n';
0x123ABC_print;
}
The idea behind the user defined literals is to allow the creation of an operator that can be applied to built in types that can convert the built in literal to another type.
EDIT:
To call one of these operators you just need to append the operator as a suffix to a value literal. So given:
// used as conversion
constexpr long double operator"" _deg ( long double deg )
{
return deg*3.141592/180;
}
The calling code could be for example:
long double d = 45_deg;
As far as using template <char...> double operator "" _π(); Maybe take a look at this.