In a concept, how can I check that a member is static?

Question

This is similar to Understanding concepts. Check if a member is static, but that Q&A only asks why it doesn't work, and here I'm asking how to fix it.

Consider the following code:

struct A
{
    static int x;
};

struct B
{
    int x;
};

template <typename T>
concept C = requires
{
    T::x;
};

static_assert(C<A>); // OK, as expected
static_assert(!C<B>); // Error, `C<B> == true` but I want it to be false

This code doesn't compile, because C<B> == true, because T::x is allowed even for nonstatic members in unevaluated contexts.

How do I make this compile? I.e., how can I make a concept that allows static members, but rejects nonstatic members?

---

&& !requires(T t) {t.x;} doesn't work, because it rejects static members too, because t.x is allowed for them.

&& !requires(T t) {&T::x;} doesn't work also, because for static members it forms a regular nonmember pointer.

Answer 1

T::x is a pointer-to-member in the case of non-static members, so it matches both static and non-static members.

You can exclude the pointer-to-member by using

#include <type_traits>

template <typename T>
concept C = requires {
    { T::x };
} && !std::is_member_pointer_v<decltype(&T::x)>;

Answer 2

Taking the address of a static member results in a free function pointer or a T* pointer; taking the address of a non-static member results in a member pointer (B::*). The former can match the pointer type, but the latter cannot. So you can:

template <typename T>
concept C = requires { [](auto*){}(&T::x); };

Demo

Answer 3

As was mentioned in other questions, B::x is a pointer to member of the type int B::*. Your concept can be based on the fact that such pointer cannot be cast to void* unlike normal pointers:

template <typename T>
concept C = requires { reinterpret_cast<void*>(&T::x); };

It works with all tested compilers: https://gcc.godbolt.org/z/nr9ecb564