#include <iostream>
using namespace std;
class Base {
protected:
    int valor = 50;
};
class Derivada : public Base {
public:
    int dobrar() { return valor * 2; }
};
int main() {
    Derivada d;
    cout << d.dobrar();
}
O que o código acima faz?
a)Gerar erro de compilação, pois valor é protegido.
b)Compilar e imprimir 100.
c)Imprimir 50.
d)Gerar erro de tempo de execução.
e)Não compilar, pois falta construtor.

Passo 1

O enunciado pergunta: “O que o código acima faz?” e dá opções de resposta (a) a (e). Informações relevantes do código que preciso usar para decidir a resposta:
  • Existe uma classe Base que declara um membro de dados valor inicializado com 50 e com especificador de acesso protected.
  • Existe uma classe Derivada que herda publicamente de Base (class Derivada : public Base) e define um método dobrar() que retorna valor * 2.
  • Na função main() é criado um objeto Derivada d; e é executado cout << d.dobrar();.
  • As opções incluem possíveis erros de compilação, execução ou o que será impresso.

Passo 2

Entender o que significa protected em C++:
  • protected é um especificador de acesso que permite que a própria classe e classes derivadas acessem o membro, mas impede o acesso direto a partir de código que não seja membro (por exemplo, de main()).
  • Em outras palavras: membros protected são inacessíveis para código externo, mas são acessíveis dentro das subclasses.
    Exemplo rápido mental: se dentro de Derivada eu escrevo valor, isso é permitido; se em main() eu tentar d.valor, isso NÃO é permitido e causaria erro de compilação.

Passo 3

Analisar a herança class Derivada : public Base:
  • public na herança significa que os níveis de acesso da classe-base se mantêm em relação ao exterior: public continua public, protected continua protected (relativamente à classe derivada e código externo).
  • O ponto importante aqui é que Derivada tem acesso aos membros protected de Base. Portanto, dentro de Derivada, usar valor é legal.

Passo 4

Analisar o método dobrar():
  • O método está declarado como int dobrar() { return valor * 2; }.
  • Ele acessa valor (membro protected da classe-base) e retorna o produto por 2.
  • valor vale 50 (inicialização na declaração em Base), então a expressão valor * 2 resulta em 100 (operacão inteira simples).

Passo 5

Verificar a criação do objeto e chamada do método em main():
  • Derivada d; usa o construtor padrão. Como não foi escrito um construtor, o compilador gera um construtor padrão implícito — então não há erro por “falta de construtor”.
  • cout << d.dobrar(); chama o método dobrar() no objeto d, que, conforme Passo 4, retorna 100. cout então envia esse valor para a saída padrão.

Passo 6

Verificar potenciais erros de compilação ou execução mencionados nas opções:
  • Opção (a): “Gerar erro de compilação, pois valor é protegido.” — incorreto, porque valor é acessado dentro da classe derivada Derivada, o que é permitido para protected.
  • Opção (d): “Gerar erro de tempo de execução.” — incorreto, não há operação indefinida ou divisão por zero; é só uma multiplicação de inteiros.
  • Opção (e): “Não compilar, pois falta construtor.” — incorreto, o compilador fornece um construtor padrão implícito quando não há um declarado.
  • Opção (c): “Imprimir 50.” — incorreto, pois o método retorna valor * 2, logo 100, não 50.

Passo 7

Resumo lógico do fluxo: o membro valor inicializa com 50 na classe-base, a classe derivada tem acesso a esse valor (por ser protected), o método dobrar() devolve 50 * 2 = 100, e cout imprime esse valor. Não há erros de compilação nem de execução nesse trecho.

Resposta

b) Compilar e imprimir 100.

Exercícios relacionados