Vamos lá pessoal. Vamos resolver cada item por vez.

Antes de mais nada, você tem que saber que nessa questão nós temos um diagrama de classe. Nesse diagrama cada classe filha aponta para sua classe mãe.

1. Qual é a classe raiz?

A classe raiz é a classe de maior hierarquia que da origem a todas as outras classes. Nesse caso, todas as classes são derivas diretas ou indiretas de

Passo 2

2. Quais as classes ancestrais de

Uma classe é considerada ancestral quando ela é uma classe “avó”. Ou seja, quando sua classe filha gera uma nova classe filha. O termo “classe avó” não costuma ser utilizado, sempre que uma classe é de uma hierarquia mais alta que a mãe, ela é considerada uma classe ancestral.

Do ponto de vista da classe os seus ancestrais são a “classe avó” e a “classe bisavó”

Passo 3

3. O que significa as setas duplas saindo de e

No diagrama de classe, cada classe aponta para sua mãe. Em alguns casos uma única classe pode ser derivada de várias outras, isso é o que chamamos de herança múltipla!

As classes e são exemplos de classes que efetuaram herança múltipla.

Bora lá, galera.

Essa é uma questão de hierarquia de classes. A questão fornece a classe que é herdada pela classe que depois é herdada pela classe .

A questão já entregou pra gente a classe ingresso prontinha, com um atributo para armazenar o valor do ingresso, um método construtor para inicializar o atributo, e o método .

Um detalhe, é que na classe nós temos um método virtual . É importante que esse método seja virtual, pois em cada classe o valor do ingresso irá mudar, e a frase que acompanha o método também, ou seja, em cada classe vamos executar polimorfismo.

Mas antes de tudo, vamos escrever o código do enunciado no nosso programa

Belezinha, agora vamos desenvolver a classe . Primeiro vamos efetuar a herança.

E prontinho. Agora temos acesso a todos os métodos e atributos da classe mãe.

O ingresso VIP possui um valor adicional, então vamos criar um atributo para conter esse valor.

Em seguida vamos desenvolver o construtor da classe . Uma ideia legal é a gente invocar o construtor da classe mãe.

Então definimos o construtor da classe mãe para receber os parâmetros e , e em seguida passamos o parâmetro pro construtor da classe mãe. Dentro das chaves, vamos inicializar o atributo e atualizar o valor do ingresso

Beleza, agora vamos dar uma olhada no método . Usando polimorfismo, vamos reescrever o método imprime valor para atualizar a mensagem impressa:

E terminamos a classe .

Vamos começar efetuando a herança. A classe é filha da classe :

Essa classe possui um novo atributo que representa mais um valor adicional .

Show, em seguida vamos cuidar do construtor da classe . Precisamos receber os três parâmetros , e . Em seguida, vamos passar os parâmetros e para o construtor da classe

E é aqui que a magica acontece! O construtor da classe chama o construtor da classe que em seguida chama o construtor da classe 🤯. Essa reação em cadeia deve ser considerada na hora de desenvolver os construtores.

Leve em consideração que o construtor da classe VIP já faz a inicialização do atributo herdado , e também já atualiza o atributo . Então, o que precisamos fazer é inicializar o atributo , e fazer uma nova atualização no atributo com o valor adicional do camarote

E pra finalizar a classe é só a gente

E assim finalizamos a classe .

Vamos nessa!

A única diferença entre os dois códigos é que na linha 06 o Código A utiliza a palavra chave e o código B não utiliza

Isso quer dizer que no código A o método é um método virtual, e no código B não.

Os métodos virtuais são uma forma de mudar o comportamento de um método que vai sofrer polimorfismo.

A mudança de comportamento acontece quando existe iterações entre a classe mãe e a classe filha de uma das duas formas:

1. Quando um método que sofreu polimorfismo na classe filha é executando dentro de outro método da classe mãe.
2. Quando usamos ponteiros da classe mãe para armazenar o endereço de um objeto da classe filha.

