Construtores

Vamos nessa galera. Essa é uma daquelas questões de analisar códigos, então vamos olhar linha por linha, e encontrar os erros no código.

A chave aqui é perceber o comportamento do programa, e tentar entender como cada linha de código vai se comportar. Então let’s go!

Da linha 01 a 03 é apenas o básico de um programa C++, e está tudo certo por aqui.

Na linha 04 iniciamos a declaração da nossa classe chamada .

Nas linhas 07 e 08 são declarados três variáveis em contexto para representar a velocidade inicial, e as posições inicial e final. Por enquanto não há nenhum erro aqui.

Em um contexto na linha 12 criamos uma função chamada , essa função recebe um parâmetro e utiliza os atributos e para calcular o valor do atributo . Aqui também não encontramos nenhum erro.

Agora vamos pra linha 17 dar uma boa olhada na nossa classe construtora.

O primeiro erro está na linha 17 perceba que o tipo foi associado a função construtora, porém as funções construtoras não possuem tipo.

O segundo erro também está na linha 17 pois o nome da função está errado, o nome do construtor deve ser igual ao nome da classe.

Seguindo para a linha 19 nos deparamos com uma instrução , e sabemos que as funções construtoras não utilizam esse comando.

Mas olhando a função como um todo, existe um erro ainda mais sério. Um dos principais objetivos da classe construtora é inicializar os atributos da classe, porém, o construtor que foi exibido não atribui os parâmetros aos atributos.

Vamos corrigir os defeitos que encontramos no nosso construtor. Pra começar, a gente deve remover o tipo e renomear o método na linha 17, e apagar o comando de retorno na linha 19:

Em seguida, vamos utilizar esse método para inicializar os atributos e existentes dentro da classe. Pra isso, basta a gente usar o operador para guardar o valor dos parâmetros nos atributos.

E esse é o nosso método construtor corrigido.

Fala aí, pessoal. Tudo que vamos precisar desenvolver nessa questão é uma classe! O que é tranquilo, pois não precisamos nos preocupar com as demais partes do programa, então vamos nessa.

O diferencial dessa questão é que o construtor deve ser definido com valores padrão.

Pra começar vamos declarar uma classe chamada

Agora vamos definir os atributos da nossa classe. Por questões de segurança o ideal é declarar os atributos como privados.

Em seguida vamos declarar três atributos , e do tipo que irão receber os valores de posição do corpo.

O passo seguinte é definir o construtor da nossa classe. Primeiro de tudo, é uma boa prática sempre definir os construtores como públicos. Pra isso usamos o comando

Para declarar o construtor nós sempre fazemos uma função com o mesmo nome da classe e sem tipo (atenção a esse detalhe!).

O construtor vai receber três parâmetros e do tipo . Eles são definidos dentro dos parênteses à direita do construtor (linha 08). Estou utilizando letras maiúsculas pra não confundir os parâmetros da função com os atributos da classe. A parte interessante dessa questão é que na hora de determinar os parâmetros vamos utilizar o operador para determinar um valor padrão para cada um dos parâmetros.

O código fica da seguinte forma:

Agora só resta desenvolver o corpo do construtor. Tudo que é necessário fazer é setar os valores dos atributos utilizando os valores inseridos pelo usuário. Veja no código:

E com isso a classe está concluída e finalizamos a questão.

Vamos nessa galerinha. O que essa questão está pedindo é pra criarmos uma classe com um construtor sobrecarregado, o primeiro caso considerando uma equação de primeiro grau e no segundo caso consideramos uma equação de segundo grau.

Vamos começar pelo cabeçalho. Para resolver equações de segundo grau vamos precisar incluir a

Vamos começar a nossa classe chamada . Pra começar vamos declarar os atributos da classe.

Todos os atributos estarão privados para garantir a integridade dos dados. Vamos precisar de três atributos e para receber os coeficientes das equações. Note que o atributo só será utilizado quando a equação tiver grau 2.

Também vamos declarar dois atributos e que conterão os resultados da equação. Da mesma forma, o atributo só será usado nas equações de segundo grau

Vamos desenvolver um método do tipo que calcula o valor de quando a reta cruza o eixo das abscissas. Na linha 10 usamos um para exibir a equação para o usuário. Na linha 13 calculamos a raiz da equação e guardamos o resultado no atributo . Para concluir, na linha 14 usamos o para exibir o resultado pro usuário.

