Calculadora Em Linguagem C
Artigo: Calculadora Em Linguagem C. Pesquise 860.000+ trabalhos acadêmicosPor: • 16/11/2013 • 9.274 Palavras (38 Páginas) • 1.440 Visualizações
LISTA DE FIGURAS
Figura 1 - Menu Inicial .......................................................................................................... 16 Figura 2 - Tela Inicial do aplicativo básico em C................................................................... 23 Figura 3- Soma ....................................................................................................................... 24 Figura 4 – Subtração ............................................................................................................... 24 Figura 5 – Multiplicação.......................................................................................................... 26 Figura 6 – Divisão .................................................................................................................. 27 Figura 7 - Divisão por 0 .......................................................................................................... 27 Figura 8 – Exponenciação ...................................................................................................... 29 Figura 9 - Raiz Quadrada........................................................................................................ 30 Figura 10 – Porcentagem ....................................................................................................... 31 Figura 11 – Sair ...................................................................................................................... 32 Figura 12 - Tela aplicativo avançado...................................................................................... 40 Figura 13 - Conversão Binário para Decimal ........................................................................ 46 Figura 14 - Conversão Decimal para Binário ........................................................................ 47
SÚMARIO
INTRODUÇÃO......................................................................................................... 05 DESAFIO ...................................................................................................................06
Objetivo do Desafio.................................................................................................... 06
ETAPAS 1 ................................................................................................................. 07
Relatório 1 – Planejamento Inicial ............................................................................. 12
Relatório 2 .................................................................................................................. 18 Comando System() ..................................................................................................... 19
CLR ............................................................................................................................ 19 STDLIB.H .................................................................................................................. 19
Pause ........................................................................................................................... 20 Relatório 3 .................................................................................................................. 20 Relatório 4 .................................................................................................................. 31 Função Exponenciação ............................................................................................... 31 Função Fatorial ........................................................................................................... 31 Função Raiz Quadrada ............................................................................................... 32 Relatório Final ............................................................................................................ 47 CONCLUSÃO/CONSIDERAÇÕES FINAIS............................................................ 55 REFERÊNCIAS BIBLIOGRÁFICAS ....................................................................... 56
INTRODUÇÃO
A linguagem C é uma linguagem de alto nível e estruturada. Sua sintaxe é simples e portátil,
isto é, pode ser usado o mesmo programa em várias plataformas. C é muito utilizada para a
programação de micro controladores e também tem o poder de interagir com a plataforma
em baixo nível podendo incluir códigos em assembly em sua implementação.
As funções desenvolvidas em C são de fácil implementação, pois são usadas, geralmente,
um conjunto de rotinas simples para a execução de rotinas complexas. Também é possível
verificar a vasta quantidade de documentação a respeito da programação nesta linguagem.
A exploração de rotinas de baixo nível é possível em C, pois existe suporte a programação
em assembly dentro de seus programas. Deste modo pode-se desfrutar de todas as vantagens
da implementação em alto nível e também fazer uso das vantagens da implementação em
baixo nível explorando rotinas que podem não ser otimizadas através da programação em
alto nível.
Os tipos de dados utilizados na construção de algoritmos são: inteiros, real, caractere e lógico.
Onde o tipo de dado inteiro pertence ao conjunto dos números inteiros relativos (1,2,3, 5,....,200), real que pertence ao conjunto dos números reais(1.5, 2.45, -3.98), caractere onde
toda informação composta de conjuntos de caracteres especiais, alfanuméricos e alfabéticos
e por fim o lógico que assumi apenas duas situações( Verdadeiro OU Falso). Também
existem operadores para cálculos matemáticos e comparativos, também com funções
pré-definidas.
Neste trabalho então é apresentado à solução para a realização da calculadora, usando a
representação código C juntamente com as telas de cada aplicativo feito e um estudo
detalhado de cada etapa.
Por fim, os softwares utilizados para elaboração, testes e interpretação dos algoritmos foram
o VisualG e o Visual Studio. O software VisualG utiliza a linguagem portugol ou português
estruturado, possui um extenso banco de dados e seu desenvolvimento foi feito pela empresa
Apoio Informática LTDA. Já o Visual Studio, utiliza a linguagem C/C++, também possui um
extenso banco de dados e seu desenvolvimento foi feito pela empresa Microsoft.
COMPETÊNCIAS E HABILIDADES
Ao concluir as etapas propostas neste desafio, você terá desenvolvido as competências
e habilidades que constam nas Diretrizes Curriculares Nacionais descritas a seguir.
Iniciar, projetar, desenvolver, validar e gerenciar qualquer projeto de software.
Identificar, analisar, documentar e solucionar problemas e necessidades passíveis de
solução via computação.
Desenvolver pesquisa científica e tecnológica.
Saber conciliar teoria e prática.
Produção Acadêmica
• Relatório 1 – Planejamento Inicial. Contendo um esboço do programa em português
estruturado, com uma descrição das ações e variáveis necessárias ao aplicativo básico.
• Relatório 2 – Comando system( ). Listagem com as opções da função system( ) que
podem ser utilizadas no aplicativo de modo a criar uma interface mais agradável.
• Relatório 3 – Aplicativo básico. Contendo o código-fonte e telas do aplicativo básico,
que utiliza os comandos de atribuição, leitura, escrita e a estrutura de seleção, para
realizar as funcionalidades propostas nas Etapas 1 e 2.
• Relatório 4 – Algoritmos Avançados. Contendo a descrição das técnicas utilizadas
para realizar as opções: Fatorial, Exponenciação e Raiz quadrada.
• Relatório 5 - Aplicativo final. Contendo o código-fonte e telas do aplicativo
avançado, que utiliza as estruturas de iteração e as estruturas de dados compostas
para complementar o aplicativo com as funcionalidades propostas nas Etapas 3 e 4.
DESAFIO
A matemática e a informática são áreas que estão fortemente relacionadas e apresentam constante evolução, muitas vezes, decorrente da influência que existe entre elas.
De um lado, o avanço da computação foi alavancado pela crescente necessidade de
programas voltados à resolução de problemas matemáticos. De outro, a alta capacidade
de cálculo dos computadores permite explorar aplicações da matemática que seriam
inviáveis se realizadas por operações puramente manuais.
O desafio proposto consiste na elaboração de um aplicativo, em linguagem de programação
C, que apresenta uma calculadora que ofereça operações básicas nas Etapas 1 e 2 e mais
avançadas nas Etapas 3 e 4 da ATPS. A elaboração do aplicativo pode ser segmentada
para ser planejada, codificada e testada por etapas, de maneira incremental e evolutiva.
A tela inicial do aplicativo deve exibir ao usuário um menu com as operações e receber
do usuário a opção desejada. Na sequência, são solicitados os parâmetros para aquela
operação; por exemplo, se o usuário escolheu a opção de soma, deverá haver a entrada dos
dois números, para concluir o cálculo e apresentar o resultado obtido. Após isso, o programa
fica em pausa, com a apresentação da mensagem: “Pressione qualquer tecla para continuar.”.
No final de cada operação, o aplicativo deve limpar a tela e retornar ao menu principal.
Objetivo do Desafio
Implementar uma calculadora via programação em Linguagem C. Deverá ser
explorado o uso dos comandos e estruturas abordados na disciplina de Programação
Estruturada na elaboração de um projeto prático que integre esses comandos de modo
simples, porém funcional. Como resultado, espera-se um conjunto de relatórios com o
código-fonte que apresente uma interface simples ao usuário, com as funções de uma
calculadora.
Etapa 1
Esta atividade é importante para que você entenda o processo de declaração e
definição de variáveis, os tipos de dados e seus relacionamentos.
Para realizá-la, devem ser seguidos os passos descritos.
PASSOS
Passo 1 (Equipe)
1 Fazer a leitura do tema Introdução à Linguagem C, em fonte bibliográfica de referência,
com foco nas variáveis e seus tipos.
2 Elaborar um esboço do programa, listando cada ação a ser executada e analisando
criteriosamente quais os dados envolvidos, bem como os tipos de variáveis que
melhor se adéquam para armazená-los. As funcionalidades da 1ª etapa são:
• (+) Soma
• (-) Subtração
• (*) Multiplicação
• (/) Divisão
• (E) Exponenciação
• (R) Raiz Quadrada
• (P) Porcentagem
No Quadro 1 são apresentados os itens que devem ser analisados referentes ao
aplicativo básico.
Quadro 1 – Ações da primeira etapa
Fonte: Próprio autor da ATPS
Itens
1 - Menu Principal 5 - Operação de Divisão
2 - Operação de Soma. 6 - Operação de Exponenciação.
3 - Operação de Subtração 7 - Operação de Raiz Quadrada.
4 - Operação de Multiplicação. 8 - Operação de Porcentagem.
A descrição em português estruturado a seguir apresenta o esboço do menu e da ação
de soma.
Item 1: Menu principal.
Variável: op do tipo caractere.
Ações:
1. Apresentar na tela as opções do aplicativo básico (Soma, Subtração, Multiplicação,
Divisão, Exponenciação, Raiz Quadrada, Porcentagem e Sair).
2. Receber a opção e armazenar (op).
Item 2: Operação de soma.
Variáveis: val1, val2 e res do tipo inteiro.
Ações:
1. Solicitar e armazenar o primeiro valor (val1).
2. Solicitar e armazenar o segundo valor (val2).
3. Realizar o cálculo e armazenar o resultado (res).
4. Apresentar o resultado na tela (res).
Passo 2 (Equipe)
1 Pesquisar, no site sugerido no item 2 a seguir, sobre a função system(). Este comando
permite acessar funcionalidades oferecidas pelo MSDOS por prompt de comando e
melhorar significativamente a operabilidade do aplicativo, torna-o mais amigável e
atraente para o usuário.
2 Elaborar uma listagem com o nome e a descrição de quatro funcionalidades
interessantes para serem utilizadas no programa. A função system() está descrita na
biblioteca stdio.h, que deve ser incluída no início do programa. Um material de aula
sobre esta função está disponível no site sugerido a seguir.
Site sugerido para pesquisa
• SYSTEM. Comando System.doc. Disponível em:
<https://docs.google.com/file/d/0B114oKTDsLjnQWQwYnhtWjFTLTA/edit?usp
=sharing>. Acesso em: 4 abr. 2013.
Passo 3 (Equipe)
1 Produzir o Relatório 1 – Planejamento Inicial. Contendo um esboço do programa em
português estruturado, com uma descrição das ações e variáveis necessárias ao
aplicativo básico.
2 Redigir o Relatório 2 – Comando system(). Contendo a listagem com as opções da
função system() que podem ser utilizadas no aplicativo de modo a tornar a operação
mais agradável. Esses relatórios servirão de base para elaboração do relatório final.
Etapa 2
Esta atividade é importante para você praticar a utilização dos comandos de entrada e
saída, ou seja, os comandos responsáveis pela elaboração da interface com o usuário.
Estas funções estão descritas nas bibliotecas stdio.h e stdlib.h. As estruturas de seleção
permitem realizar ações diferentes, em resposta à interação do usuário na interface.
Para realizá-la, devem ser seguidos os passos descritos.
Passos
Passo 1 (Equipe)
1 Fazer a leitura do tema Introdução à Linguagem C, com foco na estrutura de controle
Seleção. Vocês podem utilizar as bibliografias complementares, que se encontram no
plano de ensino aprendizagem desta disciplina.
2 Elaborar o código em Linguagem C, que apresente a tela inicial do aplicativo básico,
conforme a Figura 1 a seguir. Capturar a opção com apenas uma; para isso, ler sobre a
função getche() no capítulo 2 – Operadores, do livro- texto. Para testar, elaborar um
código que capture a tecla referente à opção, limpe a tela e apresente a tecla pressionada.
O quadro ao redor da palavra calculadora pode ser obtido com a utilização de caracteres
gráficos apresentados no capítulo 1 – Introdução do livro-texto. A formatação desta tela
deve ser similar à apresentada na Figura 1. Esta formatação é apenas uma sugestão.
Passo 2 (Equipe)
1 Fazer a leitura Comando de decisões, do livro-texto da disciplina (identificado ao final
da ATPS), com foco nas estruturas de seleção, ou em material pesquisado.
2 Desenvolver a estrutura de seleção que execute o algoritmo para resolver a operação
desejada. Para obter os valores utilizados no cálculo, ler o capítulo 2 do livro-texto, sobre
o comando scanf(). Na Figura 2(A) e 2(B) são apresentadas as telas de entrada de
dados e na Figura 2(C), a tela de resultado da operação de multiplicação.
O código em Linguagem C exibido na Figura 3 apresenta o algoritmo para executar a
operação de soma e pode servir de modelo inicial para a elaboração e formatação dos
algoritmos das demais operações.
Um detalhe específico da operação de divisão é verificar se o segundo valor é zero,
pois, caso seja realizada divisão por zero, ocorrerá um erro e o programa será interrompido.
Esta tela é apresentada na Figura 4(A). Caso seja escolhida uma opção inválida, deverá ser
impressa na tela a frase: “Opcao Invalida”, conforme a Figura 4(B). Da mesma forma, caso
seja escolhida a opção ‘s’, será apresentada a frase: “programa finalizado”, como pode ser
visto na Figura 4(C).
Para as duas próximas opções, podem ser utilizadas as funções definidas na biblioteca
math.h. As telas de entradas de dados e resultados para a operação de exponenciação é
apresentada na Figura 5(A), Raiz Quadrada na Figura 5(B) e Porcentagem na Figura 5(C).
Após cada sequência de execução, o programa entra em pausa e deve ser finalizado ao
pressionar qualquer tecla. Para reduzir a complexidade, não são necessários testes que
realizem a validação dos valores digitados pelo usuário; por exemplo, digitação de letras
quando é solicitado um valor numérico. No entanto, a escolha da opção desejada no menu
deve funcionar para caracteres maiúsculos ou minúsculos.
Passo 3 (Equipe)
Redigir o Relatório 3 – Aplicativo Básico. Contendo o código-fonte e telas do aplicativo
básico, que utilizam os comandos de atribuição, leitura, escrita e a estrutura de seleção, para
realizar as funcionalidades propostas nas Etapas 1 e 2. O código deve estar corretamente
endentado e organizado, com comentários significativos que expliquem o funcionamento dos
algoritmos. Esse texto fará parte do relatório final.
Etapa 3
Esta atividade é importante para você entender os laços de repetição, seu modo de
funcionamento, suas características e sua aplicabilidade. Operações repetitivas internas
são altamente exploradas na programação e constituem a base para a resolução de uma
infinidade de problemas
Para realizá-la, devem ser seguidos os passos descritos.
Passos
Passo 1 (Equipe)
Rever o material sobre as aplicações da função system(), disponibilizado no site a seguir
indicado, para ajustar a aparência e opções disponibilizadas na tela para a interface do
aplicativo avançado. Alterar o título da janela, bem como as cores dos caracteres e fundo da
tela.
Site sugerido para pesquisa
• SYSTEM. Comando System.doc. Disponível em:
<https://docs.google.com/file/d/0B114oKTDsLjnQWQwYnhtWjFTLTA/edit?usp
=sharing>. Acesso em: 4 abr. 2013.
Nessa etapa, o programa deve ser acrescido das operações: (F) Fatorial, (B) Conversão
Binário para Decimal e (D) Conversão Decimal para Binário. A nova aparência do aplicativo
pode ser observada na Figura 6 apresentada a seguir.
Passo 2 (Equipe)
1 Fazer a leitura do tema, Laços, do livro-texto da disciplina (identificado ao final da
ATPS), com foco nas estruturas de iteração. Vocês também podem pesquisar outras
fontes para realizar este passo.
2 Elaborar o laço de repetição que limpa a tela e retorna a execução para o menu principal
do programa, após cada sequência de execução, ou seja, o programa somente será
finalizado com a escolha da opção: (S) – sair.
Passo 3 (Equipe)
1 Elaborar o código que resolva a opção Fatorial, com base nas estruturas de controle
estudadas sobre o tema Laços, do livro-texto. Solicitar o valor e imprimir o resultado no
formato: “O fatorial de val1 = res”
2 Atualizar os algoritmos das operações de Exponenciação e Raiz Quadrada, caso as
soluções atuais tenham utilizado funções da biblioteca math.h. Nesta etapa, não é
permitido o uso de funções desta biblioteca; portanto, os algoritmos devem ser
substituídos por algoritmos equivalentes que utilizem as estruturas de controle para
obter o resultado.
Passo 4 (Equipe)
Redigir o Relatório 4 – Algoritmos Avançados. Contendo a descrição das técnicas
utilizadas para realizar as opções: Fatorial, Exponenciação e Raiz quadrada. Esse
texto será parte do relatório final. A seguir, um exemplo de formato deste relatório
no que diz respeito à operação de cálculo de fatorial.
Item: fatorial.
Variável: num, fat do tipo caractere.
Descrição: A variável fat é inicializada como valor 1 e recebe-se do usuário o valor a ser
calculado (num). Um laço for(), com decremento de 1, inicializa o seu contador (i) com o
valor a ser calculado, que será decrementado a cada iteração. Na primeira iteração, a variável
fat acumula seu valor atual, que é 1 multiplicado pela valor da variável i. Nas demais
iterações, fat acumula o produto do seu valor atual com o valor de i decrementado, até que i
seja igual a 1. Na Figura 7 é apresentado um exemplo da simulação desta função.
Etapa 4
Esta atividade é importante para que você possa praticar a utilização de estrutura de
dados do tipo vetor. Os vetores unidimensionais ou multidimensionais são amplamente
utilizados no armazenamento de dados e oferecem uma estrutura organizada, que pode ser
explorada de forma rápida e eficiente por algoritmos de busca.
Para realizá-la, devem ser seguidos os passos descritos.
Passo 1 (Equipe)
Fazer a leitura sobre o tema Memória e Impressão de Caracteres, capítulo 10 do livro-texto
da disciplina (identificado ao final da ATPS), com foco em sistemas numéricos.
Passo 2 (Equipe)
Desenvolver as funções de conversão de base de Binário para Decimal e Decimal para
Binário. Na Figura 8(A) é apresentada a tela da conversão de Binário para Decimal e na
Figura 8(B), a conversão de Decimal para Binário.
Site sugerido para pesquisa
• FUNÇÕES. Funções matemáticas. Disponível em:
<https://docs.google.com/file/d/0B114oKTDsLjnTTFQY0c1SWJvSGc/edit?usp=s
haring>. Acesso em: 4 abr. 2013.
Passo 3 (Equipe e Individual)
1 Elaborar o Relatório final — Aplicativo. Contendo o código-fonte e telas do aplicativo
básico e avançado, que utiliza as estruturas de iteração e as estruturas de dados (Etapas
1 e 2), compostas para complementar o aplicativo com as funcionalidades propostas nas
Etapas 3 e 4.
2 Postar, individualmente, o relatório final no ambiente virtual de aprendizagem (AVA),
para avaliação e validação da nota pelo tutor a distância.
Livro-Texto da Disciplina
MIZRAHI, Victorine Viviane. Treinamento em Linguagem C: módulos 1 e 2. São Paulo: Pearson - Prentice Hall, 2007. PLT 706.
Critérios de Avaliação
• Cumprimento das etapas da ATPS.
• Utilização de bibliografia sugerida.
• Utilização dos relatórios parciais para elaboração do relatório final.
• Coerência da teoria e prática para finalização do desafio.
• Relatório CST em Análise e Desenvolvimento de Sistema
2º Série – Programação Estruturada I
Etapa 1
Passo 1 (Equipe)
Na figura abaixo e apresentado um esboço do programa, listando cada ação a ser executada
e analisado criteriosamente quais os dados envolvidos, referente ao aplicativo básico.
Figura copiada do visualg.
O programa abaixo apresentado, em português estruturado as ações do programa
calculadora.
algoritmo "Calculadora"
// Função : Calculadora
// Autor : João Carlos Gomes Cardim Junior
// Data : 22/09/2013
// Seção de Declarações
var
val1, val2: inteiro
res, x: real
op: caracter
inicio
// Seção de Comandos
val1 <- 0
val2 <- 0
res <- 0
escreval ("(+) - Soma")
escreval ("(-) - Subtracao")
escreval ("(*) - Multiplicacao")
escreval ("(\) - Divisao")
escreval ("(E) - Exponenciacao")
escreval ("(R) - Raiz Quadrada")
escreval ("(P) - Porcentagem")
escreval ("(S) - Sair")
Escreva ("Opção: ",op)
leia (op)
Escreva("Primeiro Valor:")
leia (val1)
Escreva("Segundo Valor: ")
leia (val2)
escolha op
caso "+"
res <- val1 + val2
escreval (val1, " + ", val2," = ",res)
caso "-"
res <- val1 - val2
escreval (val1, " - ", val2," = ",res)
caso "*"
res <- val1 * val2
escreval (val1, " * ", val2," = ",res)
caso "\"
se (val2 = 0) entao
escreval ("Opcao Invalida")
senao
res <- val1 \ val2
escreval (val1, " \ ", val2," = ",res)
fimse
caso "E"
res <- val1 ^ val2
escreval (val1, " ^ ", val2," = ",res)
caso "R"
x <- 0
repita
x <- x + 1
ate (x * x) > val1
x <- x - 1
res <- x
escreval (val1, " = ",res)
caso "p"
res <- val1 \ 100 * val2
escreval (val1, " % ",val2," = ",res)
outrocaso
escreval ("Operação incorreta")
fimescolha
fimalgoritmo
Itens
1 - Menu Principal 5 - Operação de Divisão
2 - Operação de Soma. 6 - Operação de Exponenciação.
3 - Operação de Subtração 7 - Operação de Raiz Quadrada.
4 - Operação de Multiplicação. 8 - Operação de Porcentagem.
A descrição em português estruturado a seguir, apresenta o esboço do programa.
Item 1: Menu principal.
Variável: op do tipo caractere.
Ações:
1. Apresenta na tela as opções do aplicativo básico. (Soma, Subtração, Multiplicação,
Divisão, Exponenciação, Raiz Quadrada, Porcentagem e Sair).
2. Receber a opção e armazenar (op).
Item 2 : Operação de soma.
Variáveis: val1, val2 e res do tipo inteiro.
Ações:
1. Solicitar e armazenar o primeiro valor (val1).
2. Solicitar e armazenar o segundo valor (val2).
3. Realizar o cálculo e armazenar o resultado (res).
4. Apresentar o resultado na tela (res).
Item 3: Operação de subtração.
Variáveis: val1, val2 e res do tipo inteiro.
Ações:
1. Solicitar e armazenar o primeiro valor (val1).
2. Solicitar e armazenar o segundo valor (val2).
3. Realizar o cálculo e armazenar o resultado (res).
4. Apresentar o resultado na tela (res).
Item 4: Operação de multiplicação.
Variáveis: val1, val2 e res do tipo inteiro.
Ações:
1. Solicitar e armazenar o primeiro valor (val1).
2. Solicitar e armazenar o segundo valor (val2).
3. Realizar o cálculo e armazenar o resultado (res).
4. Apresentar o resultado na tela (res).
Item 5: Operação de divisão.
Variáveis: val1, val2 e res do tipo inteiro.
Ações:
1. Solicitar e armazenar o primeiro valor (val1).
2. Solicitar e armazenar o segundo valor (val2).
3. Se o segundo valor for 0 (zero) exibir na tele
“opção invalida”
4. Realizar o cálculo e armazenar o resultado (res).
5. Apresentar o resultado na tela (res).
Item 6: Operação de exponenciação.
Variáveis: val1, val2 e res do tipo inteiro.
Ações:
1. Solicitar e armazenar o primeiro valor “base” (val1).
2. Solicitar e armazenar o segundo valor “expoente” (val2).
3. Realizar o cálculo e armazenar o resultado (res).
4. Apresentar o resultado na tela (res).
Item 7: Operação de raiz quadrada.
Variáveis: val1, val2 e res do tipo inteiro.
Ações:
1. Solicitar e armazenar o primeiro valor (val1).
2. Variável X, para fazer o comando repita.
3. Realizar o cálculo e armazenar o resultado (res).
4. Apresentar o resultado na tela (res).
Item 8: Operação de porcentagem.
Variáveis: val1, val2 e res do tipo inteiro.
Ações:
1. Solicitar e armazenar o primeiro valor (val1).
2. Solicitar e armazenar o segundo valor (val2).
3. Realizar o cálculo e armazenar o resultado (res).
4. Apresentar o resultado na tela (res).
Item 9: sair.
Nenhuma das opções, Sair do programa.
Passo 2 (Equipe)
Listagem com os nomes e a descrição de quatro funcionalidades interessantes
que foram utilizadas no programa.
Comando system()
Este comando permite acessar funcionalidades oferecidas no prompt de comados
do MSDOS em tempo real, tais como: alterar as cores do fundo e das letras, pausar
a execução, limpar a tela, mudar o título da janela, entre outros.
Os comandos devem ser colocados entre parênteses e aspas duplas, conforme os
exemplos.
São especialmente úteis para melhorar a operabilidade do aplicativo e torná-lo mais
amigável e atraente ao usuário.
Este comando está definido na biblioteca stdio.h, portando deve ser realizada sua
inclusão no início do programa.
CLR
Exemplo: system (“clr”);
Clear screen, ou seja, limpa a tela e posiciona o cursor na primeira coluna da
primeira linha.
STDLIB.H
Stdlib.h é um arquivo cabeçalho da biblioteca de propósito geral padrão da linguagem de
programação C. Ela possui funções envolvendo alocação de memória, controle de processos,
conversões e outras.
PAUSE
Exemplo: system (“pause”);
Executa uma pausa na execução do programa até ser pressionada uma tecla
qualquer e apresenta a mensagem: “Pressione qualquer tecla para continuar...”
Após o pressionamento de uma tecla a execução do programa continua na
linha seguinte ao comando.
Etapa 2
Passo 1 (Equipe)
Abaixo a tela inicial do aplicativo básico.
Figura 1 – Tela inicial do aplicativo básico.
Passo 2 (Equipe)
Desenvolver a estrutura de seleção que execute o algoritmo para resolver a operação
desejada.
Figura 1 – Soma
Soma
switch( oper )
{
/*Operação soma, disparada pelo pressionameno do caractere ‘+’. Recebe os valores do usuário, realiza o calculo e apresenta o resultado na tela.*/
case '+':
printf("\n\n\tS O M A");
printf("\n\n\tPrimeiro valor: ");
scanf("%d", &numero1);
printf("\tSegundo valor: ");
scanf("%d", &numero2);
resultado = numero1 + numero2;
printf("\n\t%d + %d = %d", numero1, numero2, resultado);
break;
Figura 2 – Subtração
Subtração
switch( oper )
{
/*Operação subtração, disparada pelo pressionameno do caractere ‘-’. Recebe os valores do usuário, realiza o calculo e apresenta o resultado na tela.*/
case '-':
printf("\n\n\tS U B T R A C A O");
printf("\n\n\tPrimeiro valor: ");
scanf("%d", &numero1);
printf("\tSegundo valor: ");
scanf("%d", &numero2);
resultado = numero1 - numero2;
printf("\n\t%d - %d = %d", numero1, numero2, resultado);
break;
Figura 3 – Multiplicação
Multiplicação
switch( oper )
{
/*Operação subtração, disparada pelo pressionameno do caractere ‘*’. Recebe os valores do usuário, realiza o calculo e apresenta o resultado na tela.*/
case '*':
printf("\n\n\tM U L T I P L I C A C A O");
printf("\n\n\tPrimeiro valor: ");
scanf("%d", &numero1);
printf("\tSegundo valor: ");
scanf("%d", &numero2);
resultado = numero1 * numero2;
printf("\n\t%d * %d = %d", numero1, numero2, resultado);
break;
Figura 4 – Divisão
Figura 4ª - Divisão
Divisão
switch( oper )
{
/*Operação subtração, disparada pelo pressionameno do caractere ‘/’. Recebe os valores do usuário, realiza o calculo e apresenta o resultado na tela.*/
case '/':
printf("\n\n\tD I V I S A O");
printf("\n\tPrimeiro valor: ");
scanf("%d", &numero1);
printf("\tSegundo valor: ");
scanf("%d", &numero2);
if(numero2 == 0)
{
printf("\tErro divisao por zero");
printf("\tOpcao Invalida");
break;
}
resultado = numero1 / numero2;
printf("\n\t%d / %d = %d", numero1, numero2, resultado);
break;
Figura 5 – Exponenciaão
Exponenciação
switch( oper )
{
/*Operação subtração, disparada pelo pressionameno do caractere ‘E’. Recebe os valores do usuário, realiza o calculo e apresenta o resultado na tela.*/
case 'e':
case 'E':
printf("\n\n\tE X P O N E N C I A C A O");
printf("\n\n\tBase: ");
scanf("%d", &base);
printf("\tExpoente: ");
scanf("%d", &expoente);
if (expoente == 0){
resultado = 1;
}
else{
resultado = potencia(base,expoente);
}
printf("\n\t%d elevado a %d = %d", base, expoente, resultado);
break;
Figura 6 – Raiz Quadrada
Raiz Quadrada
switch( oper )
{
/*Operação subtração, disparada pelo pressionameno do caractere ‘R’. Recebe os valores do usuário, realiza o calculo e apresenta o resultado na tela.*/
case 'R':
case 'r':
case 'R':
printf("\n\n\tRAIZ QUADRADA");
printf("\n\n\tValor: ");
scanf("%f", &valorRaiz);
resultadoRaiz = raiz_quadrada(valorRaiz);
printf("\n\tRaiz quadrada de %.2f = %.2f", valorRaiz, resultadoRaiz);
break;
Figura 7 – Porcentagem
Porcentagem
switch( oper )
{
/*Operação subtração, disparada pelo pressionameno do caractere ‘p’. Recebe os valores do usuário, realiza o calculo e apresenta o resultado na tela.*/
case 'p':
case 'P':
printf("\n\n\tPORCENTAGEM");
printf("\n\n\tValor: ");
scanf("%d", &numero1);
printf("\tPorcentagem: ");
scanf("%d", &numero2);
resultado = (numero1 * numero2) / 100;
printf("\n\t%d %% de %d = %d", numero2, numero1, resultado);
break;
Figra 8 - Sair
Sair
/*Sair, disparada pelo pressionameno do caractere ‘S’, sair do programa.*/
case 's':
case 'S':
printf("\n\n\tPrograma finalizado");
break;
Passo 3 (Equipe)
O Código-Fonte do aplicativo básico.
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <math.h>
// Funcao que calcula o fatorial de um numero
int fatorial(int numero)
{
int fat = 1;
int i;
for(i = numero; i > 1; i--){
fat *= i;
}
return fat;
//Funcao que calcula a Raiz Quadrada com 2 poisicoes decimais
float raiz_quadrada(float valorRaiz)
{
float resultado_1,subtrai_1,passo_1;
float resultado_2,subtrai_2,passo_2;
float resultado_3,subtrai_3,passo_3;
float raiz;
subtrai_1 = 1;
passo_1 = 0;
passo_2 = 0;
passo_3 = 0;
resultado_1 = valorRaiz;
while (resultado_1 >= subtrai_1){
resultado_1 = resultado_1 - subtrai_1;
subtrai_1 = subtrai_1 + 2;
passo_1 = passo_1 + 1;
}
if (resultado_1 != 0)
{
resultado_2 = resultado_1 * 100;
subtrai_2 = (passo_1 * 20) + 1;
passo_2 = 0;
while (resultado_2 >= subtrai_2){
resultado_2 = resultado_2 - subtrai_2;
subtrai_2 = subtrai_2 + 2;
passo_2 = passo_2 + 1;
}
if (resultado_2 != 0){
resultado_3 = resultado_2 * 100;
subtrai_3 = (((passo_1 * 10) + passo_2) * 20) + 1;
passo_3 = 0;
while (resultado_3 >= subtrai_3){
resultado_3 = resultado_3 - subtrai_3;
subtrai_3 = subtrai_3 + 2;
passo_3 = passo_3 + 1;
}
}
}
else
{
passo_2 = 0;
passo_3 = 0;
}
raiz = ((passo_1 * 100) + (passo_2 * 10) + passo_3) / 100;
return raiz;
}
int potencia (int base,int expoente){
int resultado = 1;
do {
resultado *= base;
expoente--;
}while (expoente > 0);
return resultado;
}
int main(int argc, char *argv[])
{
int numero1, numero2, resultado, fat;
int base, expoente;
int binario[8];
float numeroPorcentagem,resultadoPorcentagem;
float valorRaiz,resultadoRaiz;
char oper;
do
{
// Menu
//printf("\t\t\t\tCALCULADORA\n\n");
system("title ATPS 02: CALCULARODA V1.0");
system("color 8e"); printf("\t\t\t\xC9\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD");printf("\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xBB\n");
printf("\t\t\t\xBA C A L C U L A D O R A \xBA\n");
printf("\t\t\t\xC8\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD");printf("\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xCD\xBC\n");
printf("\n\n");
printf("\t(+) - Soma\t\t\t(P) - Porcentagem\n");
printf("\t(-) - Subtracao\t\t\t(F) - Fatorial\n");
printf("\t(*) - Multiplicacao\t\t(B) - Conversao Binario -> Decimal\n");
printf("\t(/) - Divisao\t\t\t(D) - Conversao Decimal -> Binario\n");
printf("\t(E) - Exponenciacao\t\t(S) - Sair\n");
printf("\t(R) - Raiz quadrada\n");
printf("\tOpcao: ");
oper = getche();
// Operações
switch( oper )
{
case '+':
printf("\n\n\tS O M A");
printf("\n\n\tPrimeiro valor: ");
scanf("%d", &numero1);
printf("\tSegundo valor: ");
scanf("%d", &numero2);
resultado = numero1 + numero2;
printf("\n\t%d + %d = %d", numero1, numero2, resultado);
break;
case '-':
printf("\n\n\tS U B T R A C A O");
printf("\n\n\tPrimeiro valor: ");
scanf("%d", &numero1);
printf("\tSegundo valor: ");
scanf("%d", &numero2);
resultado = numero1 - numero2;
printf("\n\t%d - %d = %d", numero1, numero2, resultado);
break;
case '*':
printf("\n\n\tM U L T I P L I C A C A O");
printf("\n\n\tPrimeiro valor: ");
scanf("%d", &numero1);
printf("\tSegundo valor: ");
scanf("%d", &numero2);
resultado = numero1 * numero2;
printf("\n\t%d * %d = %d", numero1, numero2, resultado);
break;
case '/':
printf("\n\n\tD I V I S A O");
printf("\n\tPrimeiro valor: ");
scanf("%d", &numero1);
printf("\tSegundo valor: ");
scanf("%d", &numero2);
if(numero2 == 0)
{
printf("\n\tErro divisao por zero");
printf ("\n\n\topcao invalida");
break;
}
resultado = numero1 / numero2;
printf("\n\t%d / %d = %d", numero1, numero2, resultado);
break;
case 'e':
case 'E':
printf("\n\n\tE X P O N E N C I A C A O");
printf("\n\n\tBase: ");
scanf("%d", &base);
printf("\tExpoente: ");
scanf("%d", &expoente);
if (expoente == 0){
resultado = 1;
}
else{
resultado = potencia(base,expoente);
}
printf("\n\t%d elevado a %d = %d", base, expoente, resultado);
break;
case 'r':
case 'R':
printf("\n\n\tR A I Z Q U A D R A D A");
printf("\n\n\tValor: ");
scanf("%f", &valorRaiz);
resultadoRaiz = raiz_quadrada(valorRaiz);
printf("\n\tRaiz quadrada de %.0f = %.0f", valorRaiz, resultadoRaiz);
break;
case 'p':
case 'P':
printf("\n\n\tP O R C E N T A G E M");
printf("\n\n\tValor: ");
scanf("%d", &numero1);
printf("\tPorcentagem: ");
scanf("%d", &numero2);
resultado = (numero1 * numero2) / 100;
printf("\n\t%d %% de %d = %d", numero2, numero1, resultado);
break;
case 'f':
case 'F':
printf("\n\n\tF A T O R I A L");
printf("\n\n\tValor: ");
scanf("%d", &numero1);
resultado = fatorial(numero1);
printf("\n\tO fatorial de %d = %d", numero1, resultado);
break;
case 'b':
case 'B':
printf("\n\n\tB I N A R I O P A R A D E C I M A L");
printf("\n\n\tDigite o numero binario(8 bits): ");
scanf("%d", &numero1);
resultado = binario_decimal(numero1);
printf("\n\tEquivalente em Decimal: %d", resultado);
break;
case 'd':
case 'D':
printf("\n\n\tD E C I M A L P A R A B I N A R I O");
printf("\n\n\tDigite o numero em decimal(256): ");
scanf("%d", &numero1);
resultado = decimal_binario(numero1);
printf("\n\tEquivalente em Binario: %d", resultado);
break;
case 's':
case 'S':
printf("\n\n\tPrograma finalizado");
break;
default:
printf("\n\n\tOpcao Invalida");
}
printf("\n\n\t");
system("PAUSE");
system("cls || clear");
}while(oper != 'S' && oper != 's');
return 0;
}
...