Início / coding / Perguntas / 79119005
Accepted
Igor G
Asked: 2024-10-24 01:12:23 +0800 CST

Posso ter um std::optional<T> se T não for construtível, nem copiável, nem móvel?

  • 772

O único requisito para o parâmetro de tipo do std::optional<T>modelo de classe mencionado em [optional.optional.general] p3 é que o tipo Tseja Destructible .

Suponha que eu tenha uma classe muito restritiva que atenda a esse requisito:

class R
{
public:
    ~R() = default;

    // This works thanks to guaranteed copy elision since C++17.
    static R create()
    {
        return R();
    }

    void do_something()
    {
    }

private:
    R() = default;

    R(const R&) = delete;
    R& operator=(const R&) = delete;

    R(R&&) = delete;
    R& operator=(R&&) = delete;
};

Mas essa classe ainda é perfeitamente utilizável:

void test_1()
{
    R           obj = R::create();
    obj.do_something();
}

A questão é: eu realmente posso ter um objeto utilizável do tipostd::optional<R> ? Por "utilizável" eu quero dizer um objeto que contém valor. Se sim, então como eu construo esse valor ali?

O código a seguir obviamente falha porque cada construtor de Ré inacessível:

void test_2()
{
    std::optional<R>        o(R::create());   // Error: no matching constructor
}

Link de exemplo do Godbolt .

Editar:

Não seria legal se std::optionalhouvesse um construtor que aceitasse um construtor ?

template <typename Builder>
optional::optional(disabmiguating_tag, Builder f)
 : my_internal_union(f())
{
}

com construtor apropriado, é my_internal_unionclaro...

c++

2 respostas

  1. Best Answer

    Você pode usar o tipo aa com um operator R:

    struct Builder {
    operator R() const { return R::create(); }
};

int main() {
    std::optional<R> o(Builder{});
}

    Veja um exemplo ao vivo no Compiler Explorer

    Isto funciona porque o Rque habita oé construído como se fosse uma chamada

    R(std::move(builder))

    ... onde builderhá uma referência ao que Builder{}passamos.

    operator Rretorna um pré-valor, então o retornado R::create()e o construído Rsão o mesmo objeto, em virtude da elisão de cópia garantida do C++17.

    • 17

  2. Eu sei que a questão é , mas aparentemente você pode usar esse truque:

    auto o = std::optional<int>{0}.transform([](int){ return R::create(); });

    onde criamos um opcional fictício não vazio (neste caso std::optional<int>) e usamos std::optional<T>::transformpara aplicar uma função em seu interno int; essa função retorna o Robjeto desejado via R::create(), que é criado no local na memória que std::optionalmantém reservado para sua carga útil.

    É válido por causa da elisão de cópia obrigatória do C++17 , porque o tipo de retorno lambda é R, que é o mesmo tipo que R::create(), que por sua vez é prvalue. Acho que isso significa que esse Robjeto é construído diretamente no lugar "final", que é dentro do std::optional<R> oque você está construindo.

    Provavelmente o cerne do truque é std::construct_ato , mas não acho que você possa usá-lo de fora, porque você não tem acesso ao std::optionalmembro onde a carga útil é armazenada, e você não pode acessá-lo via UB .value()porque isso é um UB vazio std::optional, e você não pode ter um não vazio std::optional<R>porque é exatamente isso que estamos discutindo!

    • 6

relate perguntas