TrabalhosGratuitos.com - Trabalhos, Monografias, Artigos, Exames, Resumos de livros, Dissertações
Pesquisar

Calculadora Em Linguagem C

Artigo: Calculadora Em Linguagem C. Pesquise 862.000+ trabalhos acadêmicos

Por:   •  16/11/2013  •  9.274 Palavras (38 Páginas)  •  1.588 Visualizações

Página 1 de 38

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;

}

...

Baixar como  txt (42.2 Kb)  
Continuar por mais 37 páginas »