Vamos criar um segundo método do tipo que calcula a equação de segundo grau. Na linha 19 utilizamos a instrução para exibir a equação para o usuário.

Na linha 22 calculamos o valor de , note que declaramos uma nova variável dentro da função, pois ela só deve existir durante o cálculo.

Em seguida, usamos uma instrução para determinar quando é impossível obter soluções reais ou quando é possível obter soluções reais .

No primeiro caso, usamos o para informar o usuário. No segundo caso efetuamos os cálculos para encontrar as raízes, e exibimos os resultados.

Agora vamos pro coração da questão e desenvolver nossos métodos construtores.

Primeiro de tudo, precisamos mudar o contexto da classe de privado para público utilizando o

Precisamos definir um construtor para o caso de um objeto que recebe três valores no momento de sua criação. Começamos criando uma função sem tipo com o mesmo nome da classe, e que receba três parâmetros: e . Usaremos letras maiúsculas para não confundir com os atributos que definimos nos passos anteriores.

Em seguida, no corpo do construtor vamos utilizar os valores recebidos para setar os atributos da classe.

Com os valores dos atributos definidos, podemos chamar a função para efetuar o calcula e exibir os resultados pro usuário.

Seguindo os mesmos princípios, vamos criar uma sobrecarga para o construtor. Vamos criar uma segunda função sem tipo chamada mas que, desta vez, receba apenas dois parâmetros.

Da mesma forma, usaremos os valores recebidos para preencher os atributos da classe. Em seguida, vamos chamar o método para efetuar os cálculos.

E isso conclui a nossa classe.

Antes de finalizar a questão, vamos executar os testes com os valores sugeridos pela questão:

Primeiro vamos criar um objeto chamado que calcule uma equação de primeiro grau com os valores e . E um segundo objeto chamado que calcule uma equação de segundo grau com os valores e

O resultado é:

Vamos lá, galera.

A questão quer que a gente crie uma classe que represente os funcionários e depois crie um vetor com quatro funcionários.

Como iremos ter um atributo , será útil inserir a classe para facilitar nossa vida.

Vamos construir a classe chamada , e criamos os atributos privados do tipo , e do tipo

Em seguida, vamos pro contexto público da nossa classe e vamos desenvolver o construtor. Criamos uma função sem tipo com o mesmo nome da classe, e esta função receberá os parâmetros e

No corpo do construtor, vamos guardar os parâmetros recebidos nos atributos da classe.

Mas lembre-se que a questão quer que a gente imprima o e de cada funcionário. Porém, estes são atributos privados, então antes de fechar a classe, vamos criar um método que imprima esses atributos

Criamos então o método que consiste apenas em usar um para imprimir um texto com nome e salário.

Ok, a classe está pronta.

Em seguida vamos para a função principal do programa.

Aqui termos que criar uma array que contenha 4 empregados. Mas pode surgir a seguinte dúvida: “Como inserir os parâmetros do construtor?”

É simples, jovem gafanhoto, a gente cria uma array do tipo da classe, e usando as chaves vamos instanciar quatro objetos dentro desse vetor simplesmente chamando o nome da classe e abrindo parênteses para colocar parâmetros do construtor:

Então vamos criar um vetor chamado com funcionários. Preencha os campos com os nomes e salários que você quiser 😊

Show de bola. Agora precisamos imprimir o nome e salário de todos os funcionários. Então vamos fazer o seguinte, vamos criar um loop e iterar em cima da lista , e pra cada iteração vamos executar o método

E é isso! O código está pronto. 👌

E aí galerinha!

Essa questão está pedindo pra gente criar uma classe que represente um círculo. O detalhe é que ela quer que a gente deve incluir um método construtor no desenvolvimento dessa classe.

Dando uma olhada no enunciado, e a gente vai ter que criar mais três métodos: , e . O método deslocar modifica a posição do círculo, o método aumentar modifica o tamanho do raio, e o método imprimir mostra as informações do círculo. Todos esses métodos devem estar disponíveis para uso, então devem ser públicos.