O informa ao C++ que ele sempre deve olhar pra classe filha em busca de polimorfismos. Caso o virtual não esteja presente, quando a gente executar um dos dois casos acima, a versão “polimorfada” será ignorada, e a versão da classe mãe será executada.

De certa forma é como se quando a gente não usa o o polimorfismo só tem validade dentro da classe Filha, e métodos e ponteiro da classe mãe não vão levar o polimorfismo em conta.

Para ficar mais claro. Vamos executar os códigos A e B

Primeiro vamos executar o Código A que utiliza o

Então vamos fazer o seguinte. Dentro da vamos declarar um ponteiro para classe chamdo , e um objeto da classe chamado .

Em seguida, vamos guardar o endereço de no ponteiro

E pra terminar vamos executar o método duas vezes. A primeira vez vamos executar através do ponteiro, e a segunda vez vamos executar através do objeto.

Usando o os resultados são iguais! Nos dois casos a versão “polimorfada” é executada. Isso acontece pois o informa ao C++ que o método pode sofrer polimorfismo, então quando usamos um ponteiro da classe mãe para apontar para a classe filha o C++ está ciente que deve buscar por um polimorfismo do método .

E agora vamos executar o Código B que não utiliza o

Quando não usamos o os resultados são diferentes! A chamada através de ponteiro executa a versão da classe mãe, e a chamada através de objeto executa a versão “polimorfada” da classe filha.

Isso acontece pois, sem o , não existe nenhum aviso da possibilidade de polimorfismo, então, o C++ não se preocupa em conferir se existe polimorfismo do método , e simplesmente executa a versão da classe mãe.

Já quando utilizamos diretamente o objeto da classe filha, nós conseguimos executar a versão com polimorfismo, pois estamos fazendo uma chamada direta a esse objeto, enquanto o ponteiro faz uma chamada indireta.

E aí, pessoal, vamos resolver a questão

Essa é uma questão de herança dupla! Vamos desenvolver uma classe chamada com base em duas classes mães e .

A classe vai herdar duas classes, e adicionar dois atributos do tipo string e um novo método. Então, vamos escrever o cabeçalho do código incluindo

Também vamos precisar escrever o código de cada uma das classes mães dentro do nosso código. Vamos aproveitar para entender essas classes enquanto digitamos elas no nosso código.

A classe possui dois atributos protegidos: e . E para inicializar os atributos é utilizado um método construtor

A classe é bem similar. Também possui dois atributos protegidos: e , e também utiliza um método construtor para inicializar os atributos.

Vixi! Mal começamos a questão é já temos mais de 20 linhas de código 🙃. Mas está tranquilo, porque até aqui a gente só copiou o enunciado.

Agora sim, vamos de fato pra questão: desenvolver a classe .

Aqui nós vamos executar uma herança dupla. Mas não é nada difícil, pra efetuar herança múltipla é assim:

No nosso caso temos apenas duas mães, então fica assim:

E prontinho. Agora a classe tem acesso a todos os atributos e métodos das classes mães.

Continuando, temos que declarar dois novos atributos para representar a cor e modelo do carro:

Agora vem a parte mais interessante da questão. Para inicializar todos os atributos da nossa classe nós podemos fazer um construtor. E não só isso, a gente pode fazer chamada aos construtores de todas as classes mães:

Aqui a gente tem apenas duas classes mães, então fica assim:

E sem dificuldade nós já inicializamos todos os parâmetros herdados! Agora é só a gente inicializar a cor e o modelo do carro:

E está quase acabando. A questão também pede que a classe possua um método que imprima o conteúdo. Então vamos criar o método que simplesmente utiliza o para imprimir todos os atributos.

Agora é hora de testar! Vamos criar um objeto do tipo carro e inicializar com alguns atributos. E depois utilizamos o método

E o resultado é:

E prontinho. Questão concluída!

