R K's questions

Tenho o seguinte código:

#include <fmt/core.h>

template <typename ...T>
void func( const fmt::format_string<T...>& str, T&& ...args )
{
    auto _ = fmt::format( str, args... );
}

int main()
{
    func( "foo {}", 3 );
}

(Veja aqui um exemplo ao vivo)

Isso compila e funciona da maneira que eu espero se eu usar --std=c++17; no entanto, não compila se eu usar --std=c++20. Especificamente, eu recebo este erro:

consteval fmt::v10::basic_format_string<Char, Args>::basic_format_string(const S&) ... (com S= e um monte de akas) ... em expressão constante

Qual é a diferença em C++20 que faz com que isso quebre? Como posso consertar esse código para estar em conformidade com C++20?

Estou usando fmt v10.0.0.

Considere o seguinte código:

#include <memory>
#include <optional>

template <typename T>
constexpr T * arg_to_pointer(T & arg) noexcept {
    return std::addressof(arg);
}

int main() {
    std::optional<int> foo;

    auto * test = foo.transform(arg_to_pointer<int>).value_or(nullptr);
    //auto * test = foo.transform(std::addressof<int>).value_or(nullptr);

    return 0;
}

A linha que não está comentada (que passa um wrapper idiota std::addressofcomo parâmetro de função para std::optional::transform) compila e funciona perfeitamente. A linha comentada (aquela que tenta usar std::addressofdiretamente) não - recebo um erro indicando que a dedução do argumento do modelo falhou (exemplo ao vivo aqui usando o GCC 13.2, embora um comportamento semelhante seja observado com o Clang 16.0). Por que é isso? Qual é a diferença entre o padrão std::addressofe meu invólucro idiota?