What is the C++20 "addressing restriction" good for?

Question

According to cppreference.com, C++20 introduces the "addressing restriction" for standard library functions:

Addressing restriction

The behavior of a C++ program is unspecified (possibly ill-formed) if it explicitly or implicitly attempts to form a pointer, reference (for free functions and static member functions) or pointer-to-member (for non-static member functions) to a standard library function or an instantiation of a standard library function template, unless it is designated an addressable function (see below).

Following code was well-defined in C++17, but leads to unspecified behaviors and possibly fails to compile since C++20:

#include <cmath>
#include <memory>
 
int main()
{
    auto fptr0 = &std::betaf; // by unary operator&
    auto fptr1 = std::addressof(std::betal); // by std::addressof
    auto fptr2 = std::riemann_zetaf; // by function-to-pointer implicit conversion
    auto &fref = std::riemann_zetal; // forming a reference
}

Why was this introduced?

Especially with regard to backwards compatibility of the language, this seems to be a change that breaks a lot of existing code. What benefit does this provide that makes worth such a breaking change?

Answer 1

It was never "well-defined", it just happened to work on your/some/most implementation. (CppReference is wrong here)

Buried in the introduction of the library section of the standard is a description of what implementors must provide. For (say) std:: riemann_zetal, what's required is that there's a "thing" that can be called using function-call syntax, that takes a single float parameter, and returns something that can be converted to a float.

So, this is a perfectly legal implementation:

template <typename FP>
FP ZETA(FP f, int flags = 0) { /* code here */ } 

#define riemann_zetaf(x)  ZETA<float>(x, 23)

But, you can't take the address of riemann_zetaf because there is no such beast.

Note that even without the macro, you have no guarantee that addressof(riemann_zetal) would return a function that takes exactly one parameter. The only guarantee you have is that you can call it with one parameter.

If you need something that you can take the address of, define it yourself:

float riemann_zetal (float x) { return std::riemann_zetal(x); }

and then take the address of that instead.