Pensando um pouco na descrição desses métodos, podemos dizer que vamos precisar de três atributos: um para a posição no eixo x, outro para posição no eixo y e um terceiro para representar o raio.

Mas antes de começar a codificar, vamos escrever o cabeçalho do código:

Show de bola. Vamos começar a nossa classe!

Primeiro declaramos uma classe chamada :

Dentro dessas classes vamos criar os atributos três atributos privados. Os atributos e para representar a posição, e o atributo para representar o raio. Os três atributos podem ser quaisquer números reais, então vamos declarar como float.

Beleza, atributos criados, vamos agora pros métodos. Essa classe vai possuir quatro métodos públicos: o método construtor, e os métodos , e .

Pra criar um construtor é só você lembrar que um construtor é um método sem tipo com o mesmo nome da classe. Então vamos declarar o construtor:

Por enquanto, vamos apenas declarar o construtor, por isso botamos um ponto-e-vírgula no final da linha 09.

Agora vamos declarar os demais métodos, , e .

E com todos os métodos declarados podemos fechar a classe!

Beleza, o esqueleto da classe está concluído! Agora precisamos desenvolver o comportamento dos métodos! Então vamos definir cada um dos métodos. Pra gente definir um método fora da classe é bem fácil, é só fazer assim:

Vamos começar definindo o construtor. Pra isso vamos chamar o construtor fora da classe. O construtor vai receber como parâmetro os valores de cada um dos atributos. E dentro do método construtor vamos inicializar os atributos da classe com os valores dos parâmetros recebidos.

O próximo passo é definir o método . Esse método vai receber como parâmetro um valor de deslocamento para cada uma das componentes. E dentro desse método vamos atualizar os atributos e para adicionar o valor de deslocamento.

Seguindo em frente, vamos desenvolver o método . Esse método vai receber como parâmetro um valor de proporção, e dentro do método vamos multiplicar o valor do raio por essa proporção.

O último método que precisamos desenvolver é o , que não precisa receber nenhum parâmetro. Dentro desse método vamos apenas usar o para imprimir uma mensagem com todos os atributos da classe:

E com isso a gente termina de desenvolver os métodos da classe! A classe está prontinha!

Show de bola. Agora é só a gente testar a classe.

Vamos instanciar um objeto da classe . Lembre-se que essa classe tem um construtor, então, no momento que criamos um objeto temos que usar os parêntesis para passar os parâmetros do construtor:

Em seguida, vamos executar alguns métodos, e rodar o código:

O resultado é:

E aí pessoal, vamos lá?!

Essa é claramente uma questão de sobrecarga de construtor!

A questão está pedindo pra gente criar uma classe que possui três métodos privados e um construtor com 3 sobrecargas.

Vamos começar desenvolvendo o cabeçalho da questão. Nessa questão vamos precisar calcular áreas, distancias e perímetros, então vamos incluir o cabeçalho pra auxiliar a gente.

Então vamos começar declarando a classe

Vamos precisar declarar três atributos: e para representar a posição central, e o para representar o raio do círculo. Além disso, ao longo dos métodos vamos precisar do valor de , então vamos declarar uma constante com o valor.

Depois vamos precisar declarar métodos privados que calcula a área do círculo, calcular a distância entre os centros de dois círculos, e a circunferência do círculo. Vamos declarar então três métodos: , e . Por enquanto vamos apenas declarar os protótipos dos métodos, a gente vai desenvolver eles depois.

Continuando a nossa classe, vamos desenvolver os construtores. Lembre-se os construtores são sempre públicos (com raras exceções). Então vamos mudar para e criar o construtor.

Nessa questão, temos sobrecarga de construtores então vamos declarar todas as sobrecargas do nosso construtor. A primeira versão não recebe nenhum parâmetro

A segunda versão do construtor irá receber o valor do raio:

A terceira versão recebe o valor da posição e

E a última versão do construtor recebe os três parâmetros:

Está quase tudo pronto, mas tem um pequeno detalhe. Todos os atributos e métodos interessantes são privados! Precisamos criar um método público que imprima as informações dessa classe. Então vamos criar o método :

E agora sim a gente pode fechar a classe.

Dentro da classe a gente declarou o protótipo dos métodos, agora a gente precisa desenvolver o conteúdo desses métodos. Para desenvolver um método fora da classe a gente chama o método usando e dentro das chaves escreve o conteúdo do método.

