Does const pointer-to-member default to pointing to an int?

While playing with pointers-to-member I encountered a behaviour that seems slightly inconsistent and somewhat counterintuitive to me. Consider the following dummy structure:

struct foo {
    int x;
    double d;
};

and the following main():

int main() {
    int foo::* ptr = &foo::x;
    double foo::* ptr2 = &foo::d;
}

Here we have nothing unusual - two pointers to const members. The code compiles fine.

What caught my attention is that when we add const, the situation changes a little bit. Consider the following code:

int main() {
    // no int or double after const
    const foo::* ptr = &foo::x;
}

The code compiles fine on GCC 8.2.0¹. Notice that I did not specify to what data type the pointer will point.

However, this code:

int main() {
    // notice the only change - "d" instead of "x"
    const foo::* ptr = &foo::d;
}

fails to compile with the following error:

error: cannot convert 'double foo::*' to 'const int foo::*' in initialization const foo::* ptr = &foo::d;

Which is interesting - it suggests that, by default, a const pointer-to-member is implicitely declared to point to some int member. Is this correct, standard behaviour?

It's worth noting that if we drop the const, both of these lines produce errors:

int main() {
    foo::* ptr1 = &foo::x;
    foo::* ptr2 = &foo::d;
}

in the forms of:

error: expected unqualified-id before '*' token

error: 'ptr1' | 'ptr2' was not declared in this scope

So the question is - does the standard specify that const pointer-to-member implicitly points to int if we do not specify otherwise, or is it a non-standard behaviour? (either a GCC extension or GCC bug).

¹EDIT: I am using GCC from MinGW - this particular build.