E aí, galera.

Essa é uma questão de herança dupla. Vamos precisar implementar as classes e e em seguida vamos herdar essas duas classes na classe filha

O detalhe é a as duas classes mães, e , possuem o atributo em comum. Além disso, elas possuem os métodos e em comum também, o que pode gerar ambiguidade. Então vamos levar isso em consideração na hora de construir as classes mães e na hora efetuar a herança.

Quando a gente tiver construindo as classes e devemos lembrar que os métodos e devem ser virtuais. E quando a gente efetuar a herança, dentro da classe vamos ter que executar polimorfismo para evitar ambiguidades.

Mas pra começar, vamos escrever o cabeçalho do código:

Vamos começar desenvolve a classe . Se a gente der uma olhada no diagrama oferecido pela questão, vemos que essa classe tem dois atributos privados. É importante notar isso, pois atributos privados não diretamente acessíveis dentro da classe filha.

A classe também possui vários métodos públicos, um método construtor para inicializar os atributos, e métodos getters e setters para cada um dos atributos. Os métodos getters e setters são importantes pois serão as únicas formas da classe filha acessar os atributos da classe

Ok, vamos então escrever o código. Iniciamos a classe

E em seguida declaramos os atributos dentro do encapsulamento privado.

Em seguida, em encapsulamento público, desenvolvemos o construtor da classe:

E pra cada um dos atributos vamos criar um método getter e setter.

Começando com os métodos e . Aqui a gente tem que pensar um pouco no futuro, e lembrar que a classe também vai ter métodos com esses nomes. Então, já prevemos que haverá ambiguidades na execução da herança dupla. Então, para nos prevenir, vamos utilizar a palavra-chave na declaração de e

Em seguida, podemos criar os métodos e :

E assim, podemos finalizar a classe .

Show. Agora vamos dar uma olhada na classe

Observando o diagrama fornecido no enunciado, vemos que essa classe também possui dois atributos privados, um construtor público e os métodos getters e setters. Lembrando que é importante desenvolver os getters e setters para permitir que a classe filha tenha acesso aos atributos da classe

Então, primeiro iniciamos a classe:

E, no encapsulamento privado, declaramos os atributos:

Depois, mudamos para público e criamos o construtor:

E pra cada um dos atributos vamos criar um método getter e setter.

Mais uma vez, temos que lembrar que os métodos e existem nas duas classes mães. Então teremos que fazer esses métodos serem virtuais:

E pra finalizar a nossa classe, vamos criar os métodos e

E assim concluímos a classe

Belezinha, estamos com as classes base da questão concluídas. Agora criar a classe derivada

A classe é composta por uma herança dupla, e por mais um atributo privado , por um construtor e pelos métodos método , e .

Então vamos começar efetuando a herança dupla. Lembre-se que pra criar uma herança dupla a gente faz assim:

E em seguida, a gente declara o atributo privado:

Show. Mudando para o encapsulamento público, vamos iniciar o construtor da classe . Lembrando que o construtor de uma classe filha pode executar o construtor de todas as classes mães, dessa forma:

Então, o construtor da classe filha recebe todos os parâmetros necessários para iniciar a classe, e para iniciar os atributos herdados a gente executa os construtores das classes mães entregando os parâmetros necessários para cada construtor. E para o atributo que existe apenas dentro da classe filha, a gente faz sua inicialização dentro das chaves do método construtor.

O passo seguinte é desenvolver os métodos getters e setters. Vamos começar criando os mais simples o e o

Agora, a gente tem que lembrar que temos um problema sobre os métodos e . Acontece que temos duas cópias de cada um deles, pois esses métodos existem dentro das duas classes mães e

O que temos que fazer é executar um polimorfismo e escolher qual versão do método queremos utilizar. No caso dessa questão, os dois métodos funcionam exatamente iguais, então podemos escolher a versão de qualquer uma das classes mães sem problemas. Lembre-se que pra executar a versão de um método da classe mãe a gente faz assim:

Então vamos fazer. Primeiro a gente inicia um polimorfismo do método e dentro das chaves a gente executa a versão de existente na classe e retorna o resultado.

E para o método a gente faz quase a mesma coisa: inicia o polimorfismo do método, e dentro das chaves a gente executa a versão de que existe dentro da classe mãe . Detalhe é que o método recebe um valor, então temos que receber esse valor na construção do polimorfismo e passar esse valor para o

Beleza, a classe está quase pronta. Mas antes precisamos criar um método que imprime o conteúdo da classe. Aqui não tem segredo, é só usar o várias vezes para imprimir todos os atributos. O detalhe é que os atributos herdados privados só podem ser acessados através de métodos getters:

E pronto. A classe está concluída.

Agora só falta gente testar tudo.

Vamos criar um objeto da classe e iniciar com valores aleatórios, e depois é só executar e ver o resultado:

E o resultado é:

E pronto! Questão feita.

Vamos lá, pessoal

Essa é uma questão de herança dupla onde vamos criar duas classes base e e depois construir a classe derivada . O detalhe da questão está no atributo que existe dentro das duas classes base, e por consequência os métodos e também existem dentro das duas classes.

A primeira solução que você pode pensar é em simplesmente usar polimorfismo para dar prioridade a uma das classes. Mas acontece que o representa o nome da pessoa, enquanto representa o nome do inseto. Esses atributos tem o mesmo nome, mas representam coisas diferentes. Ou seja, precisamos fazer de um jeito em os dois atributos continuem existindo, mas que não gere ambiguidades

Mas pra começar, vamos escrever o cabeçalho do código.

Vamos começar escrevendo a classe base .

Essa classe possui dois atributos privados, que deve ser e que deve ser inteiro.

Em seguida, vamos criar um construtor para a classe. Lembre-se que os construtores são quase sempre públicos. O construtor vai receber e inicializar os valores dos atributos e :

Vamos definir setters e getters para os atributos privados.

Vamos começar pelo atributo . Como discutimos no passo anterior, esse atributo e seus setter e getter aparecem dentro das duas classes bases. Então, o primeiro passo para evitar ambiguidades é definir os métodos com nomes iguais como virtuais. Então vamos declarar e como métodos virtuais.

Show. Agora desenvolvemos os setter e getter para o atributo . Aqui não tem segredo nem treta:

E assim finalizamos a classe

O passo seguinte é desenvolver a classe :

Aqui temos três atributos, o que representa o nome do inseto, e os atributos booleanos e que determinam algumas características desse inseto. Vamos encapsular todos os atributos como privados.

Mudaremos agora para o encapsulamento público, e vamos desenvolver um construtor que recebe e inicializa os valores dos três atributos da classe:

E o passo seguinte é desenvolver os métodos setters e getters dessa classe.

Vamos começar pelo atributo , pois como já falamos, temos que lembrar esse atributo e seus setters e getters existem dentro das duas classes base, então para evitar ambiguidades, o primeiro passo é declarar os métodos como virtuais:

Belezinha. Agora, pra criar os setters e getters dos atributos e não tem grilo:

E prontinho, a classe está prontinha.

Da hora! Agora é a parte mais importante da questão! Vamos criar a classe derivada usando duas classes como base: e . Lembre-se que pra efetuar uma herança múltipla a gente faz assim:

No código fica assim:

Beleza. A classe possui dois atributos adicionais e os dois do tipo . Então vamos declarar esses atributos com encapsulamento privado:

Mudando para o encapsulamento público, vamos definir um construtor para a classe . Mas pra agilizar esse processo, vamos executar os construtores das classes mãe.

A gente primeiro declara o construtor da classe filha recebendo todos os parâmetros, depois usamos o operador e executamos os construtores das classes mães, entregando pra elas os parâmetros necessários:

