Geek Answers Handbook

How to use number separators for non-piggy template options?

I have a template that accepts non-standard template parameters of type unsigned long long . Creating an instance of this template quickly becomes confusing because it involves so many numbers. In fact, ideally, I would use a binary representation, which would make it even worse: there are up to 64 characters 0 and 1 . How to create a visually recognizable argument. For example:

 template <unsigned long long> struct use_mask { // for this question it doesn't matter what the template actually does }; int main() { use_mask<0b1001001010010010> unreadable; // OK, there are no binary literals use_mask<0b1001,0010,1001,0010> more_readable; // ... nor are there digit separators }

Is there a way to approximate the last notation, perhaps with some materials before and after the value?

+7
c ++ c ++ 11 literals
source share
5 answers

Here is my question, answering my own question: using a custom literal that is implemented as constexpr along with a string literal allows you to efficiently define a parser for the corresponding value! There are two parts that are a little ugly:

  • The actual literal is enclosed in double quotes.
  • The end of the line is the user literal.

In addition, this approach actually allows you to specify integer literals, including numeric delimiters. I am currently not quite able to create a fancy version confirming that the delimiters are in the right place, but this should be just a small detail of the correct programming. The following is a program that implements the corresponding user literal, which allows you to use functions such as

 use_mask<"0b0101,0101,0101,0101,0011,0101"_sep> um1; use_mask<"0x0123,4567,89ab,cdef"_sep> um2;

Of course, in fact, this also forces the use of literals. Factual literals

 "0b0101,0101,0101,0101,0011,0101"_sep "0x0123,4567,89ab,cdef"_sep

... and they can be used completely separately. Error messages throwing an exception are not necessarily as beautiful as we would like. It was also pointed out that the use of a user-defined literal for processing digit separators precludes the use of other user literals.

 #include <algorithm> #include <iostream> #include <stdexcept> template <unsigned long long Value> struct use_mask { static constexpr unsigned long long value = Value; }; // ------------------------------------------------------------------------ constexpr bool is_digit(char c, unsigned base) { return '0' <= c && c < '0' + int(base < 10u? base: 10u); } constexpr bool is_hexdigit(char c) { return ('a' <= c && c <= 'f') || ('A' <= c && c <= 'F'); } constexpr unsigned long long hex_value(char c) { return c - (('a' <= c && c <= 'f')? 'a': 'A') + 10; } // ------------------------------------------------------------------------ constexpr unsigned long long decode(unsigned long long value, unsigned base, char const* str, size_t n) { return n == 0 ? value : (str[0] == ',' ? decode(value, base, str + 1, n - 1) : (is_digit(str[0], base) ? decode(value * base + str[0] - '0', base, str + 1, n - 1) : (base == 16u && is_hexdigit(str[0]) ? decode(value * base + hex_value(str[0]), base, str + 1, n - 1) : throw "ill-formed constant with digit separators" ) ) ); } constexpr unsigned long long operator"" _sep(char const* value, std::size_t n) { return 2 < n && value[0] == '0' ? ((value[1] == 'b' || value[1] == 'B') ? decode(0ull, 2, value + 2, n - 2) : ((value[1] == 'x' || value[1] == 'X') ? decode(0ull, 16, value + 2, n - 2) : decode(0ull, 8, value + 1, n - 1))) : decode(0ull, 10, value, n); } int main() { std::cout << use_mask<"0b1010,1010"_sep>::value << "\n"; std::cout << use_mask<"02,52"_sep>::value << "\n"; std::cout << use_mask<"1,70"_sep>::value << "\n"; std::cout << use_mask<"0xA,A"_sep>::value << "\n"; #ifdef ERROR std::cout << use_mask<"0xx,A"_sep>::value << "\n"; #endif std::cout << use_mask<"0b0101,0101,0101,0101,0011,0101"_sep>::value << '\n'; std::cout << use_mask<"0x0123,4567,89ab,cdef"_sep>::value << '\n'; }
+7
source share

Starting with C ++ 14, this is valid:

 use_mask<0b1001'0010'1001'0010> its_just_what_i_wanted;
+5
source share

Not ideal, since a comma is required for each binary digit, but any number of spaces is allowed for any const expr for any binary digit - for example, 0xFFFF FFFF FFFF FFFF, which should be:

 use_mask<bit64< 1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1 >::VAL>

the code:

 template < bool b3F,bool b3E,bool b3D,bool b3C,bool b3B,bool b3A,bool b39,bool b38, bool b37,bool b36,bool b35,bool b34,bool b33,bool b32,bool b31,bool b30, bool b2F,bool b2E,bool b2D,bool b2C,bool b2B,bool b2A,bool b29,bool b28, bool b27,bool b26,bool b25,bool b24,bool b23,bool b22,bool b21,bool b20, bool b1F,bool b1E,bool b1D,bool b1C,bool b1B,bool b1A,bool b19,bool b18, bool b17,bool b16,bool b15,bool b14,bool b13,bool b12,bool b11,bool b10, bool b0F,bool b0E,bool b0D,bool b0C,bool b0B,bool b0A,bool b09,bool b08, bool b07,bool b06,bool b05,bool b04,bool b03,bool b02,bool b01,bool b00 > class bit64 { public: static const unsigned long long VAL=0UL |((unsigned long long)b00<< 0)|((unsigned long long)b01<< 1)|((unsigned long long)b02<< 2)|((unsigned long long)b03<< 3) |((unsigned long long)b04<< 4)|((unsigned long long)b05<< 5)|((unsigned long long)b06<< 6)|((unsigned long long)b07<< 7) |((unsigned long long)b08<< 8)|((unsigned long long)b09<< 9)|((unsigned long long)b0A<<10)|((unsigned long long)b0B<<11) |((unsigned long long)b0C<<12)|((unsigned long long)b0D<<13)|((unsigned long long)b0E<<14)|((unsigned long long)b0F<<15) |((unsigned long long)b10<<16)|((unsigned long long)b11<<17)|((unsigned long long)b12<<18)|((unsigned long long)b13<<19) |((unsigned long long)b14<<20)|((unsigned long long)b15<<21)|((unsigned long long)b16<<22)|((unsigned long long)b17<<23) |((unsigned long long)b18<<24)|((unsigned long long)b19<<25)|((unsigned long long)b1A<<26)|((unsigned long long)b1B<<27) |((unsigned long long)b1C<<28)|((unsigned long long)b1D<<29)|((unsigned long long)b1E<<30)|((unsigned long long)b2F<<31) |((unsigned long long)b20<<32)|((unsigned long long)b21<<33)|((unsigned long long)b22<<34)|((unsigned long long)b23<<35) |((unsigned long long)b24<<36)|((unsigned long long)b25<<37)|((unsigned long long)b26<<38)|((unsigned long long)b27<<39) |((unsigned long long)b28<<40)|((unsigned long long)b29<<41)|((unsigned long long)b2A<<42)|((unsigned long long)b2B<<43) |((unsigned long long)b2C<<44)|((unsigned long long)b2D<<45)|((unsigned long long)b2E<<46)|((unsigned long long)b3F<<47) |((unsigned long long)b30<<48)|((unsigned long long)b31<<49)|((unsigned long long)b32<<50)|((unsigned long long)b33<<51) |((unsigned long long)b34<<52)|((unsigned long long)b35<<53)|((unsigned long long)b36<<54)|((unsigned long long)b37<<55) |((unsigned long long)b38<<56)|((unsigned long long)b39<<57)|((unsigned long long)b3A<<58)|((unsigned long long)b3B<<59) |((unsigned long long)b3C<<60)|((unsigned long long)b3D<<61)|((unsigned long long)b3E<<62)|((unsigned long long)b3F<<63) ; };

It could also be constexpr for compilers that support it.

+1
source share

An alternative is to use a macro:

 #define ULongLongHex(p1, p2, p3, p4) (0x ## p1 ## p2 ## p3 ## p4) ULongLongHex(0123,4567,89ab,cdef)

but do not check .: (

0
source share

I don't have a C ++ compiler for experimentation, but you can try the approach on these lines (using the UDL template form):

 template<char... chars> constexpr unsigned long long operator"" _bin(); template<char... chars> constexpr unsigned long long operator"" _bin<'0', chars...>() { // return correctly shifted calculated value. } template<char... chars> constexpr unsigned long long operator"" _bin<'1', chars...>() { // return correctly shifted calculated value. } template<char... chars> constexpr unsigned long long operator"" _bin<'_', chars...>() { // simply forward to rest }

Sorry for not being specific enough, I just don't have the tools here, but I saw how UDL parsing was done this way.

0
source share

More articles:


All Articles