HolyBlackCat's questions

Considere o seguinte código:

#include <iostream>
#include <string>

union U
{
    std::string s;

    U()
    {
        new(&s) std::string;
    }

    void Set(std::string new_s)
    {
        s.~basic_string();
        new(&s) std::string(std::move(new_s));
    }

    ~U()
    {
        s.~basic_string();
    }
};

int main()
{
    U u;
    u.Set("foo");
    std::cout << u.s << '\n'; // Do I need `std::launder` here?
}

Eu sei que se eu usasse um array de bytes em vez de uma união, eu teria que std::launder(&s)acessar a string. Mas eu preciso disso aqui?

A resposta do senso comum parece ser "não", mas então onde está a bênção padrão unionde não precisar std::launder?

Estou lendo a documentação em std::expected::operator==, e aparentemente não é amigável ao SFINAE. Em vez de "não participa da resolução de sobrecarga se [os tipos não forem eq-comparáveis]", diz "o programa está malformado [nesse caso]".

E de fato:

#include <concepts>
#include <expected>

struct A {};

static_assert(!std::equality_comparable<std::expected<A, A>>);

Esta afirmação falha no MSVC e no Clang com libc++ e causa um erro grave no Clang com MSVC STL.

Mas por que não é compatível com SFINAE?

std::expected<T,U>requer que ambos Te Usejam completos de qualquer forma, então aparentemente nada impede que todas as operações nele sejam compatíveis com SFINAE.

Eu tenho uma string C ( const char *) e quero convertê-la em um intervalo C++ 20 (a forward_range) para aplicar alguns algoritmos padrão a ela.

Não quero usar std::string_viewporque não quero calcular seu comprimento (a string pode ser longa e só me importo com os primeiros caracteres). Felizmente, a forward_rangenão precisa saber seu comprimento com antecedência.

Como eu faço isso? Eu poderia escrever um iterador personalizado, mas espero que haja uma maneira mais fácil.