cv qualifiers are always discarded on function types, they have no effect:
```
using ft = void();
using cft = const cft;

static_assert(std::is_same_v<ft, cft>); // passes
```
Hence, there are no type reference/pointers to const function. Function types are not object types, and cannot be assigned to, and their concrete representation cannot change at runtime: in a sense, they are always 'logically const' (and never 'logically volatile'). Since there is no reasonable semantics for runtime modification of a function's source code, having cv qualifiers on them seems superfluous.

With respect to this view, it seems logical to say that casting to a function type does not cast away const (but does cast away volatile). Conversely, casting from function type to void* could be viewed as casting away const. This boils down to 2 possible 'cv violations', but only one which could actually lead to a cv related UB without first encountering a strict aliasing UB:

```
void f();

// 1) volatile object pointer -> function pointer
volatile int i;
// bad: cast away volatile
auto* pf = reinterpret_cast<void(*)()>(&i);
// Ok
int const* pi = reinterpret_cast<int const*>(pf);

// UB: access to volatile object through non
// volatile lvalue. The first cast should be made
// illegal
int j = *pi;

// 2) function pointer -> non const object
//      pointer
void f();
// ok: we cast away const, but see below
int* pi = reinterpret_cast<int*>(&f);


```
This would seem like reasonable implementation, but is not mandated by the standard, and I think implementation are free to document how they support conversion to/from function pointer an object pointers.

I didn't go through explaining member function pointers; but they behave the same with respect to cv-ness. Although, their syntax is a different beast. Unlike function types, there exist no member function types, nor reference to member function types, so it is impossible to name or declare a  'const member function' type (the const qualifier appearing after the argument list is completely unrelated as it applies to the implicit 'this' and has no relationship on the constness of a pointed to member function.