Primeiro, vamos começar pelo método . Ele é bem simples, não precisa receber nenhum parâmetro. Apenas vai acessar o atributo e aplicar a fórmula da área do círculo:

Depois vamos desenvolver o método . Esse método é interessante por recebe um outro objeto da classe ! Dentro desse método, a gente calcula a distancia entre as componentes do círculo, e depois calcula o módulo dessa distância, e retorna esse resultado:

No código fica assim:

O próximo método que vamos desenvolver é o que calcula o comprimento da circunferência usando a seguinte fórmula:

E já vamos aproveitar para desenvolver o método também. É só usar o várias vezes para imprimir os atributos e métodos da classe:

Agora vamos desenvolver os construtores. Vamos lembrar que um construtor é um método sem tipo e que não retorna nada. Na maioria das vezes esse método é usado apenas para inicializar os atributos da classe, e é exatamente isso que faremos aqui.

Para evitar confusão entre os nomes dos parâmetros e dos atributos, vamos usar o ponteiro quando a gente quiser se referir aos atributos da classe.

O primeiro construtor não recebe nenhum parâmetro, e inicializa os atributos com valores padronizados.

O segundo construtor recebe o valor do raio, e inicializar os atributos:

O construtor três recebe os parâmetros e :

E o último construtor recebe o valor de todos os parâmetros da classe:

E prontinho! Desenvolvemos todas as sobrecargas do construtor, e a classe está terminada!

Pra terminar a questão, precisamos testar o nosso código!

Vamos criar quatro instâncias da classe círculo, e em cada uma delas a gente vai utilizar uma construtor diferente!

E depois, em cada instância vamos utilizar o método :

E aí termos o seguinte resultado:

E aí, tudo beleza?!

Essa questão pede pra gente criar uma classe para representar um retângulo. Um detalhe é que a questão pede um construtor com valores padronizados.

Vamos precisar declarar dois atributos e , que por questões de boas práticas de programação, serão privados. E também vamos desenvolver dois métodos privados e .

Porém, essa classe não tem nenhuma forma de exibir seus atributos e métodos. Então vamos criar um método que mostra os atributos e cálculos da classe.

Vamos começar desenvolvendo o cabeçalho da questão.

Vamos agora desenvolver a classe

E em seguida vamos declarar seus atributos:

O passo seguinte é declarar os protótipos dos métodos! Primeiro vamos declarar os protótipos dos métodos privados e . Esses dois métodos não precisam receber parâmetros, e retornam valores reais.

Depois a gente muda para o e declaramos o protótipo do construtor, que não tem tipo, e recebe dois parâmetros.

E por fim, declaramos o protótipo do método

E podemos fechar a classe.

Agora vamos desenvolver cada um dos métodos da classe! Para desenvolver um método fora da classe a gente chama o método usando e dentro das chaves escreve o conteúdo do método.

Primeiro, vamos desenvolver o construtor. Como já definimos, o nosso construtor vai receber dois parâmetros. O detalhe é que esses parâmetros tem valores padrão. Caso não seja fornecido valores, o construtor irá usar o como padrão.

Para criar um método com valor padrão é só a gente usar o operador do lado dos parâmetros do método.

Dentro do construtor vamos inicializar os atributos e com os valores inseridos pelo usuário.

Seguindo em frente, vamos desenvolver os demais métodos da classe.

O método vai simplesmente retornar o valor da multiplicação :

O método também é tranquilo de desenvolver. Ele simplesmente vai retornar o valor da soma de todos os lados do retângulo, que podemos calcular assim:

E pra gente acessar os valores dos atributos e os resultados dos métodos, vamos desenvolver o método . Utilizando o vamos exibir na tela o valor dos atributos e o resultado dos cálculos:

E prontinho! A classe e seus métodos estão concluídos!

Agora é só a gente testar tudo.

Vamos criar três instancias de , cada uma delas vai inserir uma quantidade diferente de parâmetros no construtor, pois como o construtor possui valores padrão, os parâmetros não fornecidos serão preenchidos com o valor padrão .

Depois, em cada objeto, vamos executar o método

Rodando o código vamos ter o seguinte resultado:

E prontinho! Está tudo funcionando direitinho!