Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

Duração de armazenamento automática e alocação dinâmica

Distingue a duração de armazenamento e o tempo de vida de um objeto das alocações separadas que os seus membros podem fazer, por exemplo para os caracteres de uma `std::string`.

Versão: ISO C++23; implementation support may vary

Sintaxe

T local{args...};                                      // Direct declaration; automatic in an ordinary block.
std::unique_ptr<T> owner = std::make_unique<T>(args...); // The local owner and its dynamically created T are separate objects.
owner.reset();                                         // Destroy the owned T; owner remains alive and becomes empty.

Em C++23, a duração de armazenamento indica durante quanto tempo a memória de um objeto pode permanecer disponível; o tempo de vida indica quando o próprio objeto existe. Uma variável normal de bloco declarada sem static, thread_local ou extern tem duração de armazenamento automática. Um objeto de tipo classe que já tenha sido construído é destruído à saída do bloco, incluindo durante o desenrolar da pilha devido a uma exceção. A regra da linguagem não obriga a colocar o objeto numa pilha física.

std::make_unique<Record>() cria um Record através de uma expressão new e devolve um std::unique_ptr<Record> que detém a sua propriedade exclusiva. No exemplo, owner tem duração de armazenamento automática, mas o Record que possui tem duração de armazenamento dinâmica e sobrevive à saída do bloco interior. owner.reset() destrói esse Record e liberta a respetiva memória; owner continua a existir, agora vazio. Não uses um ponteiro ou uma referência para aceder a um objeto destruído.

O membro Record::text tem a mesma duração de armazenamento que o Record que o contém. A memória dos caracteres é uma questão distinta: std::string pode obtê-la através do seu alocador quando necessário. A otimização de cadeias curtas (SSO) pode guardar os caracteres dentro do próprio objeto, mas o C++23 não exige nem SSO nem um limite de comprimento específico.

«Pilha ou heap» é uma expressão informal, não uma garantia de localização física. Prefere um objeto local declarado diretamente se o seu tempo de vida deve terminar com o bloco. Usa std::unique_ptr se um objeto separado, criado dinamicamente, precisar de um proprietário exclusivo.

Exemplos

#include <iostream>
#include <memory>
#include <string>

struct Record {
    std::string text;
};

int main() {
    std::unique_ptr<Record> owner;
    {
        Record local{"abc"};
        owner = std::make_unique<Record>();
        owner->text.assign(1000, 'x');
        std::cout << local.text.size() << ' ' << owner->text.size() << '\n';
    }
    std::cout << owner->text.size() << '\n';
    owner.reset();
    std::cout << (owner ? "owns a record" : "empty") << '\n';
}

Resultado

3 1000
1000
empty

Se a alocação e a escrita na consola forem bem-sucedidas, o programa apresenta os dois comprimentos, volta a apresentar o comprimento da cadeia do objeto gerido após sair do bloco interior e, por fim, escreve `empty` após `reset()`. O resultado não mostra endereços nem conta as alocações.

Lições relacionadas

  • C++ · Lição 22 · Avançado · Versão: 3

Fontes