5 Vpl s - Linguagens de Programação 2022 2

+ memoria: int + cor: string + quantidade: int + valor_unitario: float Celular(string modelo, string fabricante, int armazenamento, int memoria, double peso, string cor, int qtd, float valor) OBS: O primeiro celular inserido deverá receber o código 1, o segundo celular o código 2 e assim sucessivamente. Como esse código não é passado como parâmetro, seu valor deve ser atribuído na implementação do construtor da classe. A classe Venda deverá ter uma lista de celulares como membro e os seguintes métodos: Venda ------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------- - celulares: std::list<Celular> + adicionaCelular(const Celular& celular): void + recarregaEstoque(int cod, int qtd): void + efetuaVenda(int cod, int qtd): void + aplicaDesconto(string fabricante, float desconto): void + removeModelo(int cod): void + imprimeEstoque(): void + ordena(): void Breve descrição: ● adicionaCelular(const Celular& celular); //adiciona um novo celular à lista de celulares disponíveis à venda. ● recarregaEstoque(int cod, int qtd); //repõe o estoque de um determinado modelo de celular. ● efetuaVenda(int cod, int qtd); //efetua a venda de um determinado modelo de celular. ● aplicaDesconto(string fabricante, float desconto); // aplica um desconto (em porcentagem) em todos os celulares de um mesmo fabricante. ● removeModelo(int cod); //remove um determinado modelo da lista de celulares disponíveis à venda. ● imprimeEstoque(); // imprime os modelos dos celulares em ordem alfabética, somente daqueles que possuem pelo menos um item no estoque. ● ordena(); // ordena a lista de celulares (utilizando a composição fabricante + modelo) Help https://www.cplusplus.com/reference/list/list/ https://www.cplusplus.com/reference/list/list/sort/ https://www.cplusplus.com/reference/locale/toupper/ https://www.cplusplus.com/reference/string/string/ http://www.cplusplus.com/forum/beginner/37166/ http://www.cplusplus.com/forum/beginner/222475/ https://www.cplusplus.com/doc/tutorial/classes/ Formato de entrada Cada método da classe Venda é associado a um comando. Esses comandos são executados de forma aleatória, com exceção dos métodos ordena() e imprimeEstoque() que são chamados uma única vez após o processamento de todos os comandos. Os parâmetros de entrada de cada comando, seguem a mesma ordem de declação dos seus respectivos métodos. Por exemplo, para o comando sell a ordem os parâmetros são: codigo e quantidade. OBS: Os atributos de entrada do comando insert seguem a seguinte ordem: modelo, fabricante, cor, armazenamento, memoria, peso, qtd e valor. Associações dos comandos aos métodos da classe Venda: Comando Método insert adicionaCelular(const Celular& celular); sell efetuaVenda(int cod, int qtd); add recarregaEstoque(int cod, int qtd); del removeModelo(int cod); discount aplicaDesconto(string fabricante, float desconto); Formato de saída Os métodos ordena() e imprimeEstoque() da classe Venda são executados e todos os modelos de celulares, com pelo menos uma unidade em estoque, deverão ser exibidos em ordem alfabética. Notem que é utilizado a composição dos atributos "fabricante + modelo" como critério de ordenação. Exemplo de entrada insert Galaxy M22, Samsung, 128, 4, 0.186, preto, 10, 1349 insert Moto G50, Motorola, 128, 4, 0.206, azul, 10, 1799 insert iPhone 12 Pro, Apple, 512, 6, 0.206, branco, 10, 6974 sell 2 5 sell 1 6 sell 3 4 Exemplo de Saída Apple iPhone 12 Pro, 512GB, 6GB, 2060 gramas, Branco, 6 restantes, R$ 6974.00 Motorola Moto G50, 128GB, 4GB, 2060 gramas, Azul, 5 restantes, R$ 1799.00 Samsung Galaxy M22, 128GB, 4GB RAM, 1860 gramas, Preto, 4 restantes, R$ 1349.00 Depurando localmente Caso você queira testar seu VPL localmente, você pode baixar os arquivos necessários aqui, e usá-los com diferentes arquivos de entrada, assim: g++ *.cpp -o main ./main < input.txt —------------------------------------------------------------------------------------------------------------------------------------------- VPL 11 Descrição O Google Passwords Manager é um gerenciador de senhas do Chrome. O serviço armazena as credenciais coletadas (com o consentimento do usuário) todas as vezes em que o usuário realizada um login ou cria um cadastro em algum site. Neste problema, você terá que simular o gerenciamento de logins e senhas. Para fazer essa simulação, você terá que implementar duas classes: GooglePassword e Usuario. OBS: O arquivo google_password.hpp não deve ser modificado. Já o arquivo usuario.hpp deve ser modificado apenas para declaração das variáveis necessárias. A classe Usuario deverá armazenar as seguintes informações: Usuario -------------------------------- - - login: string - password: string OBS: Essas informações, como são sigilosas, devem ser de acesso restrito da classe Usuario. Logo, só podem ser manipuladas por outras classes, através de métodos. A classe GooglePassword deverá manter a lista de senha salvas, associado ao site que foi utilizado. Além disso, ela deverá possuir os seguintes métodos: GooglePassword ------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------- - passwords: std::map<string, Usuario> + insert(string url, string login, string password): void + update(string url, string login, string old_password, string new_password): void + remove(string url): void + printPasswords(): void - checkPassword(string password): bool Breve descrição: ● insert(string url, string login, string password); // insere uma nova senha associado a um determinado site ● update(string url, string login, string old_password, string new_password); //atualiza as credenciais utilizadas em um site ● remove(string url); //remove as informações associadas a um site ● printPasswords(); //imprime as informações salvas em ordem alfabética, utilizando os sites como critério de ordem ● checkPassword(string password); // verifica se o password passa em todas as restricoes OBS: O gerenciador não deverá aceitar senhas que contenham a sequência "123456", caracteres em branco, possuam menos do que 6 ou mais do que 50 caracteres. Help https://www.cplusplus.com/doc/tutorial/classes/ https://www.cplusplus.com/reference/map/map/ https://www.cplusplus.com/reference/string/string/ Formato de entrada Cada método da classe GooglePassword é associado a um comando. Esses comandos são executados de forma aleatória. Os parâmetros de entrada de cada comando seguem a mesma ordem de declação dos métodos e são separados por vírgula. Por exemplo, para o comando insert a ordem os parâmetros são: url, login e password. Formato de saída O método printPasswords() da classe GooglePassword é executado após o processamento de todos os comandos. Deverão ser exibidos a quantidade de credenciais armazenadas e os detalhes das informações de cada site. Exemplo de entrada insert sistemas.ufmg.br,aluno,esta_senha_e_forte insert www.linkedin.com,usuario_trabalhador,ninguem_conhece_essa_senha_porque_ela_e_m uito_forte insert www.facebook.com,usuario_divertido,123456 insert www.youtube.com,criador_de_conteudo,ninguem_descobre_esta_senha Exemplo de Saída 2 sistemas.ufmg.br: aluno and esta_senha_e_forte www.youtube.com: criador_de_conteudo and ninguem_descobre_esta_senha Depurando localmente Caso você queira testar seu VPL localmente, você pode baixar os arquivos necessários aqui, e usá-los com diferentes arquivos de entrada, assim: g++ *.cpp -o main ./main < input.txt —------------------------------------------------------------------------------------------------------------------------------------------- VPL 12 Descrição Durante a pandemia, a utilização de aplicativos para fazer pedidos em restaurantes e supermercados se tornou muito comum. Neste problema, você terá que simular o recebimento de pedidos de um restaurante que faz vendas por aplicativo. Para fazer essa simulação de recebimento de pedidos, você terá que implementar seis classes: Venda, Pedido, Produto, Pizza, Hamburguer e Japonesa. OBS: Os arquivos venda.hpp, pedido.hpp e produto.hpp não devem ser modificados. A classe Produto armazena as seguintes informações: Produto ------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------- # quantidade: int # valor_unitario: float As classes Pizza, Hamburguer e Japonesa deverão ser subclasse de Produto e possuir as seguintes especificações: Pizza ------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------- - sabor: string - pedacos: int - borda_recheada: bool + Pizza(string sabor, int pedacos, bool borda_recheada, int qtd, float valor_unitario) Hamburguer ------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------- - tipo: string - artesanal: bool + Hamburguer(string tipo, bool artesanal, int qtd, float valor_unitario) Japonesa ------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------- - combinado: string - sushis: int - temakis: int - hots: int + Japonesa(string combinado, int sushis, int temakis, int hots, int qtd, float valor_unitario) A classe Pedido deverá ter uma lista de produtos, o endereco de entrega e os seguintes métodos deverão ser implementados (modifiquem apenas o arquivo pedido.cpp): Pedido ------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------- - produtos: std::list<Produto*> - endereco: string + adicionaProduto(Produto* p): void + calculaTotal(): float + resumo(): string + setEndereco(string endereco): void Breve descrição: ● void adicionaProduto(Produto* p); // adiciona um produto ao pedido ● float calculaTotal(); // calcula e retorna o valor total do pedido ● string resumo(); // retorna um resumo do pedido (uma descrição de todos os produtos que fazem parte do pedido e o endereço de entrega no final) ● setEndereco(string endereco); // atualiza o endereço de entrega do pedido A classe Venda, terá uma lista de pedidos recebidos e os métodos a seguir (modifiquem apenas o arquivo venda.cpp): Venda ------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------- - pedidos: std::list<Pedido*> + adicionaPedido(Pedido* p): void + imprimeRelatorio(): void Breve descrição: ● void adicionaPedido(Pedido* p); // adiciona um pedido à lista de pedidos recebidos ● void imprimeRelatorio(); // imprime a lista completa de todos pedidos processados, o total de vendas e a quantidade de pedidos recebidos Help https://www.cplusplus.com/doc/tutorial/classes/ https://www.cplusplus.com/reference/list/list/ https://www.cplusplus.com/reference/string/string/ https://www.cplusplus.com/doc/tutorial/inheritance/ https://www.cplusplus.com/doc/tutorial/polymorphism/ http://www.cplusplus.com/forum/beginner/222475/ Formato de entrada Os pedidos são compostos por uma lista de produtos e um endereço de entrega. A tag pedido indica o início de um novo pedido e a tag endereco indica o final do pedido. Cada produto é representado por duas linhas. A primeira linha informa o tipo do produto (pizza, hamburguer ou comida japonesa) e a segunda linha informa os atributos do produto. Os atributos de cada produto seguem a mesma ordem dos seus construtores. Formato de saída Após o processamento de todos os pedidos, o método imprimeRelatorio() da classe Venda é executado. O relatório deverá imprimir uma descrição detalhada de todos os pedidos que foram processados, a quantidade de pedidos e o total de vendas. Assim como no exemplo a seguir. Exemplo de entrada pedido pizza Calabresa,4,1,2,40 pizza Frango com catupity,6,0,1,55.90 hamburguer X-tudo,1,2,25 endereco Av. Pres. Antonio Carlos, 6627 - Pampulha, Belo Horizonte - MG pedido hamburguer X-salada,0,4,15 japonesa Combo 1,4,5,6,1,70 endereco Rua Reitor Pires Albuquerque, ICEx - Pampulha, Belo Horizonte - MG Exemplo de Saída Pedido 1 2X Pizza Calabresa, 4 pedacos e borda recheada. 1X Pizza Frango com catupity, 6 pedacos e sem borda recheada. 2X Hamburguer X-tudo artesanal. Endereco: Av. Pres. Antonio Carlos, 6627 - Pampulha, Belo Horizonte - MG Pedido 2 4X Hamburguer X-salada simples. 1X Comida japonesa - Combo 1, 4 sushis, 5 temakis e 6 hots. Endereco: Rua Reitor Pires Albuquerque, ICEx - Pampulha, Belo Horizonte - MG Relatorio de Vendas Total de vendas: R$ 315.90 Total de pedidos: 2 Depurando localmente Caso você queira testar seu VPL localmente, você pode baixar os arquivos necessários aqui, e usá-los com diferentes arquivos de entrada, assim: g++ *.cpp -o main ./main < input.txt —------------------------------------------------------------------------------------------------------------------------------------------- VPL 13 Os arquivos complexo.h e complexo.cpp implementam o TAD Complexo utilizando coordenadas polares. Esta implementação está correta e passa em todos os testes no arquivo main.cpp (execute o código para se certificar). Neste exercício, você deve reescrever os arquivos complexo.h e complexo.cpp representando os números complexos com coordenadas euclidianas (i.e. "parte real" e "parte imaginária"). Observe que você não precisa alterar em absolutamente nada os testes no arquivo main.cpp. Além disso, a medida que for implementando os métodos, faça uso dos testes para se certificar que suas novas implementações estão corretas. —--------------------------------------------------------------------------------- VPL 14 Neste VPL, vocês vão trabalhar com uma classe Vetor, que é uma versão simplificada do vector de c++ . Uma diferença significativa é que os índices de um Vetor podem ser definidos como qualquer intervalo de números inteiros. Por exemplo, a instrução Vetor<int> v(-10, 10); Cria um arranjo com *21* elementos, cujos índices variam de -10 até 10. O programador pode acessar os elementos deste arranjo através de dois métodos atribuir() e valor(). Por exemplo: Vetor<int> v(-10, 10); for (int i = -10; i <= 10; i++) { v.atribuir(i, i * i); cout << a.valor(i) << endl; } O que nós faremos neste VPL é alterar aspectos deste código, utilizando técnicas de programação defensiva/tratamento de exceções para tornar o código mais robusto à erros de entrada de dados dos usuários. Antes de mais nada, abra os arquivos na sua IDE de programação e entenda todo o funcionamento do programa. Atente-se, principalmente, a quais são as pré-condições de cada método da classe Vetor. O código passado para vocês está correto. Entretanto, mesmo um software correto pode apresentar um comportamento indeterminado/inesperado diante de uma má operação do usuário. Um software robusto precisa antever estes episódios e tratá-los de alguma forma, mesmo que seja abortando o programa e explicando claramente ao usuário o que aconteceu. Para ilustrar como lidar com este tipo de erro, nós vamos adicionar ao código do VPL o tratamento de algumas exceções. A função main já está implementada. Ela capta (catch) corretamente três tripos de exceções: ExcecaoIntervaloVazio, ExcecaoIndiceNaoInicializado, e ExcecaoIndiceInvalido. O que você tem que fazer neste VPL é garantir que os métodos da classe Arranjo lancem (throw) estas exceções de acordo com suas pré-condições. —-------------------------------------------------------------------------------------------------------------------------------------------