Eu estou olhandostd:variant/std::visit doc aqui:http://en.cppreference.com/w/cpp/utility/variant/visit e também pesquisou bastante no Google tentando entender a mágica por trásstd::visit estd::variant.

Então, minha pergunta é a seguinte. No exemplo fornecido, ambos nolambda polimórfica e o "sobrecarregado" ocorre alguma "mágica" que permite extrair o tipo correto destd::variant.

Então, olhando para isso:

for (auto& v: vec) {
    std::visit(overloaded {
        [](auto arg) { std::cout << arg << ' '; },
        [](double arg) { std::cout << std::fixed << arg << ' '; },
        [](const std::string& arg) { std::cout << std::quoted(arg) << ' '; },
    }, v);
}

Para cadav, que é apenas uma variante, como a função lambda sobrecarregada correta está sendo chamada? Parece que há alguma lógica que precisa descobrir o tipo exato mantido pelo específicostd::variant, faça a transmissão e envie-a para a função adequada. Minha pergunta é como isso funciona? O mesmo acordo para isso:

    std::visit([](auto&& arg) {
        using T = std::decay_t<decltype(arg)>;
        if constexpr (std::is_same_v<T, int>)
            std::cout << "int with value " << arg << '\n';
        else if constexpr (std::is_same_v<T, long>)
            std::cout << "long with value " << arg << '\n';
        else if constexpr (std::is_same_v<T, double>)
            std::cout << "double with value " << arg << '\n';
        else if constexpr (std::is_same_v<T, std::string>)
            std::cout << "std::string with value " << std::quoted(arg) << '\n';
        else 
            static_assert(always_false<T>::value, "non-exhaustive visitor!");
    }, w);

Passamos lambda polimórficos para o visitante como o objeto que pode ser chamado ew é uma variante que pode conter int, long, double ou std :: string. Onde está a lógica que descobre o tipo certo parausing T = std::decay_t<decltype(arg)>; recuperar o tipo real da instância específica de uma variante?