Início / coding / Perguntas / 79552712
Accepted
Max
Asked: 2025-04-03 18:48:34 +0800 CST

start_lifetime_as proíbe o acesso ao buffer original?

  • 772

Considere este trecho de código C++23:

struct MyData {
    std::int32_t value;
};

std::vector<char> read_from_net();
void send_over_net(std::vector<char>&);

...

std::vector<char> buffer = read_from_net();

std::start_lifetime_as<MyData>(buffer.data())->value = 222; // (1)

send_over_net(buffer); // (2)

Assumindo que todos os requisitos para iniciar a vida útil de MyDataat buffer.data()sejam respeitados:

  1. Existe alguma UB neste código? Começar o tempo de vida assim e modificar o campo é bem definido?
  2. Posso acessar o buffer original como caracteres (2)sem UB, considerando que isso start_lifetime_asencerrou a vida útil do objeto anterior e iniciou uma nova?
  3. Ou start_lifetime_asapenas inicia outra vida, mas também preserva a anterior?
  4. Devo usar std::launder(buffer.data())[0]o método de acesso ao buffer original como uma matriz de caracteres depois (2)?
c++

2 respostas

  1. Best Answer

    TL;DR É um comportamento indefinido.

    Parabéns por pensar nisso.

    Os pontos principais são que

    1. reutilizar o armazenamento para criar um novo objeto encerra a vida útil dos objetos antigos 1

      https://eel.is/c++draft/basic.life#2.5

    2. aliasing through charé permitido

      https://eel.is/c++draft/basic.lval#11.3

      • mas você tem que ter um ponteiro validamente derivado, o que você não tem, porque

    3. início da vida útil de um novo objeto de tipo diferente termina a validade de todos os ponteiros para qualquer parte desse objeto

      https://eel.is/c++draft/basic.life#10

    4. Você pode obter um novo ponteiro válido por meio std::launderde um ponteiro expirado existente ou por meio reinterpret_castde um ponteiro válido para o novo objeto (o ponteiro retornado de std::start_lifetime_as).

      • Com std::launder, o ponteiro retornado é válido, mas não restaura a validade de outros ponteiros expirados (como os que estão dentro std::vectordele). Ai.

        https://eel.is/c++draft/ptr.launder#5

    1 A única regra que pode ser interpretada para permitir isso aparece aqui, na linguagem relativamente nova em torno

    reutilizado por um objeto que não está aninhado dentro

    Se o novo objeto estiver "aninhado dentro" dos objetos antigos de propriedade de std::array, então seu tempo de vida continua, deixando tudo ok.

    https://eel.is/c++draft/intro.object#4

    Mas essa permissão se aplica apenas a unsigned chare std::byte, não simplesmente a char, então não ajuda aqui.

    https://eel.is/c++draft/intro.object#3

    • 7

    • 1. Existe alguma UB neste código? O início do tempo de vida é assim e o campo de modificação está bem definido?
      Supondo que você esteja cumprindo todos os requisitos, não deve haver nenhum comportamento indefinido.
      if buffer.data()aponta para uma região de memória que satisfaça os requisitos de tamanho e alinhamento de MyData, o std::start_lifetime_asiniciará com sucesso o tempo de vida de um MyDataobjeto naquele local. No seu snippet, depois de iniciar o tempo de vida de MyDataem buffer.data(), escrever em seu membro (ou seja, definir valor = 222) é uma operação definida.

    • 2. e 3. Sim, você pode acessar o original bufferem char(2) sem comportamento indefinido.

    • 4. Em C++ 17 std::launder pode ser usado para obter um ponteiro para um objeto que pode ter sido realocado. Se você quiser otimizar algo, pode usá-lo. Do meu ponto de vista, você não precisa dele porque já tem um ponteiro válido de buffer.data().

    • 1

relate perguntas