Atps Algoritmo
Artigo: Atps Algoritmo. Pesquise 861.000+ trabalhos acadêmicosPor: • 14/3/2015 • 2.293 Palavras (10 Páginas) • 412 Visualizações
1. ETAPA 3
1.1. DEFINIÇÃO DE VETORES
Vetores, também conhecidos como “arrays” (matrizes em inglês) ou matrizes unidimensionais, são variáveis que servem para guardar vários valores do mesmo tipo de forma uniforme na memória. É determinado pelo tipo (int, float, string, char) e sua capacidade de valores, que começa do índice 0 e vai até o valor determinado subtraindo-se 1, ou seja, se o vetor foi determinado com o tamanho 150, seus índices vão de 0 a 149. Tem a vantagem de facilitar a manipulação de um grande conjunto de dados do mesmo tipo declarando-se apenas uma variável.
O vetor é um espaço linear na memória divido de acordo com o tamanho que declaramos, como na figura abaixo:
Fig. 1.1. Representação gráfica de um vetor
Fonte: http://www.tiexpert.net/programacao/c/vetores.php
1.2. IMPLEMENTAÇÃO DE VETORES E MATRIZES EM LINGUAGEM C
As matrizes em geral são caracterizadas por se tratarem de uma única variável de um determinado tamanho que guarda várias informações do mesmo tipo. Essas informações são gravadas na memória sequencialmente e são referenciadas através de índices. As matrizes podem ser tanto unidimensionais (vetores) como bidimensionais.
Um vetor pode ser definido pela seguinte sintaxe:
Tipo nome_vetor [tamanho];
Deverá ser indicado o tipo (int, float, char, string) do vetor, o nome do vetor e em seguida seu tamanho. Deve-se lembrar que o vetor começa do índice 0, ou seja, se for determina um tamanho 5 para um vetor, este começará do índice 0 e irá até o índice 4.
Ex.:
int vet1[5];
Já as matrizes bidimensionais são matrizes do tipo linha-coluna, onde o primeiro índice indica a linha e o segundo a coluna. Esse tipo de matriz é considerado o caso mais simples de matrizes multidimensionais.
Ex.:
int mat[2][2];
1.3. VANTAGENS E LIMITAÇÕES DA UTILIZAÇÃO DE VETORES E MATRIZES
A principal vantagem de se utilizar vetores e matrizes é a manipulação de um grande conjunto de dados do mesmo tipo declarando-se apenas uma variável. Utilizando-se laços de repetição, podemos acessar cada valor contido nos índices de um vetor ou matriz, como pode-se observar no programa que será colocado ao final do trabalho. Já as desvantagens ocorrem por uma matriz ser muito grande, contendo vários dados, pode demorar um certo tempo até o programa ler os dados contidos na matriz.
1.4. MODULARIZAÇÃO E DECOMPOSIÇÃO DE PROGRAMAS
Modularização é uma técnica de desenvolvimento de sistemas que consiste na divisão da solução de um problema em “partes”. Ou seja, as funções contidas em um programa são organizadas, facilitando a visualização do código e estruturando melhor o programa.
1.5. PASSAGEM DE PARÂMETROS PARA FUNÇÕES
Parâmetros são dados que uma função precisa receber, necessários para que a mesma possa atingir seu objetivo ao ser executada. Um exemplo básico é uma função soma, que, para a função realizar a soma entre dois algarismos, é necessário que informe os algarismos, que são os parâmetros para que a função realize a soma.
ETAPA 4
2.1. REPRESENTAÇÃO DE STRINGS EM LINGUAGEM C
String é uma matriz do tipo char, que armazena um texto formado de caracteres e sempre terminado pelo caractere zero (‘0’). Em outras palavras, string é uma série de caracteres em que cada um ocupa um byte de memória, armazenando em sequência e terminado por um byte de valor zero (‘0’). Cada caractere é um elemento independente de matriz e pode ser acessado por meio de um índice. Uma string é representada igual à um vetor:
char nome [tamanho do vetor];
2.2. MANIPULAÇÃO DE STRINGS: FUNÇÕES NATIVAS DA LINGUAGEM C
Existem algumas funções para a manipulação de uma string, que no início do programa deve-se incluir a biblioteca “string.h”. Abaixo algumas dessas funções:
• printf () e puts () : A função printf(), assim com a função puts () (biblioteca stdio.h), é utilizada para escrever uma string no vídeo. A função printf() também pode imprimir o conteúdo de uma string que está armazenada em um vetor de caracteres. Nesse caso usa-se o parâmetro da própria de string (%s).
Ex. printf ():
char nome[] = “Maria Cristina”;
char sobrenome[] = “Silva”;
printf(“%s %s”, nome, sobrenome);
Ex. puts ():
puts (“Testando strings”);
• scanf () e gets ():A função scanf() permite a leitura de strings usando o formato %s. Para a leitura de strings a função permite ler apenas uma palavra, ou seja, a função lê todos os caracteres até encontrar um espaço em branco ou um TAB ou um ENTER. Para a leitura de strings a melhor a função é gets() da biblioteca stdio.h. A sintaxe para a função gets() é:
Ex. gets ():
gets ( nome_da_string );
Ex. scanf ();
scanf (“Maria %s”, &string);
• strlen (): retorna o tamanho, em caracteres, de uma string dada. Na verdade o strlen() procura o terminador de string e calcula a distância dele ao início da string. No exemplo abaixo, a variável “s” irá conter o valor 14:
char nome[15] = “Maria da Silva”;
int s = strlen (nome);
• strcpy (): esta função é utilizada para copiar o conteúdo de uma string para outra. No exemplo abaixo, a variável “nome” irá conter “José da Silva”:
char nome [] = “Maria José”;
char nome2 [] = “José da Silva”;
strcpy (nome, nome2);
• strcat ():Esta função é utilizada para concatenar duas strings, ou seja, o conteúdo de uma string é adicionado ao final de outra string. No exemplo abaixo, a variável “nome” passará a conter “Maria da Silva”:
char nome [50] = “Maria”;
char sobrenome [] = “ da Silva”;
strcat (nome, sobrenome);
2.3. DEFINIÇÃO DE ESTRUTURAS
As estruturas de dados consistem em criar apenas um dado que contém vários membros, que nada mais são do que outras variáveis. De uma forma mais simples, é como se uma variável tivesse outras variáveis dentro dela. A vantagem em se usar estruturas de dados é que podemos agrupar de forma organizada vários tipos de dados diferentes, por exemplo, dentro de uma estrutura de dados podemos ter juntos tanto um tipo float, um inteiro, um char ou um double.
2.4. CONSTRUÇÃO E IMPLEMENTAÇÃO DE ESTRUTURAS EM LINGUAGEM C
Para criar uma estrutura de dados usamos a palavra reservada struct. Toda estrutura deve ser criada antes de qualquer função ou mesmo da função principal main. Toda estrutura tem nome e seus membros são declarados dentro de um bloco de dados. Após a definição de seus membros no bloco de dados, terminamos a linha com um ponto-e-vírgula.
Ex.:
struct data {
int dia;
int mes;
int ano;
};
Lembrando que as variáveis contidas dentro da struct podem ser de qualquer outro tipo.
2.5. MODELAGEM E ULTILIZAÇÃO DE FUNÇÕES QUE MANIPULAM ESTRUTURAS
O uso mais comum em funções, é o uso de funções aninhadas, ou seja, uma função de controle dentro da outra. Assim, pode-se construir uma estrutura como um vetor, e usando funções aninhadas, podemos percorrer os índices dessa estrutura.
Ex.:
struct cadastro
{
char nome;
char endereco;
int tel;
} cad [20];
Note que essa estrutura é um vetor, que cabe até 20 cadastros dentro, contendo as variáveis de nome, endereço e telefone da pessoa a ser cadastrada. Para acessar esses dados, utilizamos a seguinte sintaxe:
cad[índice].nome;
cad é o nome da struct, o índice é a posição onde estão os valores das variáveis, ou seja, na posição 0 há uma cadastro, na posição 1 há outro e assim por diante. Para percorrer esse índice, utilizamos uma função de controle aninhada, como o exemplo do programa que será apresentado no próximo índice.
2.6. PROGRAMAÇÃO
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <iostream>
#include <conio2.h>
#include <conio.h>
using namespace std;
void menu ();
void sair ();
void limpaTela ();
void quebraTabula ();
void iul ();
void idl ();
void tabula ();
void calculo ();
void calculo1 ();
void calculo2 ();
void calculo3 ();
void calculo4 ();
void pesoteorico ();
void cadastro ();
void statuscadastro ();
void reverpedido ();
void ultimocadastro ();
char cliente1 [40];
int cad;
int contador2 = 0;
int Contador = 0;
int aux = 0;
int contador = 0;
struct pedidos
{
char cliente[40];
float largura;
float diametro;
float quilos;
float soma1;
float soma2;
float soma3;
int soma4;
float resto;
float porcentagem;
float porcentagemrefugo;
float refugo;
}ped [100];
int main (void)
{
menu ();
system("pause");
return 0;
}
void quebraTabula ()
{
printf ("\n\n\t");
}
void iul ()
{
printf ("\n");
}
void idl ()
{
printf ("\n\n");
}
void tabula ()
{
printf ("\t");
}
void sair ()
{
exit (1);
}
void limpaTela ()
{
system ("cls");
}
void menu ()
{
limpaTela ();
int opc;
printf ("Para calcular o peso te%cico de uma bobina filha, ou realizar cadastros de pedidos escolha a op%c%co abaixo: ", 162, 135, 198);
iul ();
quebraTabula ();
printf ("1 - Para calcular o peso te%crico de uma bobina filha", 162);
iul ();
tabula ();
printf ("2 - Para realizar cadastro de pedidos");
iul ();
tabula ();
printf ("3 - Para ver todos os cadastros realizados");
iul ();
tabula ();
printf ("4 - Sair do programa");
idl ();
printf ("Op%c%co: ", 135, 198);
scanf ("%d", &opc);
getchar ();
switch (opc)
{
case 1:
pesoteorico ();
break;
case 2:
cadastro ();
case 3:
statuscadastro ();
case 4:
sair ();
break;
default:
menu ();
}
}
void pesoteorico ()
{
limpaTela ();
int opc;
printf ("Para calcular o peso te%crico de uma bobina filha, escolha a op%c%co abaixo referente ao seu di%cmetro padr%co: ", 162, 135, 198, 131, 198);
quebraTabula ();
printf ("1 - Para bobinas com di%cmetro de 1000mm", 131);
iul ();
tabula ();
printf ("2 - Para bobinas com di%cmetro de 1150mm", 131);
iul ();
tabula ();
printf ("3 - Para bobinas com di%cmetro de 1200mm", 131);
iul ();
tabula ();
printf ("4 - Para bobinas com di%cmetro de 1500mm", 131);
iul ();
tabula ();
printf ("5 - Voltar ao menu anterior");
idl ();
printf ("Op%c%co: ", 135, 198);
scanf ("%d", &opc);
getchar ();
switch (opc)
{
case 1:
calculo1 ();
break;
case 2:
calculo2 ();
break;
case 3:
calculo3 ();
break;
case 4:
calculo4 ();
case 5:
menu ();
break;
default:
pesoteorico ();
break;
}
}
void calculo1 ()
{
limpaTela ();
char opc;
char opc2;
float N1,P;
printf ("A largura padr%co %c de 660 mm.", 198, 130);
idl ();
printf ("Deseja alterar a largura? (s/n): " );
scanf ("%c", &opc);
getchar ();
if (opc == 's')
{
iul ();
printf ("Insira a largura desejada: ");
scanf ("%f", &N1);
getchar ();
idl ();
P = N1 * (1000/1000) * 0.610;
printf ("O peso da bobina filha com a largura desejada ser%c de %.2f kg", 160, P);
idl ();
idl ();
printf ("Digite 1 para refazer o calculo ou 2 para voltar ao menu: ");
scanf ("%d", &opc2);
getchar ();
switch (opc2)
{
case 1:
calculo1 ();
break;
case 2:
pesoteorico ();
break;
default:
calculo1 ();
}
}
if (opc == 'n')
{
P = 660 * (1000/1000) * 0.610;
idl ();
printf ("O peso da bobina filha com a largura padr%co ser%c de %.2f kg", 198, 160, P);
idl ();
idl ();
printf ("Digite 1 para refazer o calculo ou 2 para voltar ao menu: ");
scanf ("%d", &opc2);
getchar ();
switch (opc2)
{
case 1:
calculo1 ();
break;
case 2:
pesoteorico ();
break;
default:
calculo1 ();
}
}
else
{
calculo1 ();
}
}
void calculo2 ()
{
limpaTela ();
char opc;
char opc2;
float N1,P;
printf ("A largura padr%co %c de 660 mm.", 160, 130 );
idl ();
printf ("Deseja alterar a largura? (s/n): " );
scanf ("%c", &opc);
getchar ();
if (opc == 's')
{
iul ();
printf ("Insira a largura desejada: ");
scanf ("%f", &N1);
getchar ();
idl ();
P = N1 * 1.15 * 0.678;
printf ("O peso da bobina filha com a largura desejada ser%c de %.2f kg", 160, P);
idl ();
idl ();
printf ("Digite 1 para refazer o calculo ou 2 para voltar ao menu: ");
scanf ("%d", &opc2);
getchar ();
switch (opc2)
{
case 1:
calculo2 ();
break;
case 2:
pesoteorico ();
break;
default:
calculo2 ();
}
}
if (opc == 'n')
{
P = 660 * 1150/1000 * 0.678;
idl ();
printf ("O peso da bobina filha com a largura padr%co ser%c de %.2f kg", 198, 160, P);
idl ();
idl ();
printf ("Digite 1 para refazer o calculo ou 2 para voltar ao menu: ");
scanf ("%d", &opc2);
getchar ();
switch (opc2)
{
case 1:
calculo2 ();
break;
case 2:
pesoteorico ();
break;
default:
calculo2 ();
}
}
else
{
calculo2 ();
}
}
void calculo3 ()
{
limpaTela ();
char opc;
char opc2;
float N1,P;
printf ("A largura padr%co %c de 660 mm.", 198, 130 );
idl ();
printf ("Deseja alterar a largura? (s/n): " );
scanf ("%c", &opc);
getchar ();
if (opc == 's')
{
iul ();
printf ("Insira a largura desejada: ");
scanf ("%f", &N1);
getchar ();
idl ();
P = N1 * 1.2 * 0.725;
printf ("O peso da bobina filha com a largura desejada ser%c de %.2f kg", 160, P);
idl ();
idl ();
printf ("Digite 1 para refazer o calculo ou 2 para voltar ao menu: ");
scanf ("%d", &opc2);
getchar ();
switch (opc2)
{
case 1:
calculo3 ();
break;
case 2:
pesoteorico ();
break;
default:
calculo3 ();}
}
if (opc == 'n')
{
P = 660 * 1.2 * 0.725;
idl ();
printf ("O peso da bobina filha com a largura padr%co ser%c de %.2f kg", 198, 160, P);
idl ();
idl ();
printf ("Digite 1 para refazer o calculo ou 2 para voltar ao menu: ");
scanf ("%d", &opc2);
getchar ();
switch (opc2)
{
case 1:
calculo3 ();
break;
case 2:
pesoteorico ();
break;
default:
calculo3 ();
}
}
else
{
calculo3 ();
}
}
void calculo4 ()
{
limpaTela ();
char opc;
char opc2;
float N1,P;
printf ("A largura padr%co %c de 660 mm.", 198, 130 );
idl ();
printf ("Deseja alterar a largura? (s/n): " );
scanf ("%c", &opc);
getchar ();
if (opc == 's')
{
iul ();
printf ("Insira a largura desejada: ");
scanf ("%f", &N1);
getchar ();
idl ();
P = N1 * 1.5 * 0.933;
printf ("O peso da bobina filha com a largura desejada ser%c de %.f kg", 160, P);
idl ();
idl ();
printf ("Digite 1 para refazer o calculo ou 2 para voltar ao menu: ");
scanf ("%d", &opc2);
getchar ();
switch (opc2)
{
case 1:
calculo4 ();
break;
case 2:
pesoteorico ();
break;
default:
calculo4 ();}
}
if (opc == 'n')
{
P = 660 * 1.5 * 0.933 ;
idl ();
printf ("O peso da bobina filha com a largura padr%co ser%c de %.2f kg", 198, 160, P);
idl ();
idl ();
printf ("Digite 1 para refazer o calculo ou 2 para voltar ao menu: ");
scanf ("%d", &opc2);
getchar ();
switch (opc2)
{
case 1:
calculo4 ();
break;
case 2:
pesoteorico ();
break;
default:
calculo4 ();
}
}
else
{
calculo4 ();
}
}
void cadastro ()
{
limpaTela ();
int opc;
printf ("Quantos pedidos deseja realizar?: ");
idl ();
printf ("N%cmero de pedidos: ", 163);
scanf ("%d", &cad);
aux = aux + cad;
getchar ();
idl ();
if (cad > 100 || cad <=0)
{
printf ("O numero maximo de cadastros suportados %c 100!", 130);
idl ();
printf ("Aperte qualquer tecla para inserir outro valor...");
idl();
system ("PAUSE > 0");
cadastro ();
}
else
{
for (contador = aux-cad; contador < aux; contador++)
{
Contador = aux;
idl ();
printf("Pedido n%cmero %d ",163, contador+1);
idl ();
printf ("Informe o nome do cliente: ");
gets (ped[contador].cliente);
printf ("Insira a quantidade de quilos desejada: ");
scanf ("%f" , &ped[contador].quilos);
getchar();
iul();
printf ("Insira a largura desejada: ");
scanf ("%f" , &ped[contador].largura);
getchar();
iul();
printf ("Insira o di%cmetro externo desejado: ", 131);
scanf ("%f", &ped[contador].diametro);
getchar();
ped[contador].soma1 = ped[contador].soma1 + ped[contador].quilos;
ped[contador].soma2 = ped[contador].soma2 + ped[contador].largura;
ped[contador].soma3 = ped[contador].soma3 + ped[contador].diametro;
ped[contador].soma4 = ped[contador].soma2 / 2450;
ped[contador].resto = fmod (ped[contador].soma2 , 2450);
ped[contador].porcentagem = (ped[contador].resto * 100) / 2450;
ped[contador].refugo = 2450 - ped[contador].resto;
ped[contador].porcentagemrefugo = (ped[contador].refugo * 100) / 2450;
idl();
idl();
}
}
printf ("Cadastro realizado com sucesso!");
idl ();
printf ("Digite 1 voltar ao menu ou digite 2 para ir a tela de status do pedido: ");
idl ();
scanf ("%d", &opc);
getchar ();
idl ();
switch (opc)
{
case 1:
menu ();
break;
case 2:
statuscadastro ();
break;
default:
menu;
}
}
void statuscadastro ()
{
int opcc;
limpaTela ();
if (Contador == 0)
{
printf ("Nao h%c pedidos cadastrados!", 160);
idl ();
system ("pause");
menu ();
}
else
{
for(contador=0; contador < aux ; contador++)
{
printf ("Segue abaixo os dados do pedido do Sr. ");
printf (ped[contador].cliente);
idl ();
printf ("Quantidade em quilos: %2.fkg", ped[contador].soma1);
idl ();
printf ("Largura total: %2.fmm", ped[contador].soma2);
idl ();
printf ("Di%cmetro total: %2.fmm", 131, ped[contador].soma3);
idl ();
printf ("Ir%c ser utilizado %d bobinas jumbo mais %2.f por cento de outra bobina, equivalente %c %2.fmm. ",160, ped[contador].soma4, ped[contador].porcentagem, 133, ped[contador].resto);
idl();
printf ("O ref%cgo comercial ser%c de %2.f por cento da bobina jumbo, equivalente %c %2.fmm.", 163, 160, ped[contador].porcentagemrefugo, 133, ped[contador].refugo);
idl();
idl();
idl();
}
}
system ("PAUSE");
menu ();
}
REFERÊNCIAS
MIZRAHI, Victorine Viviane. Treinamento em Linguagem C. 1 ed. São Paulo: Pearson Educacional do Brasil Ltda., 2008.
C/C++: Operadores Lógicos & Controle de Fluxo. Disponível em: <http://robertcg.wordpress.com/2009/12/15/operadores-logico-controle-de-fluxo/>. Acesso em 01 de Out. 2014.
Apostila, Fundamentos de linguagem C. Disponível em: <http://www.dca.ufrn.br/~lmarcos/courses/DCA800/apostila_C.pdf>. Acesso em 01 de Out. 2014.
...