c++ - How to detect a pointer to an arithmetic type using type traits and concepts?

Question

How do I write a concept that detects a pointer to an arithmetic type?

template <typename T>
concept arithmetic = std::is_arithmetic<T>::value;

template <typename T>
concept pointer_to_arithmetic = requires (T a) {
    { *a } -> arithmetic;
};

template <typename T>
void fn() {
    printf("fail
");
}   

template <pointer_to_arithmetic T>
void fn() {
    printf("pass
");
}   

struct s{};

int main() {
    fn<int>();
    fn<int*>();
    fn<s>();
    fn<s*>();
}

I tried the above and it compiles but doesn't do what it's supposed to.

Expected output is:

fail
pass
fail
fail

Instead I get:

fail
fail
fail
fail

It also doesn't work if I replace *a with a[0].

question from:https://stackoverflow.com/questions/65864208/how-to-detect-a-pointer-to-an-arithmetic-type-using-type-traits-and-concepts

Answer 1

For an expression E in a compound requirement, the type constraint predicate is fed decltype((E))¹.

decltype encodes the value category of the expression in the type it deduces. Since *p is an lvalue expression. The deduced type is T& for some T.

So you may want to rewrite your pair of concepts as

template <typename T>
concept arithmetic_ref = std::is_arithmetic<std::remove_reference_t<T>>::value;

template <typename T>
concept pointer_to_arithmetic = requires (T a) {
    { *a } -> arithmetic_ref ;
};

_{The atomic predicate could probably be better named.}

---

Of course, this leaves a couple of questions open. Are you just duck-typing, and so any pointer-like type (even std::optional has operator*) is permissible? Or are you after only fundamental pointer types? How should the concept treat cv-qualified types (it currently doesn't permit them)?

Depending on how you answer those questions, the concept could be tweaked further.