Numeric UDL operator template

Question

I'm trying to define what Pablo Halpern calls a numeric UDL operator template. I want it to return a lambda that would count how many characters at the beginning of a char array are from the given set.

Here's my test code:

template <char... c>
constexpr auto operator ""_cntany() {
  return [](const char* s){
    unsigned n = 0;
    while (((*s==c) || ...)) { ++n; ++s; }
    return n;
  };
}

int main(int argc, char** argv) {
  return ("test"_cntany)(argv[1]);
}

But this doesn't compile with GCC 11.2 (https://godbolt.org/z/TdbKzTMW8). Here's the error I'm getting:

<source>: In function 'int main(int, char**)':
<source>:11:15: error: no matching function for call to 'operator""_cntany<"test">()'
  11 |       return ("test"_cntany)(argv[1]);
      |               ^~~~~~~~~~~~~
<source>:2:20: note: candidate: 'template<char ...c> constexpr auto operator""_cntany()'
    2 |     constexpr auto operator ""_cntany() {
      |                    ^~~~~~~~
<source>:2:20: note:   template argument deduction/substitution failed:
<source>:11:15: error: '"test"' is not a valid template argument for type 'char' because string literals can never be used in this context
  11 |       return ("test"_cntany)(argv[1]);
     |               ^~~~~~~~~~~~~
Compiler returned: 1

What am I doing wrong?

JHBonarius · Accepted Answer · 2022-02-10T14:39:39.800

2

cppreference says

If the literal operator is a template, it must have an empty parameter list and can have only one template parameter, which must be a non-type template parameter pack with element type char (in which case it is known as a numeric literal operator template)

template <char...> double operator "" _x();

Also see [over.literal.5]

i.e. it's numeric-, and not a string literal.

It can be used like 123_cntany.

Note, there is a new C++20 string literal operator template: see this answer

edited Feb 10 '22 at 14:39

answered Feb 10 '22 at 14:32

JHBonarius

10,824
3
22
41

Thanks for pointing this out. I read this part but missed the point that the prefix can only be a **numeric** literal. Strange that there would be such a limitation. – SU3 Feb 10 '22 at 14:36

score 2 · Answer 2 · edited Feb 10 '22 at 15:11

2

template user-defined literals need to accept numeric values such as 0123_cntany, so you may need to just use user-defined string-literal:

#include <cstddef>
#include <string_view>

constexpr auto operator ""_cntany(const char* s, std::size_t count) {
  return [sv = std::string_view(s, count)](const char* s){
    unsigned n = 0;
    while (sv.contains(*s)) { ++n; ++s; }
    return n;
  };
}

edited Feb 10 '22 at 15:11

Nicol Bolas

449,505
63
781
982

answered Feb 10 '22 at 15:03

康桓瑋

33,481
5
40
90

No need to compute a length when you were given one. – Nicol Bolas Feb 10 '22 at 15:11

score 1 · Answer 3 · answered Feb 10 '22 at 14:33

C++ doesn't have udl for string with that template format unfortunately.

gcc has an extension for that template <typename Char, Char... c>

so it would be

template <typename Char, Char... c>
constexpr auto operator ""_cntany() {
  return [](const char* s){
    unsigned n = 0;
    while (((*s==c) || ...)) { ++n; ++s; }
    return n;
  };
}

but it is not portable as extension.

Numeric UDL operator template

3 Answers3