Carregando...
Carregando...
Carregando...
Considere a classe Aluno definida em C++ com a seguinte declaração de atributos e métodos. A informação que se pretende armazenar é o nome do aluno, e cada RA de aluno é um número único.
class Aluno {
private:
int ra;
std::string nome;
public:
Aluno();
Aluno(int ra, std::string nome);
void display() const;
int getRA() const;
std::string getNome() const;
void setRA(int ra);
void setNome(std::string nome);
};
Associe corretamente os métodos com suas explicações. Considere que nem todos os itens das colunas podem possuir associação ou podem possuir mais de uma correlação.
| | | | --- | --- | | Método | Explicação sobre o método | | I. Aluno() | A. Construtor que inicializa ra com -1 e nome com " ". | | II. Aluno(int ra, std::string nome) | B. Construtor que inicializa ra e nome com valores fornecidos. | | III. display() | C. Método que exibe os valores de ra e nome. | | IV. getRA() | D. Método que retorna o valor de ra. | | V. getNome() | E. Método que retorna o valor de nome. |
Assinale a alternativa que contém a associação correta.
Explique melhor esta questão
Abre o Tutor com o enunciado e as alternativas já no campo — você revisa e envia.
Esta questão foi verificada por um de nossos administradores.
Alternativa D - I-A, II-B, III-C, IV-D, V-E
A questão aborda conceitos fundamentais de Programação Orientada a Objetos (POO) em C++, focando na declaração e propósito de métodos de uma classe, especificamente construtores, métodos de acesso (getters) e métodos de exibição. Compreender a função de cada método é crucial para projetar e implementar classes de forma eficaz.
Em C++, uma classe define um tipo de objeto, especificando seus atributos (dados) e métodos (funções) que operam sobre esses dados.
get<NomeDoAtributo>().set<NomeDoAtributo>(valor). Embora existam na classe Aluno, não são o foco principal das associações nesta questão.display() ou print().O modificador const em um método como display() const, getRA() const ou getNome() const indica que o método não modificará o estado (os atributos) do objeto no qual é chamado. Isso é uma boa prática e aumenta a segurança e previsibilidade do código.
Vamos analisar cada associação proposta e compará-la com a declaração da classe Aluno e as explicações fornecidas:
| Método da Classe Aluno | Tipo de Método / Propósito Comum | Explicação Correspondente | Justificativa |
| :----------------------- | :-------------------------------- | :------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| I. Aluno() | Construtor padrão | A. Construtor que inicializa ra com -1 e nome com " ". | Este é um construtor sem argumentos. Sua finalidade comum é inicializar os membros da classe com valores padrão, como indicado na explicação A. |
| II. Aluno(int ra, std::string nome) | Construtor parametrizado | B. Construtor que inicializa ra e nome com valores fornecidos. | Este é um construtor que recebe dois argumentos, ra e nome. Sua finalidade é inicializar os membros com os valores passados como parâmetros, conforme a explicação B. |
| III. display() const | Método de exibição | C. Método que exibe os valores de ra e nome. | O nome display() sugere a função de mostrar algo. Como é um método da classe, é natural que ele exiba os dados internos do objeto (ra e nome), conforme a explicação C. O const indica que não modifica o objeto. |
| IV. getRA() const | Método de acesso (getter) | D. Método que retorna o valor de ra. | O prefixo get é uma convenção para métodos que retornam o valor de um atributo privado, neste caso, ra. A explicação D corresponde perfeitamente a essa função. O const indica que não modifica o objeto. |
| V. getNome() const | Método de acesso (getter) | E. Método que retorna o valor de nome. | Similar ao getRA(), o getNome() é um método getter que retorna o valor do atributo nome. A explicação E descreve precisamente essa funcionalidade. O const indica que não modifica o objeto. |
Comparando as associações corretas com as alternativas:
A correta associação dos métodos da classe Aluno com suas explicações reflete um entendimento fundamental dos princípios de encapsulamento e construção de objetos em C++. Os construtores (Aluno() e Aluno(int, std::string)) são usados para inicialização, enquanto os métodos get (getRA() e getNome()) servem para acessar os dados dos atributos e display() para apresentar o estado do objeto. A alternativa (D) agrupa todas as correspondências corretas, demonstrando uma compreensão clara do papel de cada componente da classe.
Alternativa D.