#include <iostream>
using namespace std;
class Pessoa {
public:
    string nome;
};
class Estudante : public Pessoa {
public:
    int matricula;
};
int main() {
    Estudante e;
    e.nome = "Ana";
    e.matricula = 123;
    cout << e.nome << " - " << e.matricula;
}
Qual será a saída?
a) Erro de compilação.
b) Ana - 123
c) 0-0
d) Apenas “Ana”.
e) Apenas “123”.

Passo 1

O enunciado pergunta qual será a saída do programa C++ dado e fornece as alternativas:
a) Erro de compilação.
b) Ana - 123
c) 0-0
d) Apenas “Ana”.
e) Apenas “123”.
Informações relevantes extraídas do código (copiadas/interpretadas do enunciado):
  • Há uma classe Pessoa com um membro público nome do tipo string.
  • Há uma classe Estudante que faz public inheritance de Pessoa e adiciona um membro público matricula do tipo int.
  • No main() é criado um objeto Estudante chamado e.
  • Em seguida há atribuições: e.nome = "Ana"; e e.matricula = 123;.
  • Depois imprime-se com cout << e.nome << " - " << e.matricula;.
  • O programa inclui <iostream> e usa using namespace std;.

Passo 2

Entendendo o que significa os membros serem public e a herança public: quando uma classe é herdada com public, os membros public da classe base permanecem acessíveis como public na classe derivada. Ou seja, Estudante “herda” o campo nome de Pessoa e esse campo pode ser acessado diretamente em e.nome. Aqui tudo é público, então não há problemas de acesso. Isso responde se alguma tentativa de leitura/escrita fosse proibida — não é o caso.

Passo 3

O que acontece na criação do objeto Estudante e;: o compilador gera um construtor padrão (implícito) que inicializa os membros da forma normal para tipos de cada membro:
  • Para std::string (tipo de nome): o construtor padrão do std::string cria uma string vazia (ou seja, nome começa como "").
  • Para int (tipo de matricula): antes de qualquer atribuição poderia ficar com valor indeterminado, mas isso só importaria se tentássemos usar matricula antes de atribuí-la. No código, nós logo atribuímos um valor a matricula, então isso não causa problema.
Obs.: o enunciado pediu para supor que a questão está bem formulada — portanto assumimos que o uso de string é válido (os includes necessários estão presentes ou disponíveis).

Passo 4

Atribuições executadas no main():
  • e.nome = "Ana"; — aqui um literal de string em C++ é atribuído ao std::string membro nome. Após essa linha, e.nome contém exatamente a sequência de caracteres Ana.
  • e.matricula = 123; — aqui atribuimos o inteiro 123 ao campo matricula. Após essa linha, e.matricula vale 123.
Expliquei isso porque às vezes na prova alguém confunde inicialização com atribuição; aqui ambos são atribuídos explicitamente antes do uso.

Passo 5

Como funciona o cout << e.nome << " - " << e.matricula;:
  • operator<< do ostream imprime e.nome (que é a string Ana).
  • Em seguida imprime o literal de string " - " que é exatamente um espaço, um hífen e um espaço.
  • Por fim imprime o inteiro e.matricula que vale 123.
  • Não há quebras de linha automáticas — o código imprime os três pedaços na sequência na mesma linha.
Portanto a sequência impressa será: primeiro Ana, depois -, depois 123.

Passo 6

Verificando possíveis razões para erro de compilação ou saída diferente:
  • Não há erro de sintaxe visível: declarações de classes, herança, criação de objeto e uso de cout estão corretos.
  • Não há acesso a membros privados (todos são public).
  • Os tipos usados (string e int) são compatíveis com as operações realizadas.
    Logo, a alternativa (a) “Erro de compilação” pode ser descartada.

Passo 7

Juntando tudo: o programa imprime exatamente a string formada ao concatenar os três pedaços do passo anterior. Assim a saída exibida no terminal será:
Ana - 123
(exatamente nessa ordem, sem quebra de linha final obrigatória no código dado).

Resposta

b) Ana - 123

Exercícios relacionados