Algoritmos e programação

Prévia do material em texto

`
FACULDADE ANHANGUERA EDUCACIONAL
ENGENHARIAS: MECÂNICA E ELÉTRICA 
ATIVIDADES PRÁTICAS SUPERVISIONADAS
- ALGORITSMOS E PROGRAMAÇÃO -
Anápolis
2013
Edilson A. de Sousa Filho (5899076586)
Magdiel Ramos Rodrigues (5670128594)
Marcos Antônio M. da Costa (5222985910)
Thalles Jose da Silva (5899076605)
Victor Paulo Pena (3245555911)
ATIVIDADES PRÁTICAS SUPERVISIONADAS
- ALGORITMOS E PROGRAMAÇÃO -
Trabalho apresentado a Disciplina de Algoritmos e Programação
sobre a teoria de Programação, para composição
da nota do curso de Engenharia da Faculdade Anhanguera.
Prof. Jefferson
Anápolis
2013
SUMÁRIO
INTRODUÇÃO ......................................................................................................................04
ETAPA 1
1. CONCEITOS FUNDAMENTAIS DE PROGRAMAÇÃO ...............................................05
1.1. Peso Teórico ......................................................................................................................07
ETAPA 2
2. PROGRAMAÇÃO ESTRUTURADA ................................................................................08
2.1. Aproveitamento da Bobina ...............................................................................................10
 ETAPA 3
3. VETORES, MATRIZES E FUNÇÕES .............................................................................12
3.1. Modularização do Programa .............................................................................................14
ETAPA 4
4. STRINGS E TIPOS ESTRUTURADOS ..........................................................................15
5. CONCLUSÃO .................................................................................................................... 17
6. REFERÊNCIAS BIBLIOGRAFICAS...............................................................................18
INTRODUÇÃO
		Este trabalho tem como objetivo mostrar a noção de programação para o curso de engenharia, neste caso, o de engenharia mecânica. Os relatórios dirigidos como relatórios 1,2,3 e 4 são apresentados em formas de tópicos ao longo do trabalho, apresentando a proposta pedida na atividade pratica supervisionada.							Ao fim deste, será possível conceber, projetar e analisar sistemas, produtos e processos, assim como identificar, formular e resolver problemas de engenharia que envolvem programação. Com isso será possível desenvolver ou utilizar ferramentas e técnicas que serão vistas, a fim de atuar em grupo para a resolução de problemas. 						A programação efetuada neste trabalho foi simulado e compilada no programa DevC++, que auxilia na formação da programação e é uma ferramenta muito útil na vida acadêmica do engenheiro, principalmente nas áreas voltadas a computação e elétrica.
1. CONCEITOS FUNDAMENTAIS DE PROGRAMAÇÃO
		Um algoritmo pode ser definido como uma sequência finita de passos (instruções) para resolver um determinado problema. Sempre que desenvolvemos um algoritmo estamos estabelecendo um padrão de comportamento que deverá ser seguido (uma norma de execução de ações) para alcançar o resultado de um problema.					São propriedades de algoritmos:
ações simples e bem definidas (não ambíguas);
sequência ordenada de ações;
sequência finita de passos.
		
		Um algoritmo quando programado num computador é constituído pelo menos das 3 partes, sendo elas:
		1. Entrada de dados;
		2. Processamento de dados;
		3. Saída de dados;
		Na parte de entrada, são fornecidas as informações necessárias para que o algoritmo possa ser executado. Estas informações podem ser fornecidas no momento em que o programa está sendo executado ou podem estar embutidas dentro do mesmo. Na parte do processamento são avaliadas todas as expressões algébricas, relacionais e lógicas, assim como todas as estruturas de controle existentes no algoritmo (condição e/ou repetição). Na parte de saída, todos os resultados do processamento (ou parte deles) são enviados para um ou mais dispositivos de saída, como: monitor, impressora, ou até mesmo a própria memória do computador.													A pseudo-linguagem (ou pseudocódigo)é uma maneira intermediária entre a linguagem natural e uma linguagem de programação de representar um algoritmo. Ela utiliza um conjunto restrito de palavras-chave, em geral na língua nativa do programador, que tem equivalentes nas linguagens de programação. Além disso, a pseudo-linguagem  não requer todo a rigidez sintática necessária numa linguagem de programação, permitindo que o aprendiz se detenha na lógica do algoritmos e não no formalismo da sua representação. Na medida que em se obtém mais familiaridade com os algoritmos, então o pseudocódigo pode ser traduzido para uma linguagem de programação.								Na área de programação usa-se operadores aritméticos, lógicos e relacionais. Operadores Aritméticos são utilizados na resolução de expressões matemáticas utilizando quaisquer valores, sejam eles constantes ou variáveis. Retorna um inteiro se todos os valores são inteiros ou um real se um ou mais valores são reais.							Exemplo de operadores aritméticos:
+ soma
- subtração
* multiplicação
/ divisão
módulo: resto de uma divisão
^ potenciação
		Operadores Relacionais são utilizados para estabelecer uma relação entre operador e operando. Retorna sempre um booleano; true para uma relação verdadeira e falsa para uma relação falsa.										Exemplo de operadores relacionais:
> maior que
< menor que
<> ou != diferente de
>= maior ou igual a
<= menor ou igual a
	Operadores Lógicos são utilizados para estabelecer relação entre valores lógicos. Retornam sempre um booleano pois sua utilização é dada quase sempre pela combinação de operadores relacionais.											Exemplo de operadores Lógicos:
AND ou && "E"
OR ou || "Ou"
NOT ou ! "negação"
1.1. Peso Teórico
		Para o peso teórico, temos o seguinte calculo:
		Peso = Largura * Diâmetro Externo * Peso por metro Linear / 1000
		Sabendo disso, e possível elaborar um modelo para o calculo do peso teórico, declarando os tipos de variáveis que utilizaremos no restante do programa. Com isso, temos:
#include <stdio.h>								
int main ( ){
float pesoteorico,largura,diametroext;float pml;
printf("Largura da Bobina: ");
scanf("%f",&largura);
printf("Diametro Externo da Bobina: ");
scanf("%f",&diametroext);
printf("Peso por metro Linear da Bobina: ");
scanf("%f",&pml);
pesoteorico=largura*diametroext*pml/1000;
printf("O Peso da Bobina e: %.2f kg \n",pesoteorico);
getchar();getchar();
return 0;
}
2. PROGRAMAÇÃO ESTRUTURADA
		C é uma linguagem de programação compilada de propósito geral, estruturada, imperativa padronizada pela ISO, criada em 1972. C é uma das linguagens de programação mais populares e existem poucas arquiteturas para as quais não existem compiladores para C. C tem influenciado muitas outras linguagens de programação, mais notavelmente C++, que originalmente começou como uma extensão para C.							C tem como ponto forte, a sua eficiência, e é a linguagem de programação preferida para o desenvolvimento de sistemas e softwares de base, apesar de também ser usada para desenvolver programas de computador. É também muito usada no ensino de ciência da computação, mesmo não tendo sido projetada para estudantes e apresentando algumas dificuldades no seu uso. Outra característica importante de C, é sua proximidade do código de máquina, que permite que um projetista seja capaz de fazer algumas previsões de como o software irá se comportar, ao ser executado.							C tem como ponto fraco, a falta de proteção que dá ao programador. Praticamente tudo que se expressa em um programa em C, pode ser executado, como por exemplo, pedir o vigésimo membro de um vetor com apenas dez membros. Os resultados são muitas vezes totalmente inesperados, e os erros, difíceis de encontrar.					A linguagem C é considerada de alto nível em vista de outros métodos para implementação de algoritmos no ramoda computação. A linguagem C, apesar de muito usada, necessita de um bom leiaute. Portanto alguns pontos são evitados pelos programadores, que buscam deixar o programa de forma limpa e clara para que esta lendo e executando a ação.														Na linguagem C usa-se bastante a estrutura do laço para executar alguns programas. Laços são comandos usados sempre que uma ou mais instruções tiverem de ser repetidas enquanto uma certa condição estiver sendo satisfeita. Em C existem três comandos de laços:
For
While
Do-While
		O laço for é geralmente usado quando queremos repetir algo por um 
número fixo de vezes. Utilizamos quando sabemos de antemão o número de vezes a repetir. Utilizamos o laço while quando o laço pode ser terminado inesperadamente, por condições desenvolvidas dentro do corpo. E por fim o laço do-while é utilizado em situações em que é necessário executar o corpo do laço uma primeira vez, logo após, avaliar a expressão de teste e criar um ciclo repetido. Estes tipos de condicionamento serão visualizados ao longo do programa a ser executado.											Outro ponto são as estruturas para tomadas de Decisão na linguagem C. Os comandos de decisão permitem determinar qual é a ação a ser tomada com base no resultado de uma expressão condicional. Os dois comandos básicos para tomadas de decisões são: if-else e swith-case. Alem destes podemos citar outros que nem sempre são usados, mas também satisfazem esta parte, que são: break e continue, e goto.							If é uma estrutura de definição que tem o objetivo de testar se a condição passado é verdadeira, caso seja ele entra dentro do bloco de if, e dentro do bloco de if caso não seja ele entra dentro do bloco de else onde a decisão é satisfatória. 
Sintaxe:
	
	
		SWITCH é uma declaração de múltipla escolha, diferente do if que caso tenha uma lista de escolha a ser montada não fica elegante e dependendo a extensão do programa fica difícil a manutenção.
Sintaxe:
2.1. Aproveitamento da Bobina
		Nesta parte sera apresentada uma nova parte do programa, baseado no que ja foi desenvolvido na parte 01 do trabalho. Assim, temos:
#include<stdio.h> 
main(){
int j; int i=0									
float q,L,h;											printf("Digite quantidade de pedidos: ");							scanf("%i",&j);										while (i = j)											{												printf("Digite o Peso em quilos: ");								scanf("%f",&q);										printf("Digite a largura em milimetros: ");							scanf("%f",&L);}
printf("Digite a altura em milimetros: ");					
scanf("%f",&h);
i++;
}
float NbobinasJumbo, perdacomercial, totalLBobinas;	
 NbobinasJumbo=j/pesoteorico	;							printf("O numero de bobinas Jumbo com 2.450mm e %.2f: ",NbobinasJumbo);		perdacomercial = 1 - (totalLBobinas/2450);							printf("A perda comercial foi de %.2f: ",perdacomercial);	
3. VETORES, MATRIZES E FUNÇÕES 
		Um vetor é uma seqüência de vários valores do mesmo tipo, armazenados seqüencialmente na memória, e fazendo uso de um mesmo nome de variável para acessar esses valores. Um vetor também pode ser entendido logicamente como uma lista de elementos de um mesmo tipo. Cada elemento desta seqüência pode ser acessado individualmente através de um índice dado por um número inteiro. 								Os elementos são indexados de 0 até n-1, onde n é a quantidade de elementos do vetor. O valor de n também é chamado de dimensão ou tamanho do vetor. A declaração de vetores obedece à mesma sintaxe da declaração de variáveis. A diferença está no valor entre colchetes, que determina quantos elementos ele armazenará, ou seja, em outras palavras, determina o seu tamanho ou dimensão. 									Por exemplo, para declarar um vetor com 10 números inteiros: 
				int vetor [10];
		Uma matriz é uma estrutura de dados que pode armazenar vários valores do mesmo tipo. A sintaxe para declarar uma matriz é:
				TIPO NOME[QUANTIDADE];
onde TIPO é o tipo dos dados que serão armazenados na matriz. Todos os dados colocados na matriz devem ser deste tipo. NOME é o nome a ser dado a matriz. Este nome identificará a matriz no código do programa. EQUANTIDADE é a quantidade máxima de itens a ser armazenados.													Uma das matrizes mais comuns utilizadas em C é a matriz de caracteres. As strings manipuladas em C são matrizes de caracteres.
		Outro ponto importante na linguagem C é a modularizacao. Exemplos de modularização, i.e., sistemas que são compostos por módulos com funções bem definidas e tão independentes quanto possível, são bem conhecidos.  Por exemplo, a maior parte dos sistemas de alta fidelidade para audiófilos são compostos por módulos: o amplificador, o equalizador, o leitor de CD, o sintonizador, o leitor de cassetes, etc.
A divisão dum sistema em módulos tem várias vantagens.  Para o fabricante, por um lado, a modularização tem a vantagem de reduzir a complexidade do problema, dividindo-o em sub-problemas mais simples, que podem inclusivamente ser resolvidos por equipas independentes.  Até sob o ponto de vista do fabrico é mais simples alterar a composição de um módulo, por exemplo porque se desenvolveram melhores circuitos para o amplificador, do que alterar a composição de um sistema integrado.  Por outro lado, é mais fácil detectar problemas e resolvê-los, pois os módulos são, em princípio, razoavelmente independentes.  Claro que os módulos muitas vezes não são totalmente independentes.  Por exemplo, o sistema de controlo à distância duma aparelhagem implica interação com todos os módulos simultaneamente.												A arte da modularização está em identificar claramente que módulos devem existir no sistema, de modo a garantir que as ligações entre os módulos são minimizadas e que a sua coesão interna é máxima.  Isto significa que, no caso dum bom sistema de alta fidelidade, os cabos entre os módulos são simplificados ao máximo e que os módulos contêm apenas os circuitos que garantem que o módulo faz a sua função.  A coesão tem portanto a ver com as ligações internas a um módulo, que idealmente devem ser maximizadas.  Normalmente, um módulo é coeso se tiver uma única função, bem definida. 				É comum em programação decompor programas complexos em programas menores e depois juntá-los para compor o programa final. Essa técnica de programação é denominada programação modular. A programação modular facilita a construção de programas grandes e complexos, através de sua divisão em pequenos módulos, ou subprogramas, mais simples. Estes subprogramas alem de serem mais simples de serem construídos, são também mais simples de serem testados. Esta técnica também possibilita o reaproveitamento de código, pois podemos utilizar um módulo quantas vezes for necessário eliminando a necessidade de escrevê-lo repetidamente.							Outro aspecto importante da modularização é a possibilidade de vários programadores trabalhem simultaneamente na solução de um mesmo problema, através da codificação separada dos módulos. Assim, cada equipe pode trabalhar em um certo conjunto de módulos ou subprogramas.										Há duas formas de passagem de parâmetros: 
			- Passagem de parâmetros por valor. 
			- Passagem de parâmetros por referência. 
		A passagem de parâmetros por valor é a forma que temos usado em todos os exemplos até agora. Dizemos que parâmetros passados por valor são parâmetros de entrada. O valor do argumento é passado para dentro da função através dos parâmetros. Assim, os parâmetros recebem os valores dos argumentos. Na passagem de parâmetro por referência não é criado um novo espaço de memória para o parâmetro. O que acontece é que o parâmetro vai usar o mesmo espaço de memória usado pelo argumento. Nesse caso é passado como argumento um ponteiro para a variável e não o seu valor.
3.1. Modularização do Programa
		Para armazenar valores, substituindo o modelo da etapa 02, utilizando vetores, como exemplo, um numero de pedidos igual a 10, pode-se utilizar a seguinte função:
	int i, vetor [10];
	printf ("Digite os valores dos pedidos: ");
	for ( i=0 ; i<=10 ; i++);
	scanf ( "%d", &vetor[i]);
	
4. STRINGS E TIPOS ESTRUTURADOS
		Na linguagem C uma string é um vetor de caracteres. Porém, obrigatoriamente um dos caracteres do vetor deve ser o caractere nulo, ou seja, o '\0'. O caractere nulo sucede o último caractere válido da string em questão. Para declarar uma string, podemos usar o seguinte formato geral: 
char nome_da_string [tamanho];
		A biblioteca padrão string da linguagem C contém várias funções de manipulação de string. Para usar essas funções, o seu programa deve incluir o arquivo-interface "string.h". As cadeias de caracteres da linguagem C podem formatar um novo tipo de dados, porém criar tipos de dados mais sofisticados não é possível nesta linguagem, as strings em C++ são objetos da classe string, o que isso traz de novo para o tratamento de textos em programas? A primeira coisa a notar quando criamos strings em C++ é a maneira de criá-las, a classe disponibiliza uma série de construtores.							Isto torna possível, basicamente, criar string de seis maneiras diferentes:
Podemos definir um objeto string vazio, para futuramente usarmos de acordo com a necessidade;
Podemos criar um objeto string com uma cópia de outro;
Podemos criar um objeto string com uma cópia de uma porção de outra string;
Podemos criar um objeto string com uma cópia de uma parte de uma "char string";
Podemos criar um objeto string com uma cópia de uma "char string";
Podemos criar um objeto string preenchida com uma quantidade definida de um determinado caractere;
		A estrutura de dados array é usada para conter dados do mesmo tipo junto. Dados de tipos diferentes também podem ser agregados em tipos chamados de estruturas ou registros (tipo struct em linguagem C). Primeiro, o tipo estrutura é declarado (precisamos especificar que tipos de variáveis serão combinados na estrutura), e então variáveis deste novo tipo podem ser definidas (de maneira similar que usamos para definir variáveis do tipo int ou char).										Uma declaração de estrutura declara um tipo struct. Cada tipo struct recebe um nome (ou tag). Refere-se àquele tipo pelo nome precedido pela palavra struct. Cada unidade de dados na estrutura é chamada membro e possui um nome de membro. Os membros de uma estrutura podem ser de qualquer tipo. Declarações de estrutura não são definições. Não é alocada memória, simplesmente é introduzida um novo tipo de estrutura.				Geralmente declarações de estruturas são globais. Elas são colocadas próximas ao topo do arquivo com o código fonte do programa, assim elas são visíveis por todas as funções (embora isto dependa de como a estrutura está sendo usada).A forma padrão de declaração de uma estrutura é:
struct nome-estrutura {
declaração dos membros
} definição de variáveis (optional);
	
5. CONCLUSÃO
		Com o trabalho realizado, foi possível observar o uso da linguagem C/C++ na área de engenharia, a importância desta ferramenta na engenharia, assim como a aplicação dela na resolução de problemas.										O trabalho desenvolvido trouxe um aprofundamento na disciplina de algoritmo e programação, salientando o uso da programação no ambiente de trabalho atual. Assim foi possível ver que a programação e o conhecimento desta é de grande valia na engenharia atual, não são sendo útil na engenharia da computação, mas em todas as outras em geral, sendo a grande ferramenta do engenheiro hoje.													
REFERÊNCIAS BIBLIOGRÁFICA
MIZRAHI, Victorine Viviane. Treinamento em Linguagem C. 1ª ed. São Paulo: Pearson, 2007.
SCHILDT, Herbert. Linguagem C - Guia do Usuario. McGraw-Hill, 1986.