C++ Academy · Aula

Tempo de vida de objetos

Saiba quando os objetos são criados e destruídos

Tempo de vida de objetos é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C++ Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C++ Academy inclui 4 aulas no total.

Quando os objetos nascem

O tempo de vida de um objeto começa depois que seu armazenamento é alocado e seu construtor termina. A partir desse momento, ele pode ser usado integralmente.

#include <iostream>

struct Widget {
    Widget() { std::cout << "born\n"; }
};

int main() {
    Widget w;   // constructor runs here
}

Quando os objetos morrem

O tempo de vida termina quando o destrutor é executado. Para um objeto da pilha, isso acontece na chave de fechamento do escopo.

#include <iostream>

struct Widget {
    ~Widget() { std::cout << "dies\n"; }
};

int main() {
    Widget w;
    std::cout << "alive\n";
}   // ~Widget runs here

Ordem de construção e destruição

Os objetos são destruídos na ordem inversa da construção. O último a ser criado é o primeiro a ser desmontado.

#include <iostream>

struct Tag {
    int id;
    Tag(int i) : id(i) { std::cout << "make " << id << "\n"; }
    ~Tag() { std::cout << "drop " << id << "\n"; }
};

int main() {
    Tag a(1);
    Tag b(2);   // dropped before a
}

Tempo de vida automático (na pilha)

Objetos automáticos vivem durante a execução do bloco que os contém. Esse é o modelo de tempo de vida mais comum e seguro.

Tempo de vida dinâmico (na memória dinâmica)

Objetos na memória dinâmica criados com new permanecem até que delete seja chamado — o tempo de vida deles é controlado por você, não pelo escopo.

#include <iostream>

struct Widget {
    ~Widget() { std::cout << "dies\n"; }
};

int main() {
    Widget* w = new Widget();
    std::cout << "still alive\n";
    delete w;   // destructor runs here
}

Tempo de vida estático

Objetos com armazenamento static vivem durante todo o programa. Uma variável estática local de uma função é construída uma vez, no primeiro uso.

#include <iostream>

int next() {
    static int counter = 0;   // built once
    return ++counter;
}

int main() {
    std::cout << next() << next() << next() << "\n";
}

Temporários

Um objeto temporário criado em uma expressão geralmente morre ao final da expressão completa (o ponto e vírgula).

#include <iostream>
#include <string>

int main() {
    std::cout << (std::string("a") + "b") << "\n";
}   // temporary string dies after this line

Os membros são construídos antes do corpo

Os objetos membros de uma classe são construídos antes da execução do corpo do construtor do objeto que os contém e destruídos depois do corpo do destrutor.

#include <iostream>
#include <string>

struct Engine { Engine() { std::cout << "engine\n"; } };
struct Car {
    Engine e;
    Car() { std::cout << "car\n"; }
};

int main() { Car c; }

Extensão do tempo de vida por referência const

Vincular um temporário a uma const& estende seu tempo de vida para corresponder ao da referência — uma regra útil do C++.

#include <iostream>
#include <string>

int main() {
    const std::string& s = std::string("hi");
    std::cout << s << "\n";   // s still valid
}

Uso após o fim do tempo de vida

Acessar um objeto depois que seu tempo de vida termina resulta em comportamento indefinido — o clássico erro de referência pendente ou de uso após liberação.

O tempo de vida impulsiona RAII

Como os destrutores são executados de forma determinística ao fim do tempo de vida, o C++ vincula a limpeza dos recursos ao tempo de vida — a base de RAII, abordada no próximo curso.

Verificação rápida

Teste sua compreensão do tempo de vida dos objetos.

Recapitulação

Você aprendeu como o tempo de vida de um objeto começa após a construção e termina com a destruição. Objetos automáticos seguem o escopo, objetos dinâmicos seguem new/delete, e objetos estáticos duram todo o programa. A destruição acontece na ordem inversa — a base de RAII.

Perguntas Frequentes

A aula “Tempo de vida de objetos” é grátis?

Sim — o texto completo de “Tempo de vida de objetos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C++ Academy, atualize para CoddyKit PRO. O curso de C++ Academy inclui 4 aulas no total.

O que vou aprender em “Tempo de vida de objetos”?

Saiba quando os objetos são criados e destruídos Você pratica C++ Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C++ Academy?

Nenhuma experiência prévia é necessária. C++ Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Tempo de vida de objetos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C++ Academy?

Sim. Cada aula de C++ Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C++ Academy