0Pricing
C++ Academy · Aula

Polimorfismo estático

Evite o custo de chamadas virtuais

Polimorfismo estático é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 2 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.

Dois Tipos de Polimorfismo

O C++ oferece dois tipos de polimorfismo.

  • Dinâmico: funções virtuais resolvidas em tempo de execução por meio de uma tabela virtual
  • Estático: modelos e CRTP resolvidos em tempo de compilação

O polimorfismo estático troca flexibilidade por velocidade.

O Custo de virtual

Uma chamada virtual exige um salto indireto pela tabela virtual. Em geral, o compilador não consegue incorporá-la, impedindo muitas otimizações.

#include <iostream>

struct Shape {
    virtual double area() const = 0;
    virtual ~Shape() = default;
};

struct Square : Shape {
    double s;
    Square(double x) : s(x) {}
    double area() const override { return s * s; }
};

int main() {
    Shape* p = new Square(3);
    std::cout << p->area() << "\n";
    delete p;
    return 0;
}

Despacho Estático com CRTP

Com CRTP, a classe base chama diretamente o método da classe derivada por meio de uma conversão em tempo de compilação, permitindo que o compilador incorpore tudo.

#include <iostream>

template <typename T>
struct Shape {
    double area() const { return static_cast<const T*>(this)->area(); }
};

struct Square : Shape<Square> {
    double s;
    Square(double x) : s(x) {}
    double area() const { return s * s; }
};

int main() {
    Square sq(3);
    std::cout << sq.area() << "\n";
    return 0;
}

Nomeação do Encaminhador

Quando a classe base e a derivada definem ambas area, dê ao encaminhador da classe base um nome distinto, como compute, para que ele chame inequivocamente a implementação da classe derivada.

#include <iostream>

template <typename T>
struct Shape {
    double compute() const { return static_cast<const T*>(this)->area(); }
};

struct Circle : Shape<Circle> {
    double r;
    Circle(double x) : r(x) {}
    double area() const { return 3.14159 * r * r; }
};

int main() {
    Circle c(2);
    std::cout << c.compute() << "\n";
    return 0;
}

Modelos como Polimorfismo Estático

Modelos de função simples também são polimorfismo estático: o mesmo código funciona para qualquer tipo que forneça a interface necessária (tipagem estrutural em tempo de compilação).

#include <iostream>

struct Dog { void speak() const { std::cout << "Woof\n"; } };
struct Cat { void speak() const { std::cout << "Meow\n"; } };

template <typename Animal>
void make_speak(const Animal& a) { a.speak(); }

int main() {
    make_speak(Dog{});
    make_speak(Cat{});
    return 0;
}

Quando o Tipo é Conhecido

A polimorfia estática se aplica somente quando o tipo concreto é conhecido em tempo de compilação. Se precisar armazenar objetos heterogêneos em um único contêiner e escolher o comportamento em tempo de execução, você ainda precisará de funções virtuais.

Sem Contêineres Heterogêneos

Você não pode colocar Shape<Square> e Shape<Circle> no mesmo std::vector como uma base comum, pois são tipos não relacionados. Essa é a limitação central da polimorfia estática.

Benefício de Desempenho

Ao inserir a chamada despachada, o compilador pode propagar constantes e eliminar completamente o custo das chamadas de função. Em laços compactos sobre um único tipo conhecido, a polimorfia estática pode ser substancialmente mais rápida.

#include <iostream>

template <typename T>
struct Op {
    int apply(int x) const { return static_cast<const T*>(this)->apply(x); }
};

struct Doubler : Op<Doubler> {
    int apply(int x) const { return x * 2; }
};

int main() {
    Doubler d;
    int sum = 0;
    for (int i = 0; i < 5; ++i) sum += d.apply(i);
    std::cout << sum << "\n";
    return 0;
}

Combinando Ambos

Você pode usar CRTP para o caminho crítico e um encapsulador virtual simples quando for necessário apagar o tipo. Assim, você obtém velocidade onde ela importa e flexibilidade onde é necessária.

Verificações Estáticas da Interface

Se uma classe derivada esquecer de implementar o método exigido, o erro aparecerá em tempo de compilação, quando o encaminhador da base for instanciado, e não em tempo de execução.

#include <iostream>

template <typename T>
struct Greeter {
    void greet() const { static_cast<const T*>(this)->hello(); }
};

struct English : Greeter<English> {
    void hello() const { std::cout << "Hello\n"; }
};

int main() {
    English{}.greet();
    return 0;
}

Escolhendo a Ferramenta Certa

Use polimorfia estática quando:

  • O tipo é conhecido em tempo de compilação
  • O desempenho é fundamental
  • Você não precisa de um tipo base comum em tempo de execução

Caso contrário, prefira funções virtuais por sua clareza e flexibilidade.

Verificação Rápida

Escolha a principal compensação da polimorfia estática.

Recapitulação

Você comparou a polimorfia estática e a dinâmica.

  • Virtual = despacho em tempo de execução, tabela virtual, contêineres heterogêneos
  • CRTP/modelos = despacho em tempo de compilação, possibilidade de inserção, mais rápido
  • A polimorfia estática precisa que o tipo seja conhecido em tempo de compilação
  • Escolha com base nas necessidades de flexibilidade versus desempenho

Perguntas Frequentes

A aula “Polimorfismo estático” é grátis?

Sim — o texto completo de “Polimorfismo estático” é 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 “Polimorfismo estático”?

Evite o custo de chamadas virtuais 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 2 de 4.

Quanto tempo leva a aula “Polimorfismo estático”?

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

  1. O padrão CRTP
  2. Polimorfismo estático
  3. Mixins com CRTP
  4. Quando usar CRTP
← Voltar para C++ Academy