#include <iostream>
using namespace std;
class Base {
public:
    virtual void f() { cout << "Base" << endl; }
};
class Derivada : public Base {
public:
    void f() override { cout << "Derivada" << endl; }
    void g() { cout << "Método exclusivo da derivada" << endl; }
};
int main() {
    Base* b = new Derivada();
    Derivada* d = (Derivada*)b;
    d->g();
}
O que o código acima imprime?
a) Base
b) Método exclusivo
c) Derivada
d) Nada.

Passo 1

O enunciado pergunta qual a saída (o que é impresso) pelo programa C++ dado. Informações relevantes do enunciado (extraídas diretamente do código fornecido):
  • Existe a classe Base que tem um método virtual f() que imprime "Base".
  • Existe a classe Derivada que herda publicamente de Base, sobrescreve f() com override e imprime "Derivada", e possui um método g() que imprime "Método exclusivo da derivada".
  • No main():
    • É criada dinamicamente uma instância com new Derivada() e o ponteiro retornado é armazenado em Base* b.
    • Em seguida há um cast: Derivada* d = (Derivada*)b; (cast em estilo C).
    • Finalmente chama-se d->g();.
  • As alternativas oferecidas são:
    • a) Base
    • b) Método exclusivo
    • c) Derivada
    • d) Nada

Passo 2

Entender o que significa Base* b = new Derivada();. Explicação didática e sem pular etapas:
  • new Derivada() cria um objeto cujo tipo dinâmico (o tipo real da instância em tempo de execução) é Derivada.
  • O ponteiro b tem tipo estático Base*, isto é, a variável que armazena o endereço é do tipo ponteiro para Base.
  • Em C++ é perfeitamente normal armazenar o endereço de um objeto derivado em um ponteiro para a classe base (polimorfismo). Nesse caso, b aponta para um objeto Derivada, mesmo que a variável seja do tipo Base*.
  • Consequência prática: o objeto alocado tem a parte da classe Base e também a parte específica de Derivada.

Passo 3

Explicar o cast Derivada* d = (Derivada*)b; e as implicações:
  • O cast em estilo C (Derivada*)b tenta converter o ponteiro b (tipo Base*) para Derivada*.
  • Em C++ moderno o comportamento recomendado para downcast seguro é dynamic_cast<Derivada*>(b) (que verifica em tempo de execução se b aponta realmente para um Derivada quando a classe é polimórfica). O cast em C-style pode equivaler a um static_cast ou a um reinterpret_cast dependendo do caso — e pode ser perigoso se usado de forma incorreta.
  • No entanto, aqui sabemos pelo código que o objeto real criado com new é de fato um Derivada. Assim, o cast resulta em um ponteiro d que aponta para o mesmo objeto Derivada. Nesse cenário particular, o cast é efetivamente seguro e definido (não causa comportamento indefinido) porque o objeto é realmente da classe Derivada.
  • Resumindo: após o cast, d aponta para a instância de Derivada que foi criada.

Passo 4

Explicar o que acontece ao chamar d->g();:
  • g() é um método que só existe na classe Derivada (não está presente em Base).
  • Como d é um Derivada* apontando para um objeto Derivada, a chamada d->g() é válida e invoca o método definido em Derivada.
  • O corpo de g() faz cout << "Método exclusivo da derivada" << endl;, então a chamada imprime exatamente essa sequência de caracteres seguida de nova linha.
  • Nota didática: se b tivesse apontado para um objeto que realmente fosse apenas Base (por exemplo, new Base()), o cast para Derivada* seria inválido e usar d->g() causaria comportamento indefinido (possível crash). Por isso o dynamic_cast com checagem é mais seguro quando a origem não é garantida.

Passo 5

Esclarecer por que as outras possíveis saídas não ocorrem:
  • Alternativa (a) "Base" corresponderia a uma chamada de f() que resolvesse para Base. O código não chama f() em lugar algum, então "Base" não é impresso.
  • Alternativa (c) "Derivada" seria impressa se o programa chamasse f() em um ponteiro para Base que referisse um objeto Derivada (por causa do virtual e do override), mas novamente f() não é chamado no programa.
  • Alternativa (d) "Nada" significaria que nada é impresso. Não é o caso porque d->g() imprime uma string com cout.
  • Portanto a saída real é a impressão feita por g(): "Método exclusivo da derivada".

Resposta

b) Método exclusivo da derivada

Exercícios relacionados