Isso vai garantir que as classes herdadas sejam inicializadas corretamente. E depois, é só a gente abrir as chaves, e dentro do método construtor inicializar os atributos exclusivos da classe filha.

No nosso código temos apenas duas classes mães, então fica assim:

Repare que dentro das chaves a gente inicializou os atributos e que são exclusivos da classe derivada.

Belezinha, seguindo em frente, precisamos criar setters e getters para os atributos e :

Os demais atributos herdados já possuem setters e getters que também foram herdados.

O problema são os métodos e , pois a gente possui duas cópias de cada um desses métodos, uma vinda de e outra vinda de . Normalmente, a gente simplesmente escolheria usar a versão de uma classe e ignoraríamos a versão da outra classe...

Acontece que o atributo e representam coisas diferente, o primeiro representa o nome humano e o segundo representa o tipo de inseto. Então não podemos ignorar nenhum dos dois, pois eles representam coisas diferentes.

Mas não criemos pânico! A solução é simples! Primeiro, vamos criar um polimorfismo para os métodos e e vamos fazer eles atuarem sobre o conteúdo de

E o que faremos a respeito do conteúdo existente em ? Simples! Vamos criar dois métodos novos: que executa o método e o método que executa o

Viu! Foi facinho!

E pra terminar a classe, vamos desenvolver o método que simplesmente retorna um textinho engraçadinho com as características desse herói. O detalhe é que todos os atributos herdados são privados, e por isso devem ser acessados através dos métodos getters.

E prontinho! Classe concluída!

Beleza! Agora é só testar o nosso código.

Vou criar um objeto da classe e inicializa-lo com alguns valores aleatórios:

O resultado é:

E prontinho! Questão finalizada!

Vamos nessa, pessoal!

Só de olhar pro diagrama da questão, a gente vê que temos um problema do diamante. Esse problema acontece quando uma classe derivada herda duas classes “irmãs”.

Observe que as classes e herdam características da classe , e até aqui está tudo bem. O problema acontece na classe , pois ao herdas as classes e , ela acabada herdado também duas cópias de tudo que existe na classe , gerando vários conflitos e ambiguidades. A melhor forma de resolver isso é efetuando uma herança virtual da classe . E depois vamos precisar lembrar que o construtor da classe vai p

Um resumo de como resolver o problema do diamante está abaixo:

Para resolver o diamante a gente herda a classe do topo de forma virtual, e modifica um pouquinho o construtor da classe de baixo.

Mas antes de mais nada, vamos começar com o cabeçalho do código:

Vamos definir a classe raiz

Vamos declarar o atributo privado do tipo que representa o modelo do veículo.

Em seguida, vamos declarar o construtor dessa classe para inicializar o atributo:

Para ter acesso ao atributo privado, vamos desenvolver métodos setters e getters

E pra terminar a classe vamos desenvolver o método que imprime o conteúdo de todos os atributos da classe. Nesse caso, temos apenas um atributo, então vai ser tranquilo. Um ponto importante é que o método vai existir dentro das classes filhas também, ou seja, vai sofrer polimorfismo e por isso o ideal é declarar esse método como virtual.

E prontinho, a classe está pronta.

Show, vamos agora pra classe , essa classe vai herdar a classe , mas tem um detalhe, estamos tratando de um problema do diamante e nessa situação precisamos efetuar uma herança virtual:

No código é assim:

Beleza, vamos desenvolver o conteúdo da classe. Vamos declarar um atributo chamado que representa a pressão do pneu desse veículo.

Depois, vamos desenvolver um construtor para inicializar os atributos da classe. Aqui vamos aproveitar para executar o construtor da classe mãe para inicializar o atributo herdado :

Seguindo em frente, vamos desenvolver métodos setter e getter para o atributo da classe:

E antes de finalizar a classe vamos efetuar um polimorfismo sobre o método para que ele imprima também o atributo dessa classe:

E assim concluímos a classe .