C++ Academy · Aula

Guardas de escopo

Execute a limpeza ao sair do escopo

Aula 4 de 413 etapas

Guardas de escopo é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 4 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.

O que é um guardião de escopo

Um guardião de escopo é um objeto RAII cuja única função é executar uma ação de limpeza quando sai do escopo — mesmo em caso de retorno antecipado ou exceção.

O problema que ele resolve

Sem um guardião, é fácil esquecer a limpeza depois de um return antecipado ou de um throw. Um guardião de escopo torna a ação automática.

lock_guard: um guardião de escopo padrão

std::lock_guard bloqueia um objeto de exclusão mútua durante a construção e o desbloqueia durante a destruição — um guardião de escopo integrado para bloqueios.

#include <mutex>

std::mutex m;

void critical() {
    std::lock_guard<std::mutex> lk(m);   // locked
    // ... work ...
}                                        // unlocked automatically

Um guardião criado manualmente

Você pode escrever um guardião que armazene uma função e a chame no destrutor.

#include <iostream>
#include <functional>

class ScopeGuard {
    std::function<void()> fn;
public:
    ScopeGuard(std::function<void()> f) : fn(std::move(f)) {}
    ~ScopeGuard() { fn(); }
};

int main() {
    ScopeGuard g([] { std::cout << "cleanup\n"; });
    std::cout << "work\n";
}

A limpeza é executada no retorno antecipado

Como o destrutor é acionado ao sair do escopo, a ação do guardião é executada independentemente de como a função termina.

#include <iostream>
#include <functional>

class ScopeGuard {
    std::function<void()> fn;
public:
    ScopeGuard(std::function<void()> f) : fn(std::move(f)) {}
    ~ScopeGuard() { fn(); }
};

void run(bool stop) {
    ScopeGuard g([] { std::cout << "always cleaned\n"; });
    if (stop) return;
}

int main() { run(true); }

A limpeza é executada em caso de exceção

Se uma exceção percorrer o escopo durante o desenrolamento, o destrutor do guardião ainda será executado, liberando o recurso com segurança.

Cancelando um guardião

Às vezes, você deseja ignorar a limpeza (a operação foi bem-sucedida). Guardiões reais oferecem um dismiss() para desativar a ação.

#include <iostream>
#include <functional>

class ScopeGuard {
    std::function<void()> fn;
    bool active = true;
public:
    ScopeGuard(std::function<void()> f) : fn(std::move(f)) {}
    void dismiss() { active = false; }
    ~ScopeGuard() { if (active) fn(); }
};

int main() {
    ScopeGuard g([] { std::cout << "rollback\n"; });
    g.dismiss();   // success: no rollback
}

Use para reversão

Os guardiões de escopo são excelentes para código transacional: registre uma ação de reversão, realize o trabalho e então descarte o guardião após o sucesso.

Guardiões são somente-móveis

Um guardião não deve ser copiado — a cópia executaria a ação duas vezes. Torne os guardiões somente-móveis ou não copiáveis.

Auxiliares padrão e de bibliotecas

std::scoped_lock protege vários bloqueios, e bibliotecas como GSL fornecem finally. Muitas bases de código incluem um pequeno utilitário ScopeGuard.

Prefira tipos RAII específicos

Quando existir um tipo RAII dedicado (um guardião de bloqueio, um ponteiro exclusivo ou um fluxo de arquivo), prefira-o. Use um guardião de escopo genérico somente para limpezas pontuais sem um encapsulamento natural.

Verificação rápida

Teste sua compreensão dos guardiões de escopo.

Responda na aula interativa

Recapitulação

Você aprendeu que um guardião de escopo executa a limpeza automaticamente ao sair do escopo por meio de RAII. Ele lida com retornos antecipados e exceções, permite reversões com um dismiss() e deve ser somente-móvel. Prefira tipos RAII dedicados quando eles existirem.

Grátis para começar

Aprenda C++ com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 51
Aulas: 203

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Guardas de escopo” é grátis?

Sim — o texto completo de “Guardas de escopo” é 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 “Guardas de escopo”?

Execute a limpeza ao sair do escopo 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 4 de 4.

Quanto tempo leva a aula “Guardas de escopo”?

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