ATPS ALGORITMOS E PROGRAMAO

Engenharia de Produo
Professor: Eriovaldo Coelho Magalhes

NOME: FABIANO GALDINO MOREIRA NOME: NELSON GABRIEL DE GODOI NOME: JOSIAS CUSTDIO JUNIOR NOME: LEANDRO DE ANDRADE DOMINGOS

RA: 5222980262 RA: 5212967730 RA: 5638119576 RA: 5667749592

INDICE
APRESENTAO ETAPA 2 PROGRAMAO ESTRUTURADA 1 - Definies de operadores 1.1-Operadores aritmticos 1.2-Operadores de incremento e decremento 1.3-Operadores aritmticos de atribuies 1.4-Operadores relacionais 1.5-Operadores lgicos 1.6-Operadores bit a bit 1.7-Operador cast 1.8-Operador sizeof 2 - Precedncias 3 - Controle de fluxo 3.1-Instrues condicionais 4 - Operador ternario 4.1- switch 5 - Estrutura de repetio 5.1-Lao for 5.2-Lao while 5.3-Lao do-while 5.4-Desvio incondicional 5.5-Comando goto Passo 3 - Exercicios ETAPA 3 VETORES E MATRIZES, MODULARIZAO 1-Vetores 1.1-Inicializao 1.2-Vetores como argumentos de funes 1.3- Vetores de caracteres 1.3.1-A funo strlen() 1.3.2-A funo strcmp() 1.3.3-A funo strcpy() 1.3.4-A funo atrcat() 2 - Matrizes 2.1 - Inicializao 2.2 - Matrizes como argumento de funes 3 - Modularizao 3.1 - Introduo 3.2 - Procedimentos 3.3 Funes 3.3.1 - Prottipos de Funes 3.3.2 - Escopo de Variveis 3.3.2.1 - Variveis locais 3.3.2.2 - Parmetros formais 3.3.2.3 - Variveis globais 3.3.3 - Passagem de parmetros por valor e passagem por referncia 3.4 Funes recursivas 3.5 - Estruturao de mdulos de um algoritmo ETAPA 4 STRINGS E RELATRIOS ESTRUTURADOS 1 - Strings 2 - Manipulando strings 3 - Definio de Estruturas 3.1 - Declarando uma estrutura 3.2 - Declarando variveis do tipo de uma estrutura criada 3.3 - Acessando os campos de uma estrutura 3.4 - Acessando uma estrutura com ponteiros Passo 3 Exercicios ETAPAS 3 e 4 CONCLUSO E BIBLIOGRAFIA

ETAPA 2 PROGRAMAO ESTRUTURADA

1 - Definio dos Operadores
Os operadores indicam ao compilador a necessidade de se fazer manipulaes matemticas ou lgicas.

1.1 - Operadores aritmticos

Os operadores aritmticos so usados para calcular expresses matemticas. Sendo classificados em duas categorias: os binrios ou unrios. Os operadores unrios atuam na inverso de valores. Veja a tabela abaixo.

Operador binrio = + / %

Descrio Atribuio Soma Subtrao Diviso Modulo (obtm o resto da diviso)

Operador unrio +

Ao Sinal negativo Sinal positivo

1.2 - Operadores de incremento e decremento

O operador de incremento (++) soma 1 ao seu operando enquanto que o de decremento (--) subtrai um. Eles podem ser pr-fixados ou ps-fixados conforme mostra a tabela abaixo:

Operador ++

Instruo var = var+1;

Ps-fixado

Pr-fixado

var = var++; var = ++var; ou ou var++; ++var; var = var--; ou var--; var= --var; ou --var;

--

var = var-1;

No caso das instrues mostradas acima no existe diferena, podemos aplicar tanto o ps-fixado quanto o prfixado. Mas quando esses operadores so usados em outras expresses necessita-se de cuidado, pois o uso incorreto pode ocasionar resultados inesperados. A diferena entre eles que o pr-fixado incrementa a varivel para depois executar a instruo e a ps-fixado executa a instruo para depois fazer o incremento da varivel. Veja o exemplo abaixo:

O programa acima incrementa a varivel var e coloca o valor na var2 que no nosso caso ser 6. J o cdigo abaixo coloca o valor da varivel var na var2 que 5 para depois incrementar a varivel var.

Sada do programa: var=6 var2=5

1.3 - Operadores aritmticos de atribuies

So combinaes de operadores que simplificam as instrues e que geralmente so usados por programadores experientes. Dessa forma uma instruo escrita da forma: Var= var operador + expresso Pode ser reduzida obedecendo sintaxe: Var operador= expresso Veja alguns exemplos utilizando duas variveis (var e expr) que devem ser declaradas em seus programas.

Instruo normal var = var + expr; Var=var expr; Var=var/expr; Var=var*expr;

Instruo reduzida var+=expr; Var-=expr; Var/=expr; Var*=expr;

1.4 - Operadores relacionais

Esses operadores so responsveis pelas comparaes de expresses nos programas. A lista completa se encontra abaixo:

Operador > >= < <= == !=

Descrio Maior Maior igual Menor Menor igual Igualdade Diferente

importante distinguir (=) de (==). O primeiro atribui um valor e o segundo comprara expresses.

1.5 - Operadores lgicos

Os operados lgicos servem para interligar mais de uma operao relacional. E assim como os relacionais retornam zero para falso e um para verdadeiro.

Operador && || !

Descrio AND OR NOT (operador de negao)

Exemplo de utilizao de operadores lgicos:

Sada do programa: O nmero 76 esta entre 65 e 80 Nesse programa o operador lgico (&&) faz a ligao das operaes relacionais (x>65) e (x<=80), verificando se o nmero dado (x) est entre essa faixa. A instruo if ser estudada no prximo artigo.

1.6 - Operadores bit a bit

Como j sabemos a linguagem C considerada de baixo nvel, pois permite a manipulao de bits. Isto feito atravs dos operadores bit a bit listados a seguir.

Operador & | ^ << >>

Descrio AND OR XOR (OR exclusivo) Deslocamento para esquerda Deslocamento para direita

Embora a descrio na tabela seja parecida com as dos operadores Lgicos eles no devem ser confundidos. Os operadores bit a bit so muito usados em rotinas de modens e de impressoras.

1.7 - Operador Cast

Tem como funo forar para que uma expresso seja de um determinado tipo. Sua sintaxe : (tipo de dado) expresso O tipo de dado pode ser qualquer um dos definidos pelo padro ANSI. Um exemplo da utilizao deste operador pode ser visto no programa mostrado neste artigo para exemplificar o uso dos operadores aritmticos. Nesse programa o operador cast usado para forar a diviso de dois nmeros inteiros ser do tipo float.

1.8 - Operador Sizeof

Este operador usado em tempo de execuo e tem como objetivo retornar o tamanho em bytes da varivel.

Sada do programa: A variavel x do tipo float tem o tamanho=4 bytes A variavel y do tipo double tem o tamanho=8 bytes A variavel z do tipo char tem o tamanho=1 bytes

2 - Precedncias
Precedncia a prioridade com que os operadores so executados pelo compilador. Caso os operadores tenham o mesmo nvel de precedncia eles so analisados da esquerda para direita.

Prioridades dos operadores aritmticos Alta Incremento(++), decremento (--) Menos unitrio (-) Multiplicao(*), diviso(/), modulo(%) Baixa Soma(+), subtrao(-)

A precedncia dos operadores pode ser mudada utilizando parentes. Para entender melhor veja o exemplo abaixo, onde as duas expresses so iguais, porm o uso de um parntese fez mudar a precedncia obtendo assim resultados diferentes. 4/2*5+1=11 4/2*(5+1)=12

3 - Controle de Fluxo
Os comandos de controle de fluxo podem ser divididos em trs grupos: Instrues condicionais, estrutura de repetio e os desvios incondicionais que sero apresentados a seguir.

3.1 - Instrues Condicionais

As instrues condicionais existentes no padro ANSI so: if, switch e o operador ternrio (?). Instruo If Esta instruo obedece sintaxe: if (condio) instruo para condio verdadeira ; else instruo para condio falsa; Pode-se utilizar uma ou mais instrues verdadeiras e falsas no if. Caso seja mais de uma deve-se colocar entre chaves. Se a condio verdadeira sero executadas apenas as instrues localizadas aps a instruo if. Caso contrario somente as instrues aps o else sero executadas. O else opcional conforme mostra o exemplo abaixo que efetua a soma de dois nmeros e avisa ao usurio quando o resultado obtido for um nmero par.

#include<stdio.h> void main() { int num1,num2,soma; printf("Digite o primeiro valor inteiro a ser somado:"); scanf("%d",&num1); printf("Digite o segundo valor inteiro a ser somado:"); scanf("%d",&num2); soma=num1+num2; printf("Soma: %d ",soma); if((soma%2)==0) printf(" - numero par\n"); } No programa acima usada a instruo scanf que ser ensinada num prximo artigo. O importante agora saber que ela a responsvel pela entrada de dados pelo console. Abaixo pode ser visto a entrada do usurio e sada do programa. Digite o primeiro valor inteiro a ser somado: 2 Digite o segundo valor inteiro a ser somado: 4 Soma:6 numero par Esse mesmo programa pode ser reescrito para que avise tambm ao usurio quando o resultado um numero impar. #include<stdio.h> void main() { int num1,num2,soma; printf("Digite o primeiro valor inteiro a ser somado:"); scanf("%d",&num1); printf("Digite o segundo valor inteiro a ser somado:"); scanf("%d",&num2); soma=num1+num2; printf("Soma: %d ",soma); if((soma%2)==0) printf(" - numero par\n"); else printf(" - numero impar\n"); } Isto feito acrescentando o else a instruo if. Desta forma, o programa verifica se o resto da soma dividido por dois igual a 0, caso seja ser impresso na tela que o valor par. Caso contrario ser impresso que a soma se trata de um numero impar. A linguagem C padro tambm permite o uso de ifs alinhados, obedecendo forma: If(condio) Instruo; Else If(condio) Instruo; Else If(condio) Instruo; . . . Else Instruo;

Para entender melhor veja o prximo exemplo:

#include<stdio.h> void main() { float nota; printf("Digite o valor da nota(numero):"); scanf("%f",&nota); if((nota>=8)&&(nota<=9)) printf("Nota correspondente a A!!!\n"); else if((nota>=6)&&(nota<=7)) printf("Nota correspondente a B!!!\n"); else if((nota>=4)&&(nota<=5)) printf("Nota correspondente a C!!!\n"); else if((nota>=2)&&(nota<=3)) printf("Nota correspondente a D!!!\n"); else if((nota>=0)&&(nota<=1)) printf("Nota correspondente a E!!!\n"); else printf("Nota invalida!!!\n"); }

4 - O operador ternrio (?)

O operador ? muito utilizado no lugar da instruo if. Este operador requer trs operando e pode ser escrito da seguinte forma: Exp1? Exp2: Exp3 Neste exemplo o usurio entra com o valor de x, se o valor de x for menor ou igual a 0 ento o valor de x incrementado de 1 atribudo a y. De outra forma o y ter o valor de x decrementado de 1. #include<stdio.h> void main() { int x,y; printf("digite um numero inteiro:\n"); scanf("%d",&x); y=x<=0 ? x+1 : x-1; printf("y:%d\n",y); }

4.1 - Switch
Sua sintaxe : switch(expresso){ case constante1: seqncia de comandos break; case constante2: seqncia de comandos break; case constante3: seqncia de comandos break; . . . default: seqncia de comandos

Esta instruo compara a expresso com todas as constantes caso seja verdadeira ela executa as seqncias de comandos daquela constante. Caso todas as alternativas sejam falsas o comando default executado. A instruo break demonstrada acima opcional, ela que para a execuo do switch case. O Padro ANSI permite usar 257 comandos case. O comando switch compara apenas igualdades, enquanto que o if comparar qualquer expresso lgica ou relacional. Como exemplo ser criado um menu para que o usurio escolha entre fazer a soma de dois nmeros ou calcular a media. #include<stdio.h> void main() { int entrada; printf("Digite 1 para calcular printf("Digite 2 para calcular scanf("%d",&entrada); switch(entrada){ case 1: printf("Vc escolheu a opcao de case 2: printf("Vc escolheu a opcao de default: printf("Nenhuma das opcoes foi } }

a soma de dois numeros\n"); a media\n");

somar dois numeros"); calcular a media"); selecionada");

5 - Estrutura de repetio
As estruturas de repetio so utilizadas para que um conjunto de instrues seja executado at que ocorra uma certa condio. O lao for diferencia dos restantes( while e do-while) por ter condies pr-definidas, ou seja, o numero de vezes a ser executada j conhecido.

5.1 - Lao for

Sintaxe do lao: For(inicializao; condio ; incremento) comando; Na inicializao atribudo um valor para variavel que controla o lao, a condio determina quando o lao deve ser encerrado e por ultimo temos o quanto a varivel controladora incrementada. Exemplo simples: #include<stdio.h void main() { int n; for(n=1; n<=10; n++) printf("n=%d\n",n); } No programa acima o for iniciamos a varivel n com o valor, a instruo que escreve o valor de n ser executada enquanto n for menor ou igual a 10, sendo que n incrementada de 1 em iterao. Sendo assim a sada do programa ser: n=1 n=2 n=3 n=4 n=5 n=6 n=7 n=8 n=9 n=10

5.2 - Lao While

Sua forma geral :

while (condio) Instruo; Este lao executa a instruo at que a condio se torne falsa (qualquer valor diferente de zero). #include<stdio.h> void main() { int n1,n2,soma,resposta; resposta=1; while(resposta==1) { printf("Digite valor de n1(inteiro):\n"); scanf("%d",&n1); printf("Digite valor de n2(inteiro):\n"); scanf("%d",&n2); soma=n1+n2; printf("Soma:%d\n",soma); printf("Deseja continuar? (1 - sim / 2 - nao)\n"); scanf("%d",&resposta); while((resposta!=1) && (resposta!=2)) { printf("Digite 1 para sim ou 2 para nao !!\n"); scanf("%d",&resposta); }/*fim_while*/ }/*fim_while*/ }

Nesse programa foram executados dois laos while, o primeiro executa a soma de dois nmeros at que a resposta seja igual a 1. E o segundo que pede um valor valido, ou seja, 1 para continuar calculando a soma de outros nmeros ou 2 para terminar o programa.

5.3 - Lao do-while

A grande diferena entre o lao do-while e os vistos anteriormente que ele analisa a condio no final do lao. Dessa forma todas as instrues localizadas dentro do do-while ser executada pelo menos uma vez. O lao termina quando a condio se torna falsa. Sintaxe: Do{ Instruo; }while(condio) O programa anterior tambm pode ser escrito da seguinte forma: #include<stdio.h> void main() { int n1,n2,soma,resposta; do{ printf("Digite valor de n1(inteiro):\n"); scanf("%d",&n1); printf("Digite valor de n2(inteiro):\n"); scanf("%d",&n2); soma=n1+n2; printf("Soma:%d\n",soma); printf("Deseja continuar? (1 - sim / 2 - nao)\n"); scanf("%d",&resposta); if((resposta!=1)&& (resposta!=1)) printf("Programa finalizado, este numero nao existe no menu \n"); }while(resposta==1); }

A nica diferena que este programa permite digitar outro nmero alm de 1 e 2, porm ser exibida a mensagem Programa finalizado, este numero no existe no menu.

5.4 - Desvio incondicional

A linguagem C tem como desvio incondicional o comando goto.

5.5 - Comando goto

Esta instruo ou comando muito pouco utilizado, pois tornam os cdigos difceis de se compreender. Por esse motivo no entraremos em muitos detalhes. Veja o exemplo abaixo, ele faz o mesmo do que o exemplo que utilizando o lao for (mostrado anteriormente). Repare que o programa que utiliza o for muito mais fcil de se entender. #include<stdio.h> void main() { int n; n=1; loop1: /*rtulo*/ printf("n=%d\n",n); n++; if(n<=10) goto loop1; /*caso n seja menor ou igual a 10 volta para o rtulo acima, executando assim as instrues outra vez at que a condio do if seja falsa*/ }

PASSO 3 - Exerccios
Utilizando conceitos de Algoritmos em linguagem C, utilizando o programa DEV C++ para desenvolver o exerccio a seguir: void caucula() { int numerobobinas; float PesoTotal = 0; int larguratotal = 0; printf("\nQuantas bobinas filhas tem o pedido? \n"); scanf("%i",&numerobobinas); while(numerobobinas > 0) { float PesoT; int Largura; int Diametro; printf("\n \n"); printf("Informacoes da Bobina %i \n", numerobobinas); printf("\n \n"); printf("Qual o Peso por metro da Bobina Kg? \n");scanf("%f",&PesoT); printf("Qual o Largura mm? \n");scanf("%i",&Largura); printf("Qual o Diametro mm? \n");scanf("%i",&Diametro); float Peso = (Largura * (Diametro / 1000)) * PesoT; printf("Peso teorico da Bobina Filha %.2f \n", Peso); larguratotal = larguratotal + Largura; PesoTotal = PesoTotal + Peso;numerobobinas--; }; float PesoBobina; float largurabobinacorte; printf("Qual o peso das Bobinas a serem utilizadas no Corte Kg? \n"); scanf("%f", &PesoBobina); printf("Qual a Largura das Bobinas a serem utilizadas no Corte mm? \n"); scanf("%f", &largurabobinacorte); float totalbobinas = PesoTotal / PesoBobina; float BobinasPorLargura = larguratotal / largurabobinacorte; int BobinasPorLarguraI = larguratotal / largurabobinacorte; float perda = ((BobinasPorLargura - BobinasPorLarguraI)) * 100; printf("\n\n"); printf("\nLargura total do pedido: %i \n", larguratotal); printf("\nPeso Total do Pedido: %.2f \n", PesoTotal); printf("\nTotal de Bobinas Jumbo: de 2.450 mm Utilizadas %.2f \n" , totalbobinas); printf("\nPerda Comercial %.2f%% \n" , perda);

}; int main(int argc, char**argv) { printf("################################################ \n"); printf("# Facudade Anhaguera de Sao Jose dos Campos # \n"); printf("# ATPS - Algoritimos e Programacao # \n"); printf("# Turma Engenharia de Producao # \n"); printf("################################################ \n"); caucula(); int escolha; printf("\nDeseja realizar outro cauculo [1] - Sim, [0] - Nao ?\n"); scanf("%i", &escolha); if(escolha == 1) { printf("\n============================================\n"); caucula(); } else { system("PAUSE"); return 0; }; };

ETAPA 3 VETORES E MATRIZES, MODULARIZAO

1 - Vetores
Um vetor armazena uma determinada quantidade de dados de mesmo tipo. Vamos supor o problema de encontrar a mdia de idade de 4 pessoas. O programa poderia ser: main() { int idade0, idade1, idade2, idade3; printf("Digite a idade da pessoa 0: "); scanf("%d", &idade0); printf("Digite a idade da pessoa 1: "); scanf("%d", &idade1); printf("Digite a idade da pessoa 2: "); scanf("%d", &idade2); printf("Digite a idade da pessoa 3: "); scanf("%d", &idade3); printf("Idade media: %d\n", (idade0+idade1+idade2+idade3) / 4); } Suponhamos agora que desejssemos encontrar a mdia das idades de 500 pessoas. A tarefa passa a ser bem mais trabalhosa, sendo em diversos casos impraticvel se resolver da maneira apresentada acima. A soluo para este problema a utilizao de vetores. Um vetor uma srie de variveis de mesmo tipo referenciadas por um nico nome, onde cada varivel diferenciada atravs de um ndice, que representado entre colchetes depois do nome da varivel. A declarao int idade[4], aloca memria para armazenar 4 inteiros e declara a varivel idade como um vetor de 4 elementos. O programa da mdia das idades poderia ser substitudo por: main() { int idade[4], i, soma = 0; for(i = 0; i < 4; i++) { printf("Digite a idade da pessoa %d: ", i); scanf("%d", &idade[i]); } for(i = 0; i < 4; i++) soma += idade[i]; printf("Idade media: %d\n", soma / 4); } Ao escrever o mesmo programa utilizando vetores, a complexidade do cdigo fica independente do tamanho do vetor.

Para acessar um determinado elemento do vetor, deve-se chamar o elemento pelo nome da varivel seguido do ndice, entre colchetes. Note que o ndice comea em 0, e no em 1. Ou seja, o elemento idade[2] no o segundo elemento e sim o terceiro, pois a numerao comea de 0. Em nosso exemplo utilizamos uma varivel inteira, i, como ndice do vetor. Suponhamos o seguinte programa: main() { int idade[5]; idade[0] = 15; idade[1] = 16; idade[2] = 17; idade[3] = 18; idade[4] = 19; idade[5] = 20; } Nota-se que neste programa, definimos a varivel idade como um vetor de 5 elementos (0 a 4). Definimos os elementos do vetor mas, na ltima definio, ultrapassamos o limite do vetor. A linguagem C no realiza verificao de limites em vetores. Quando o vetor foi definido, o compilador reservou o espao de memria equivalente a 5 variveis inteiras, ou seja, 10 bytes. Quando tentamos acessar um elemento que ultrapasse o limite de um vetor, estamos acessando uma regio de memria que no pertence a esse vetor.

1.1 - Inicializao
A linguagem C permite que vetores sejam inicializados. No caso, ser inicializada uma varivel contendo o nmero de dias de cada ms: int numdias[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; O nmero de elementos do vetor pode ser omitido, ou seja int numdias[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

Se nenhum nmero for fornecido para inicializar o vetor, o compilador contar o nmero de itens da lista de inicializao e o fixar como dimenso do vetor. Na falta de inicializao explcita, variveis extern e variveis static so inicializadas com valor zero; variveis automticas tm valor indefinido (isto , lixo). Se h menos inicializadores que a dimenso especificada, os outros sero zero. Se h mais inicializadores que o especificado, o compilador acusa um erro. Em C no h como se especificar a repetio de um inicializador, nem de se inicializar um elemento no meio de um vetor sem inicializar todos os elementos anteriores ao mesmo tempo

1.2 - Vetores como argumentos de funes

Vetores podem ser passados tambm como argumentos de funes. Vamos rescrever o programa que calcula a mdia das idades para um programa contendo uma funo que receba um vetor e retorne a sua mdia. int media(int valor[], int nElementos) { int i, soma = 0; for(i = 0; i < nElementos; i++) soma += valor[i]; return soma / nElementos; } main() { int idade[5], i; for(i = 0; i < 5; i++) { printf("Digite a idade da pessoa %d: ", i); scanf("%d", &idade[i]); } printf("Idade media: %d\n", media(idade, 5)); }

Note que na declarao da funo, o argumento que representa o vetor declarado com colchetes. Alm dele, passamos como argumento da funo tambm o tamanho do vetor. Sem ele, a funo no tem como saber o tamanho do vetor que foi passado a ela como argumento. Na funo main(), chamamos a funo media() passando dois atributos: idade e 5. Para acessarmos um elemento do vetor, escrevemos aps o seu nome o ndice do elemento desejado entre colchetes (por exemplo, idade[0]). A chamada ao nome de um vetor sem que seja fornecido o ndice de um determinado elemento representa o primeiro endereo de memria acessado por esse vetor. Ou seja, ao passarmos um vetor como argumento da funo, o compilador no cria uma cpia do vetor para ser utilizada na funo. o prprio vetor quem passado como argumento e pode ser alterado na funo.

1.3 - Vetores de caracteres

O vetor de caracteres, tambm conhecidos como string, uma das formas de dados mais importantes da linguagem C. usado para manipular texto, como palavras, nomes e frases. Em algumas linguagens, como Pascal e Basic, string um tipo primitivo. Em C, tratada como um vetor de elementos do tipo char. Cada elemento pode ser acessado individualmente, como em qualquer vetor, atravs do uso de colchetes. Sempre que o compilador encontra qualquer coisa entre aspas, ele reconhece que se trata de uma string constante, isto , os caracteres entre aspas mais o caractere nulo ('\0'). Para declarar uma varivel do tipo string, deve-se declar-la como um vetor de caracteres, ou seja: char Nome[50]; Esta declarao cria a varivel Nome como string, ou vetor de caracteres, permitindo um comprimento de at 50 caracteres. Vale lembrar que o ltimo caractere de uma string deve ser o caractere nulo, ou seja, temos 49 caracteres para trabalhar livremente. A declarao: char Nome[5] = "Pedro"; invlida, por no ter sido reservado espao suficiente para as 6 variveis ('P', 'e', 'd', 'r', 'o' e '\0'). Para manipulao de strings, so fornecidas diversas funes na biblioteca C (arquivo string.h). Algumas dessas funes so descritas a seguir. A sintaxe apresentada para cada funo no exatamente a sintaxe fornecida pela biblioteca, mas representa basicamente o que a funo executa e j foi explicado at o presente momento.

1.3.1 - A funo strlen()

A funo strlen() retorna o nmero de caracteres da string, sem contar o caractere nulo. Sintaxe: int strlen(char[] s);

Exemplo: main() { char Nome[6] = "Navio"; printf("%d\n%d\n", strlen("Barco a vela"), strlen(Nome)); } Note que os espaos fazem parte da string, e so simplesmente caracteres, assim como letras e algarismos.

1.3.2 - A funo strcmp()

A funo strcmp() compara duas strings. Retorna: - um valor menor que zero se a primeira string for menor que a segunda; - zero se as strings forem iguais; - um valor maior que zero se a primeira string for maior que a segunda. Entende-se pr comparao entre strings, sua posio em ordem alfabtica. A ordem alfabtica baseada na tabela ASCII (Anexo A). Portanto, cuidado ao comparar maisculas com minsculas, pois na tabela ASCII as letras maisculas possuem um valor menor que as letras minsculas, ou seja, o caractere 'Z' vem antes do caractere 'a'. Sintaxe: int strcmp(char[] s1, char[] s2);

Exemplo: main() { printf("%d\n", strcmp("Ariranha", "Zebra")); printf("%d\n", strcmp("Zebra", "Ariranha")); printf("%d\n", strcmp("Zebra", "Zebra")); }

Espaos e outros caracteres especiais tambm so considerados na comparao, algumas vezes no fornecendo o que se espera de uma ordenao alfabtica.

1.3.3 - A funo strcpy()

A funo strcpy() copia o contedo de uma string para outra. A string de destino j tem que ter espao reservado na memria antes de ser chamada a funo. Sintaxe: void strcpy(char[] destino, char[] origem);

Exemplo: main() { char Nome[10]; strcpy(Nome, "Teste") printf("%s\n", Nome); }

1.3.4 - A funo strcat()

A funo strcat() concatena duas strings, ou seja, anexa o contedo de uma na outra. Similarmente funo strcpy(), a string de destino tem que ter espao reservado na memria. Sintaxe: void strcat(char[] destino, char[] origem); Exemplo: main() { char Nome[12]; strcpy(Nome, "Teste") strcpy(Nome, "geral") printf("%s\n", Nome); }

2 - Matrizes
A linguagem C permite vetores de qualquer tipo, inclusive vetores de vetores. Por exemplo, uma matriz um vetor em que seus elementos so vetores. Com dois pares de colchetes, obtemos uma e, para cada par de colchetes adicionado, obtemos uma matriz com uma dimenso a mais. Por exemplo, a declarao int A[5][6]; indica que A uma matriz 5x6 e seus elementos so inteiros.

2.1 Inicializao
As matrizes so inicializadas como os vetores, ou seja, os elementos so colocados entre chaves e separados por vrgulas. Como seus elementos so vetores, estes, por sua vez, tambm so inicializados com seus elementos entre chaves e separados por vrgulas. Por exemplo: int A[5][6] = { { 1, 2, 3, 4, 5, 6}, { 7, 8, 9, 10, 11, 12}, {13, 14, 15, 16, 17, 18}, {19, 20, 21, 22, 23, 24}, {25, 26, 27, 28, 29, 30} }; Caso as matrizes sejam de caracteres, isto equivalente a termos um vetor de strings. Sua inicializao pode se dar da forma char Nome[5][10] = {"Joao", "Jose", "Maria", "Geraldo", "Lucia"}; A matriz ser inicializada como J o a o \0 \0 \0 \0 \0 \0 J o s e \0 \0 \0 \0 \0 \0 M a r i a \0 \0 \0 \0 \0 G e r a l d o \0 \0 \0 L u c i a \0 \0 \0 \0 \0

2.2 - Matrizes como argumento de funes

A passagem de uma matriz para uma funo similar passagem de um vetor. O mtodo de passagem do endereo da matriz para a funo idntico, no importando quantas dimenses ela possua, j que sempre passado o endereo da matriz. Entretanto, na declarao da funo, a matriz um pouco diferente. A funo deve receber o tamanho das dimenses a partir da segunda dimenso. Por exemplo: void Determinante(double A[][5]); Note que fornecido a segunda dimenso da matriz. Isto necessrio para que, ao chamarmos o elemento A[i][j], a funo saiba a partir de que elemento ela deve mudar de linha. Com o nmero de elementos de cada linha, a funo pode obter qualquer elemento multiplicando o nmero da linha pelo tamanho de cada linha e somando ao nmero da coluna. Por exemplo, o elemento A[2][3], o elemento de ndice 13, j que 2 * 5 + 3 = 13.

3 - Modularizao 3.1 - Introduo

Vimos que os algoritmos estruturados so desenvolvidos levando-se em conta algumas premissas bsicas: Desenvolver o algoritmo em diferentes fases de detalhamento crescente, do geral ao particular, por refinamentos sucessivos (desenvolvimento "top-down" ou de cima para baixo). Decompor o algoritmo em mdulos funcionais, organizados de preferncia em um sistema hierrquico. Esses mdulos trazem vantagens adicionais para testes, pois testa-se um mdulo (ou seja, uma parte do programa) de cada vez, independentemente; e para reutilizao de um mdulo em outros algoritmos e programas, no futuro. Passaremos agora a formalizar a utilizao de mdulos nos nossos algoritmos e verificar as vantagens que os mesmos trazem para entendimento, construo, codificao, teste e reutilizao dos mesmos. A grande maioria das linguagens de programao que so utilizadas, tem esta facilidade, seja com o nome de Sub-rotinas, Subprogramas, Procedimentos, Funes, Mdulos, Blocos, etc., sempre possvel subdividir-se um programa de modo a facilitar o entendimento, permitir a reutilizao, evitando-se a repetio de blocos dos programas. No nosso pseudo-cdigo definiremos dois tipos de mdulos: Os procedimentos ("procedures") e as funes ("functions"). Os procedimentos e funes so normalmente definidos antes de serem utilizados(chamados) pelo programa principal. Em se tratando de algoritmos, entretanto, poderemos definir nossos procedimentos e funes em qualquer parte do algoritmo principal ou depois dele, adotando os formatos que se seguem e as normas de documentao.

3.2 - Procedimentos
Um procedimento uma seqncia de comandos precedida por uma seqncia de declaraes que possui um identificador (nome do procedimento), uma lista de parmetros opcional e pode realizar qualquer tipo de processamento que o programador ou analista deseje. As variveis, os tipos e as constantes declaradas dentro de um procedimento s so acessveis dentro dos comandos do procedimento. So chamadas variveis locais. Em um Algoritmo, as variveis, tipos e constantes declaradas logo aps o identificador do algoritmo, so acessveis e visveis dentro de qualquer procedimento que esteja sendo usado pelo algoritmo. So chamadas variveis Globais. uma boa tcnica ao se construir um procedimento, no fazer uso no mesmo, de variveis globais e referenciar e utilizar apenas as variveis locais e os parmetros do procedimento. Isso far com que cada procedimento, ao ser modificado, no afete outras partes o Algoritmo, e da mesma forma as variveis globais podero ser modificadas sem que haja efeitos colaterais nos procedimentos. Sintaxe de declarao: Procedimento < nome do Procedimento> Incio <declaraes>; C1; C2; Cn; Fim { nome do procedimento}.

Exemplo: Incio Inteiro: X,Y,A,B,C,D; Procedimento troca; Incio Inteiro: AUX,X; AUXX; XY; YAUX; Fim troca. A5; B3; Imprima(A, XA; YB; Troca; AX; BY; Imprima(A, C4; D9; Imprima(C, XC; YD; Troca; CX; DY; Imprima(C, Fim.

B);

B); D);

D);

Os mdulos usados anteriormente so procedimentos sem parmetros, ou seja, que fazem uso de variveis globais e sua nica importante vantagem facilitar o entendimento e a soluo do algoritmo. Utilizando parmetros e no variveis globais dentro do procedimento, podemos, por assim dizer, isol-lo do meio exterior e obter vantagens adicionais na codificao, pois, uma vez que foram bem definidos os parmetros, um programador poder desenvolver seu procedimento sem se preocupar com o algoritmo que o vai chamar. Poderemos tambm test-lo individualmente e isoladamente para verificar sua correo. Isto ser comprovado na disciplina LP. A isto se denomina Encapsulamento. Uma lista de parmetros consiste em uma lista de variveis e seus respectivos tipos.

Procedimento < nome do Procedimento> (<lista de parmetros>) Incio <declarao de variveis locais> C1; C2; Cn; Fim. { nome do procedimento}

Exemplo de Procedimento: Procedimento TROCAINTEIROS (Inteiro NUM1,inteiro NUM2) Incio Inteiro AUXNUM; AUXNUM = NUM1; NUM1 = NUM2; NUM2 = AUXNUM; Fim.

3.3 Funes
Funes so as estruturas que permitem ao usurio separar seus programas em blocos. Se no as tivssemos, os programas teriam que ser curtos e de pequena complexidade. Para fazermos programas grandes e complexos temos de constru-los bloco a bloco. Uma funo um mdulo que tem por objetivo calcular e retornar ao algoritmo, procedimento ou funo "chamador" um valor. A chamada de uma funo para execuo feita apenas citando-se o seu identificador no meio de uma expresso. Vide as funes previamente existentes no nosso pseudo-cdigo. Uma funo dita recursiva quando chama a ela prpria. Uma funo no C tem a seguinte forma geral: tipo_de_retorno nome_da_funo (declarao_de_parmetros) Incio corpo_da_funo Fim. Aqui no nosso Pseudo-Cdigo utilizaremos a seguinte forma Pseudo - Cdigo Tipo-de-retorno<nome da funo>(<declarao dos parmetros>) Incio Corpo da Funo Fim. Onde: A lista de parmetros semelhante dos procedimentos.Antes do nome da funo d o tipo do valor que a funo retorna ao algoritmo ou procedimento chamador. O tipo-de-retorno o tipo de varivel que a funo vai retornar. O default o tipo inteiro (int), ou seja, uma funo para qual no declaramos o tipo de retorno considerada como retornando um inteiro. A declarao de parmetros uma lista com a seguinte forma geral: tipo nome1, tipo nome2, ... , tipo nomeN Repare que o tipo deve ser especificado para cada uma das N variveis de entrada. na declarao de parmetros que informamos ao compilador quais sero as entradas da funo (assim como informamos a sada no tipo-deretorno). O corpo da funo a sua alma. nele que as entradas so processadas, sadas so geradas ou outras coisas so feitas. O comando return tem a seguinte forma geral: retorna valor_de_retorno; ou retorna;

Digamos que uma funo est sendo executada. Quando se chega a uma declarao retorna (return) a funo encerrada imediatamente e, se o valor de retorno informado, a funo retorna este valor. importante lembrar que o valor de retorno fornecido tem que ser compatvel com o tipo de retorno declarado para a funo. Uma funo pode ter mais de uma declarao retorna (return). Isto se torna claro quando pensamos que a funo terminada quando o programa chega primeira declarao retorna (return). Abaixo esto dois exemplos de uso do retorna (return): Exemplo de funo: Inteiro VALORABSOLUTO (inteiro X) Incio Se X > = 0 Ento VALORABSOLUTO =X; Seno VALORABSOLUTO = (-X); Fim Se; Fim.

3.3.1 - Prottipos de Funes

At agora, nos exemplos apresentados, escrevemos as funes antes de escrevermos a funo principal, main(). Isto , as funes esto fisicamente antes da funo principal main(). Isto foi feito por uma razo. Imagine-se na pele do compilador. Se voc fosse compilar a funo main(), onde so chamadas as funes, voc teria que saber com antecedncia quais so os tipos de retorno e quais so os parmetros das funes para que voc pudesse gerar o cdigo corretamente. Foi por isto que as funes foram colocadas antes da funo main(): quando o compilador chegasse funo main() ele j teria compilado as funes e j saberia seus formatos. Mas, muitas vezes, no poderemos nos dar ao luxo de escrever nesta ordem. Muitas vezes teremos o nosso programa espalhado por vrios arquivos. Ou seja, estaremos chamando funes em um arquivo que sero compiladas em outro arquivo. Como manter a coerncia? A soluo so os prottipos de funes. Prottipos so nada mais, nada menos, que declaraes de funes. Isto , voc declara uma funo que ir usar. O compilador toma ento conhecimento do formato daquela funo antes de compil-la. O cdigo correto ser ento gerado. Um prottipo tem o seguinte formato: tipo_de_retorno nome_da_funo (declarao_de_parmetros); onde o tipo- de-retorno, o nome-da-funo e a declarao-de-parmetros so os mesmos que voc pretende usar quando realmente escrever a funo. Repare que os prottipos tm uma ntida semelhana com as declaraes de variveis. Vamos implementar agora um dos exemplos da seo anterior com algumas alteraes e com prottipos:

Em Pseudo-Cdigo inteiro Square (inteiro a); Algoritmo Principal incio inteiro num; imprima ("Entre com um numero: "); leia (num); num=Square(num); imprima ("O seu quadrado vale:", num); retorna (0); fim. inteiro Square (inteiro a) incio retorna (a*a); fim. Em C #include <stdio.h> int Square (int a); int main () { int num; printf ("Entre com um numero: "); scanf ("%f",&num); num=Square(num); printf ("\n\nO seu quadrado vale: %f\n",num); return 0; } int Square (int a) { return (a*a);}

Observe que a funo Square() est colocada depois do algoritmo principal, mas o seu prottipo est antes. Sem isto este programa no funcionaria corretamente.

Usando prottipos voc pode construir funes que retornam quaisquer tipos de variveis. bom ressaltar que funes podem tambm retornar ponteiros sem qualquer problema. Os prottipos no s ajudam o compilador. Eles ajudam a voc tambm: usando prottipos, o compilador evita erros, no deixando que o programador use funes com os parmetros errados e com o tipo de retorno errado, o que uma grande ajuda!

3.3.2 - Escopo de Variveis

O escopo o conjunto de regras que determinam o uso e a validade de variveis nas diversas partes do programa.

3.3.2.1 - Variveis locais

O primeiro tipo de variveis que veremos so as variveis locais. Estas so aquelas que s tm validade dentro do bloco no qual so declaradas. Podemos declarar variveis dentro de qualquer bloco. S para lembrar: um bloco comea quando abrimos uma chave e termina quando fechamos a chave. At agora s tnhamos visto variveis locais para funes completas. Mas um comando para(for) pode ter variveis locais e que no sero conhecidas fora dali. A declarao de variveis locais a primeira coisa que devemos colocar num bloco. A caracterstica que torna as variveis locais to importantes justamente a de serem exclusivas do bloco. Podemos ter quantos blocos quisermos com uma varivel local chamada x, por exemplo, e elas no apresentaro conflito entre elas. A palavra reservada do C auto serve para dizer que uma varivel local. Mas no precisaremos us-la pois as variveis declaradas dentro de um bloco j so consideradas locais. Abaixo vemos um exemplo de variveis locais: Em Pseudo-Cdigo funcao1 (...) Incio inteiro abc,x; Fim. ... funcao (...) Incio inteiro abc; Fim. ... inteiro principal () Incio inteiro a,x,y; para (...) { real a,b,c; ... } ... Fim. Em C func1 (...) { int abc,x; ... } func (...) { int abc; ... } int main () { int a,x,y; for (...) { float a,b,c; ... } No programa acima temos trs funes. As variveis locais de cada uma delas no iro interferir com as variveis locais de outras funes. Assim, a varivel abc de func1() no tem nada a ver (e pode ser tratada independentemente) com a varivel abc de func2(). A varivel x de func1() tambm completamente independente da varivel x da funo principal main(). As variveis a, b e c so locais ao bloco para(for). Isto quer dizer que s so conhecidas dentro deste bloco e so desconhecidas no resto da funo Principal(main()). Quando usarmos a varivel a dentro do bloco para (for) estaremos usando a varivel a local ao para(for) e no a varivel a da funo main().

3.3.2.2 - Parmetros formais

O segundo tipo de varivel que veremos so os parmetros formais. Estes so declarados como sendo as entradas de uma funo. No h motivo para se preocupar com o escopo deles. fcil: o parmetro formal uma varivel local da funo. Voc pode tambm alterar o valor de um parmetro formal, pois esta alterao no ter efeito na varivel que foi passada funo. Isto tem sentido, pois quando o C passa parmetros para uma funo, so passadas apenas cpias das variveis. Isto , os parmetros formais existem independentemente das variveis que foram passadas para a funo. Eles tomam apenas uma cpia dos valores passados para a funo.

3.3.2.3 - Variveis globais

Variveis globais so declaradas, como j sabemos, fora de todas as funes do programa. Elas so conhecidas e podem ser alteradas por todas as funes do programa. Quando uma funo tem uma varivel local com o mesmo nome de uma varivel global a funo dar preferncia varivel local. Vamos ver um exemplo no nosso pseudoCdigo: inteiro z,k; func1 (...) { inteiro x,y;... } func2 (...) { inteiro x,y,z; ... z=10; ... } principal { inteiro count; ... }

No exemplo acima as variveis z e k so globais. Veja que func2() tem uma varivel local chamada z. Quando temos ento, em func2(), o comando z=10 quem recebe o valor de 10 a varivel local, no afetando o valor da varivel global z. Evite ao mximo o uso de variveis globais. Elas ocupam memria o tempo todo (as locais s ocupam memria enquanto esto sendo usadas) e tornam o programa mais difcil de ser entendido e menos geral.

3.3.3 - Passagem de parmetros por valor e passagem por referncia

J vimos que, na linguagem C, quando chamamos uma funo os parmetros formais da funo copiam os valores dos parmetros que so passados para a funo. Isto quer dizer que no so alterados os valores que os parmetros tm fora da funo. Este tipo de chamada de funo denominado chamada por valor. Isto ocorre porque so passados para a funo apenas os valores dos parmetros e no os prprios parmetros. Veja o exemplo abaixo: Exemplo Em Pseudo-Cdigo real sqr (real num); int main () { real num,sq; imprima ("Entre com um numero: "); leia (num); sq=sqr(num); imprima ("O numero original e:",num); imprima ("O seu quadrado vale:",sq); } real sqr (real num) { num=num*num; retorna num;} Em C #include <stdio.h> float sqr (float num); void main () { float num,sq;

printf ("Entre com um numero: "); scanf ("%f",&num); sq=sqr(num); printf ("\n\nO numero original e: %f\n",num); printf ("O seu quadrado vale: %f\n",sq); } float sqr (float num) { num=num*num; return num; } No exemplo acima o parmetro formal num da funo sqr() sofre alteraes dentro da funo, mas a varivel num da funo principal main() permanece inalterada: uma chamada por valor. Outro tipo de passagem de parmetros para uma funo ocorre quando alteraes nos parmetros formais, dentro da funo, alteram os valores dos parmetros que foram passados para a funo. Este tipo de chamada de funo tem o nome de "chamada por referncia". Este nome vem do fato de que, neste tipo de chamada, no se passa para a funo os valores das variveis, mas sim suas referncias (a funo usa as referncias para alterar os valores das variveis fora da funo). O C s faz chamadas por valor. Isto bom quando queremos usar os parmetros formais vontade dentro da funo, sem termos que nos preocupar em estar alterando os valores dos parmetros que foram passados para a funo. Mas isto tambm pode ser ruim s vezes, porque podemos querer mudar os valores dos parmetros fora da funo tambm. O C++ tem um recurso que permite ao programador fazer chamadas por referncia. H entretanto, no C, um recurso de programao que podemos usar para simular uma chamada por referncia. Quando queremos alterar as variveis que so passadas para uma funo, ns podemos declarar seus parmetros formais como sendo ponteiros. Os ponteiros so a "referncia" que precisamos para poder alterar a varivel fora da funo. O nico inconveniente que, quando usarmos a funo, teremos de lembrar de colocar um & na frente das variveis que estivermos passando para a funo. Veja um exemplo: #include <stdio.h> void Swap (int *a,int *b); void main (void) { int num1,num2; num1=100; num2=200; Swap (&num1,&num2); printf ("\n\nEles agora valem %d %d\n",num1,num2); } void Swap (int *a,int *b) { int temp; temp=*a; *a=*b; *b=temp; }

No muito difcil. O que est acontecendo que passamos para a funo Swap o endereo das variveis num1 e num2. Estes endereos so copiados nos ponteiros a e b. Atravs do operador * estamos acessando o contedo apontado pelos ponteiros e modificando-o. Mas, quem este contedo? Nada mais que os valores armazenados em num1 e num2, que, portanto, esto sendo modificados!

3.4 Funes recursivas

Existem casos em que um procedimento ou funo chama a si prprio. Diz-se ento que o procedimento ou funo recursivo. Por exemplo, o fatorial de um nmero n pode ser definido recursivamente, ou seja: n (n 1)! n! = 1 se n = 0 inteiro fat(inteiro n) Incio Se n==0 Ento fat=1; Seno fat=n*fat(n-1); Fim Se; Fim. Por exemplo, o fatorial de 3 ser calculado a partir da chamada funo pelo comando x =fat(3) que retornar em fat o valor 6.

3.5 - Estruturao de mdulos de um algoritmo

Um procedimento nada mais que um algoritmo hierarquicamente subordinado a um outro algoritmo, comumente chamado de Mdulo principal ou programa principal ou ainda algoritmo principal.

Da mesma forma, um procedimento poder conter outros procedimentos (e tambm funes) aninhados. Assim, ao definirmos as fases do nosso algoritmo, no processo de refinamentos sucessivos, se transformarmos as mesmas em procedimentos e os refinamentos de cada procedimento em outros procedimentos, obteremos, ao fim do processo de criao, um algoritmo estruturado, com mdulos hierarquicamente subordinados e muito menos suscetvel a erros de lgica na fase de codificao do programa.

ETAPA 4 STRINGS E RELATRIOS ESTRUTURADOS

1 - Strings
Um dos tipos de arranjos que mais ocorre em C o arranjo de caracteres, ou string. C no suporta um tipo bsico string; ao invs, h uma conveno para tratamento de arranjos de caracteres que permite o uso de diversas funes de manipulao de strings na linguagem. Por conveno, C considera como uma string uma seqncia de caracteres armazenada sob a forma de um arranjo de tipo char cujo ltimo elemento o carter NUL, tipicamente representado na forma de carter, '\0', ou simplesmente pelo seu valor, 0. Por exemplo, um string poderia ser declarado e inicializado como em char exemplo[4] = {'a','b','c','\0'}; Observe que o espao para o carter '\0' deve ser previsto quando dimensionando o tamanho do arranjo de caracteres que ser manipulado como string. No exemplo, o arranjo de quatro caracteres pode receber apenas trs letras, j que o ltimo carter est reservado para o NUL. C suporta uma forma alternativa de representao de um string constante, que atravs do uso de aspas: char exemplo[4] = "abc"; Este exemplo equivalente ao anterior -- a string "abc" contm quatro caracteres, sendo que o carter '\0' automaticamente anexado string pelo compilador.

2 Manipulando strings
Funes que manipulam strings trabalham usualmente com a referncia para o incio da seqncia de caracteres, ou seja, com um ponteiro para a string. A manipulao de ponteiros fonte usual de confuso em qualquer linguagem. Por exemplo, tendo duas variveis ponteiros char* s1 e char* s2 indicando o incio de duas strings, no seria possvel copiar o contedo de s2 para s1 simplesmente por atribuio, s1 = s2; /* copia o endereco! */

ou comparar seus contedos diretamente, if (s1 != s2) /* compara os enderecos! */

Diversas rotinas so suportadas para manipular strings na biblioteca padro de C, tais como: char *strcat(char *s1, const char *s2); char *strncat(char *s1, const char *s2, size_t n); int strcmp(const char *s1, const char *s2); int strncmp(const char *s1, const char *s2, size_t n); char *strcpy(char *s1, const char *s2); char *strncpy(char *s1, const char *s2, size_t n); size_t strlen(const char *s); char *strchr(const char *s, int c); Os prottipos para essas rotinas esto definidos no arquivo de cabealho string.h. Nesses prottipos, size_t um nome de tipo para representar tamanhos correspondentes a algum tipo inteiro definido no arquivo de cabealho stddef.h. A funo strcat concatena a string apontada por s2 string apontada por s1. O arranjo associado ao endereo s1 deve ter espao suficiente para armazenar o resultado concatenado. A funo strncat permite limitar a quantidade de caracteres concatenados, agregando no mximo n caracteres de s2 a s1. A funo strcmp compara o contedo de duas strings. Se a string apontada por s1 for igual quela de s2, o valor de retorno da funo 0. Se forem diferentes, o valor de retorno ser negativo quando a string em s1for lexicograficamente menor que aquela de s2, ou positivo caso contrrio.

A funo strncmp compara no mximo at n caracteres das duas strings. A funo strcpy copia a string em s2 (at a ocorrncia do carter '\0') para o arranjo apontado por s1. A funo strncpy copia no mximo at n caracteres. Observe que neste caso, se a string em s2 for maior quen caracteres, a string resultante no ser terminada pelo carter '\0'. A funo strlen retorna o comprimento da string em s, sem incluir nessa contagem o carter '\0'. A funo strchr retorna o apontador para a primeira ocorrncia do carter c na string em s, ou o apontador nulo se o carter no est presente na string. Alm destas funes, interessante destacar que existe uma funo sprintf (declarada em stdio.h e parte da biblioteca padro) que permite formatar valores seguindo o mesmo padro utilizado em printf, com a diferena que a sada formatada colocada em uma string ao invs de ser enviada para a tela. Seu prottipo : int sprintf (char *s, const char *format, ...); responsabilidade do programador garantir que o arranjo para a string apontado por s tenha espao suficiente para armazenar o resultado.

3 - Definio de Estruturas
Atravs do conceito de estrutura, C oferece um mecanismo uniforme para a definio de registros, unidades de informao organizadas em campos de tipos que podem ser no-homogneos. Como um exemplo, esse mecanismo pode ser aplicado tanto a uma linha de cdigo assembly, com campos associados a rtulo, cdigo de operao, operandos e comentrios, como a tabelas, com campos smbolo e valor. Considere a definio de uma entidade linha, composta por quatro componentes -- rotulo, opcode, operand, comment. Cada componente um arranjo de caracteres de tamanho adequado recepo de um dos campos das linhas de um programa assembly. Em uma estrutura C, #define LINSIZE 80 #define LABSIZE 8 #define OPCSIZE 10 #define OPRSIZE 20 #define CMTSIZE (LINSIZE-(LABSIZE+OPCSIZE+OPRSIZE)) typedef struct linha { char rotulo[LABSIZE]; char opcode[OPCSIZE]; char operand[OPRSIZE]; char comment[CMTSIZE]; } Linha; Variveis deste tipo de estrutura podem ser definidas como Linha l;

Apesar deste exemplo s ter como componentes seqncias de caracteres, qualquer tipo vlido pode estar presente em uma estrutura -- at mesmo outra estrutura, como em struct linCode { int posicao; Linha linha; }; Usando essa estrutura Linha, uma verso simplificada da funo getLabel usada seria: char *getLabel(Linha linha) { char term; int pos; do { term = linha.rotulo[pos];

if (term == ':' || term == ' ') { linha.rotulo[pos] = '\0'; return(linha.rotulo); } ++pos; } while (pos < LABSIZ); linha.rotulo[pos] = '\0'; return(linha.rotulo); } Em aplicaes sucessivas do operador . -- quando for necessrio acessar estruturas aninhadas -- a associativadade da esquerda para a direita. Em situaes onde h a necessidade de se minimizar o espao ocupado por dados de um programa, pode ser preciso compartilhar uma palavra da mquina para armazenar diversas informaes. Neste caso, preciso trabalhar a nvel de subseqncias de bits internas representao de um nmero inteiro. A forma bsica de manipular bits em um inteiro seria atravs dos operadores bit-a-bit, trabalhando com mscaras e deslocamentos para isolar as informaes individuais. Entretanto, a linguagem C suporta o conceito decampos de bits internos a um inteiro para facilitar este tipo de manipulao. Campos so baseados em estruturas. Por exemplo, considere uma instruo de um dado dispositivo que est sendo programado em C. Cada instruo neste dispositivo tm um formato binrio de codificao em quatro bits que especificam a operao, seguidos por dois campos de seis bits cada que especificam a fonte e o destino associados operao dada. Com o uso de campos, uma varivel poderia ser definida como: struct { unsigned int opcode: 4; unsigned int fonte: 6; unsigned int dest: 6; } instrucao; Campos so acessados exatamente da mesma forma que membros de estruturas, comportando-se como inteiros sem sinal.

3.1 - Declarando uma estrutura

A sintaxe para a declarao (ou criao) de uma estrutura : struct NOME_DA_ESTRUTURA { TIPO CAMPO1; TIPO CAMPO2; ........... ........... TIPO CAMPOn; }; Para o caso exemplificado no item anterior poderamos ter algo como: struct produto { int codigo; char nome[50]; int quantidade; float valor_compra; float valor_venda; float lucro; char obs[200]; }; importante observar que a declarao da estrutura no cria, ainda, uma varivel. A declarao da estrutura apenas cria um novo tipo de dado. Aps criar a estrutura voc pode declarar variveis do tipo de estrutura criado.

3.2 - Declarando variveis do tipo de uma estrutura criada

Aps a declarao da estrutura voc pode declarar variveis do tipo da estrutura com a sintaxe: struct NOME_DA_ESTRUTURA NOME_DA_VARIVEL; Exemplo: struct produto item; Observe que esta sintaxe obecede a sintaxe normal para a declarao de variveis: TIPO NOME_DA_VARIVEL; sendo o TIPO da varivel, a nova estrutura criada ( struct NOME_DA_ESTRUTURA ). Voc tambm pode declarar a varivel logo aps a declarao da estrutura com uma sintaxe do tipo: struct produto { int codigo; char nome[50]; int quantidade; float valor_compra; float valor_venda; float lucro; char obs[200]; }item;

3.3 - Acessando os campos de uma estrutura

A sintaxe para acessar e manipular campos de estruturas a seguinte: NOME_DA_ESTRUTURA.CAMPO Observe o cdigo abaixo para um melhor esclarecimento: acessando os campos de uma estrutura #include <stdio.h> criando um novo tipo de dado "produto" struct produto { int codigo; char nome[50]; int quantidade; float valor_compra; float valor_venda; }; int main() { struct produto item; /* declarando uma varivel "item" do tipo "struct produto" */ printf("Preenchendo a varivel \"item\"\n"); printf("Item............:"); fgets(item.nome,50,stdin); printf("Cdigo..........:"); scanf("%d",&item.codigo); printf("Quantidade......:"); scanf("%d",&item.quantidade);

printf("Valor de compra.:"); scanf("%f",&item.valor_compra); printf("Valor de revenda:"); scanf("%f",&item.valor_venda); printf("\n"); printf("Exibindo os dados\n"); printf("Cdigo..........:%d\n",item.codigo); printf("Item............:%s",item.nome); printf("Quantidade......:%d\n",item.quantidade); printf("Valor de compra.:%.2f\n",item.valor_compra); printf("Valor de revenda:%.2f\n",item.valor_venda); return(0); }

3.4 - Acessando uma estrutura com ponteiros

Para acessar uma estrutura usando ponteiros voc pode usar duas sintaxes: (*NOME_DA_ESTRUTURA).CAMPO ou NOME_DA_ESTRUTURA->CAMPO Exemplo: acessando uma estrutura com ponteiros #include <stdio.h> struct registro { char nome[30]; int idade; }; altera_estrutura1(struct registro *ficha) { (*ficha).idade -= 10; } altera_estrutura2(struct registro *ficha) { ficha->idade += 20; } int main() { struct registro ficha; printf("Entre com seu nome:"); fgets(ficha.nome,30,stdin); printf("Qual sua idade?"); scanf("%d",&ficha.idade); printf("\nExibindo os dados iniciais\n"); printf("Nome: %s",ficha.nome); printf("Idade: %d.\n",ficha.idade); altera_estrutura1(&ficha); printf("\nExibindo os dados aps a primeira alterao\n"); printf("Nome: %s",ficha.nome); printf("Idade: %d.\n",ficha.idade); altera_estrutura2(&ficha);

printf("\nExibindo os dados aps a segunda alterao\n"); printf("Nome: %s",ficha.nome); printf("Idade: %d.\n",ficha.idade); return(0); }

Exercicios da ETAPA 3 e ETAPA 4

Esta etapa dos exercicios foi realizado em linguagem PORTUGOL que tambm e bem conhecida entre os programadores de linguagem C devido a melhor familiarizao com a linguagem. Foi usado o programa de linguagem chamado VISUALG que realiza a interpretao do algoritmo de forma bem simples. algoritmo "calculo_bobinas" // Funo : Optimizar o corte de bobinas Jumbo // Autor : Fabiano G. Moreira // Data : 08/06/2013 // Seo de Declaraes var NomeCliente,resposta,temp4,Retorno:caractere Pedido_ID, Contagem, cont, TotalPedidos, i, j, Retirados:inteiro Largura, LarguraTotal, Peso, Perda2, PesoTotal, PesoTeorico, Diametro, ValidaBobinas:real LarguraJumbo, TotalBobinas, Perda, temp, temp2, temp3, QuantidadeRetirar, SomaRetira:real Porcentagem, Largura_Sequencia, Largura_Processada: real //Vetores SequenciaCorte: vetor[1..20] de real //Matrizes PedidosRetirar: vetor[1..3,1..20] de real Pedidos: vetor[1..3,1..20] de real Clientes: vetor[1..20] de caractere ClientesRetirados: vetor[1..20] de caractere imprimir: vetor[1..20] de caractere //Cabealho procedimento Cabecalho () inicio escreval("#########################################################################") escreval("# #") escreval("# Faculdade Anhanguera de So Jose dos Campos #") escreval("# ATPS Algoritimos e Programo - Professor Eriovaldo Magalhaes #") escreval("# Turma de Engenharia de Producao #") escreval("# #") escreval("#########################################################################") fimprocedimento //Funcao para o Cauculo de Bobinas procedimento EntraPedidos() inicio limpatela Cabecalho() escreval("") escreval("==================================================================") escreval(" Informaes do Tipo de Bobina" ) escreval("==================================================================") escreval("") escreva("Largura Total (Mm): ") leia(LarguraJumbo) escreva("Peso por Metro (Kg): ") leia(Peso) escreva("Diametro (Mm): ") leia(Diametro) limpatela escreval("==================================================================") escreval("Quantos Pedidos Deseja Incluir? (Mximo 20 Pedidos") leia(TotalPedidos) se TotalPedidos > 20 entao

limpatela Cabecalho () escreval("") escreval ("<<<<< ENTRE UM VALOR MENOR QUE 20 NO CAMPO PEDIDOS >>>>>") escreval("") EntraPedidos() fimse Contagem:= 1 enquanto (Contagem <= TotalPedidos) faca Pedido_ID:= Contagem escreval("") escreval("==============================================================") escreval("== Entre os dados do pedido nmero: ",Pedido_ID," ==") escreva("Nome do Cliente: ") leia(NomeCliente) Clientes[Pedido_ID] := maiusc(NomeCliente) escreva("Largura desse corte (Mm): ") leia(Largura) PesoTeorico:= (Largura * (Diametro / 1000)) * Peso LarguraTotal:= LarguraTotal + Largura PesoTotal:= PesoTotal + PesoTeorico Pedidos[1,Pedido_ID] := Pedido_ID Pedidos[2,Pedido_ID] := Largura Pedidos[3,Pedido_ID] := PesoTeorico Contagem:= Contagem + 1 fimenquanto limpatela Cabecalho () CalculaPerda () fimprocedimento //Funcao para imprimir um pedido aprovado procedimento imprime_pedido() inicio limpatela Cabecalho () escreval("") Pedidos_I() LarguraTotal:= 0 para j de 1 ate TotalPedidos faca LarguraTotal:= LarguraTotal + Pedidos[2,j] fimpara TotalBobinas:= int(LarguraTotal / LarguraJumbo) + 1 //Ordenar Vetor Para a melhor sequencia de Corte j:= TotalPedidos + Retirados enquanto j > 1 faca para i de 1 ate j-1 faca //Largura se Pedidos[2,i] < Pedidos[2,i+1] entao temp := Pedidos[2,i] Pedidos[2,i] := Pedidos[2,i+1] Pedidos[2,i+1] := temp //Pedido_ID temp2 := Pedidos[1,i] Pedidos[1,i] := Pedidos[1,i+1] Pedidos[1,i+1] := temp2 //Peso temp3 := Pedidos[3,i] Pedidos[3,i] := Pedidos[3,i+1] Pedidos[3,i+1] := temp3 //Cliente temp4 := Clientes[i] Clientes[i] := Clientes[i+1] Clientes[i+1] := temp4 fimse fimpara j:= j-1 fimenquanto escreval("")

escreval("=============================================================") escreval(" Sequencia de Corte ") escreval("=============================================================") //Imprime na melhor sequencia Contagem:= 1 Retirados:= 0 Para cont de 1 ate int(TotalBobinas) faca escreval("--------------Bobina ",Cont, " ---------------") Largura_Sequencia:= 0 enquanto (Largura_Sequencia< LarguraJumbo) faca se (Pedidos[2,Contagem] < (LarguraJumbo - Largura_Sequencia)) e (Pedidos[2,Contagem] > 0) entao Largura_Sequencia:= Largura_Sequencia + Pedidos[2,Contagem] Porcentagem:= (Largura_Sequencia * 100) / LarguraJumbo SequenciaCorte[Contagem] := Pedidos[2,Contagem] Pedidos[1,Contagem] := 0 Pedidos[2,Contagem] := 0 Pedidos[3,Contagem] := 0 resposta:= "mudado" Retirados:= Retirados + 1 senao para j de 1 ate TotalPedidos faca se (Pedidos[2,j] < (LarguraJumbo - Largura_Sequencia)) entao se (Pedidos[2,j] > 0) e (resposta <> "mudado") entao Largura_Sequencia:= Largura_Sequencia + Pedidos[2,j] Porcentagem:= (largura_sequencia * 100) / LarguraJumbo SequenciaCorte[Contagem] := Pedidos[2,j] Pedidos[1,j] := 0 Pedidos[2,j] := 0 Pedidos[3,j] := 0 resposta:= "mudado" Retirados:= Retirados + 1 fimse fimse fimpara fimse se resposta <> "mudado" entao Largura_Sequencia:= Largura_Sequencia + ((LarguraJumbo Largura_Sequencia)+1) senao se SequenciaCorte[Contagem] > 0 entao escreval(Contagem," - Cortar: ",SequenciaCorte[Contagem]," Mm ",Porcentagem,"%") Contagem:= Contagem + 1 fimse fimse resposta:= "" fimenquanto fimpara escreval("") escreval("Para realizar outra sequencia de pedidos digite CALCULAR, para sair digite FIM") escreva("->") leia(resposta) se resposta = "CALCULAR" entao TotalPedidos:= 0 LarguraTotal:= 0 Largura:= 0 Contagem:= 0 Retirados:= 0 Perda:= 0 QuantidadeRetirar:=0 limpatela Cabecalho() EntraPedidos() senao fimalgoritmo fimse

fimprocedimento //Funcao Para Recolocar Pedidos Retirados procedimento Recoloca() inicio limpatela j:= Retirados para Contagem de 1 ate j faca Pedidos[1,TotalPedidos+1]:= PedidosRetirar[1,Contagem] Pedidos[2,TotalPedidos+1]:= PedidosRetirar[2,Contagem] Pedidos[3,TotalPedidos+1]:= PedidosRetirar[3,Contagem] Clientes[TotalPedidos+1]:= ClientesRetirados[Contagem] SomaRetira:= SomaRetira - PedidosRetirar[2,Contagem] TotalPedidos:= TotalPedidos + 1 ClientesRetirados[Contagem]:= "" PedidosRetirar[1,Contagem] := 0 PedidosRetirar[2,Contagem] := 0 PedidosRetirar[3,Contagem] := 0 Retirados:= Retirados - 1 fimpara ordena_sequencia(">") //Reajusta Valores Temp:= 0 para j de 1 ate TotalPedidos faca Temp := Temp + Pedidos[2,j] fimpara LarguraTotal := Temp PesoTotal := (LarguraTotal * (Diametro / 1000)) * Peso fimprocedimento //Imprimir apenas os pedidos procedimento Pedidos_I() inicio // Seo de Comandos escreval("") //Imprimir Pedidos escreval("") escreval("============================================================================") escreval(" Pedidos ") escreval("============================================================================") Para Contagem de 1 ate TotalPedidos faca se Pedidos[2,Contagem] > 0 entao escreva("Pedido N: ",Pedidos[1,Contagem]) escreva(" | PesoTeorico: ",Pedidos[3,Contagem]) escreva(" | Largura Mm: ",Pedidos[2,Contagem]) escreval(" | Cliente: ",Clientes[Contagem]) fimse fimpara fimprocedimento //Procedimento para Ordenar o Vetor procedimento ordena_sequencia(ordem:caractere) inicio escolha ordem caso ">" j:= Cont enquanto j > 1 faca para i de 1 ate j-1 faca //Largura se Pedidos[2,i]> Pedidos[2,i+1] entao temp := Pedidos[2,i] Pedidos[2,i] := Pedidos[2,i+1] Pedidos[2,i+1] := temp //Pedido_ID temp2 := Pedidos[1,i] Pedidos[1,i] := Pedidos[1,i+1] Pedidos[1,i+1] := temp2 //Peso temp3 := Pedidos[3,i] Pedidos[3,i] := Pedidos[3,i+1] Pedidos[3,i+1] := temp3

//Cliente temp4 := Clientes[i] Clientes[i] := Clientes[i+1] Clientes[i+1] := temp4 fimse fimpara j:= j-1 fimenquanto caso "<" j:= Cont enquanto j > 1 faca para i de 1 ate j-1 faca //Largura se Pedidos[2,i] < Pedidos[2,i+1] entao temp := Pedidos[2,i] Pedidos[2,i] := Pedidos[2,i+1] Pedidos[2,i+1] := temp //Pedido_ID temp2 := Pedidos[1,i] Pedidos[1,i] := Pedidos[1,i+1] Pedidos[1,i+1] := temp2 //Peso temp3 := Pedidos[3,i] Pedidos[3,i] := Pedidos[3,i+1] Pedidos[3,i+1] := temp3 //Cliente temp4 := Clientes[i] Clientes[i] := Clientes[i+1] Clientes[i+1] := temp4 fimse fimpara j:= j-1 fimenquanto fimescolha fimprocedimento //funcao para aprovacao dos pedidos procedimento CalculaPerda () inicio ValidaBobinas:= (LarguraTotal / int((LarguraTotal / LarguraJumbo)+1)) se ValidaBobinas = LarguraJumbo entao TotalBobinas:= int((LarguraTotal / LarguraJumbo)) Perda:= 0 senao TotalBobinas:= int((LarguraTotal / LarguraJumbo)) + 1 Perda:= 100 - (((LarguraTotal / LarguraJumbo) - int((LarguraTotal / LarguraJumbo))) * 100) fimse se Perda = 100 entao Perda := 0 TotalBobinas:= TotalBobinas-1 fimse Pedidos_I() escreval("") escreval("Bobinas necessarias: ",TotalBobinas) escreval("Refugo Comercial(Sobra): ",Perda,"%") escreval("Largura Total: ",LarguraTotal) escreval("Peso Total: ",PesoTotal) escreval("Total de Pedidos: ",TotalPedidos) escreval("Optimizao: ", Retorno) se Retirados > 0 entao escreval("") escreval("===================== Pedidos Retirados ========================") para Contagem de 1 ate Retirados faca escreva("Pedido : ",PedidosRetirar[1,Contagem]) escreva(" | Quanditade: ",PedidosRetirar[2,Contagem]) escreval(" | Cliente: ",ClientesRetirados[Contagem]) escreval("===============================================================") fimpara escreval("") escreval("Deseja Recolocar esses Pedidos na sequencia? SIM / NAO")

leia(resposta) se resposta = "SIM" entao Recoloca() CalculaPerda () escreval("") fimse fimse escreval("") escreval("=========================================================================") escreval("Deseja aprovar esse pedido?") escreval("Digite SIM para imprimir a sequncia de corte ou NAO para optimizar") escreva("-> ") leia(resposta) resposta:= maiusc(resposta) se resposta = "SIM" entao limpatela imprime_pedido() senao se resposta = "NAO" entao optimiza_corte () fimse fimse fimprocedimento procedimento Retirar(Ordem:caractere) inicio ordena_sequencia(Ordem) //Ver quanto Precisa ser retirado para reduzir a perda QuantidadeRetirar := LarguraTotal - (LarguraJumbo * int((LarguraTotal / LarguraJumbo))) //Analizar Quais Pedidos Podem Ser Retirados para Contagem de 1 ate TotalPedidos faca se (SomaRetira + Pedidos[2,Contagem]) <= QuantidadeRetirar entao se (Pedidos[2,Contagem] <= QuantidadeRetirar) e (Pedidos[2,Contagem] > 0) entao Retirados:= Retirados + 1 PedidosRetirar[1,Retirados] := Pedidos[1,Contagem] PedidosRetirar[2,Retirados] := Pedidos[2,Contagem] PedidosRetirar[3,Retirados] := Pedidos[3,Contagem] ClientesRetirados[Retirados]:= Clientes[Contagem] Pedidos[1,Contagem] := 0 Pedidos[2,Contagem] := 0 Pedidos[3,Contagem] := 0 TotalPedidos:= TotalPedidos - 1 SomaRetira:= SomaRetira + PedidosRetirar[2,Retirados] fimse senao para j de 1 ate Cont faca se ((SomaRetira + Pedidos[2,j]) <= QuantidadeRetirar) e (Pedidos[2,j] > 0) entao Retirados:= Retirados + 1 PedidosRetirar[1,Retirados] := Pedidos[1,j] PedidosRetirar[2,Retirados] := Pedidos[2,j] PedidosRetirar[3,Retirados] := Pedidos[3,j] ClientesRetirados[Retirados]:= Clientes[j] Pedidos[1,j] := 0 Pedidos[2,j] := 0 Pedidos[3,j] := 0 TotalPedidos:= TotalPedidos - 1 SomaRetira:= SomaRetira + PedidosRetirar[2,Retirados] fimse fimpara fimse fimpara fimprocedimento //Recalcula procedimento Recalcula() inicio //Reajusta Valores Temp:= 0 para Contagem de 1 ate Cont faca

Temp := Temp + Pedidos[2,Contagem] fimpara LarguraTotal := Temp PesoTotal := (LarguraTotal * (Diametro / 1000)) * Peso //Vendo se a perda maior ValidaBobinas:= (LarguraTotal / int((LarguraTotal / LarguraJumbo)+1)) se ValidaBobinas = LarguraJumbo entao TotalBobinas:= int((LarguraTotal / LarguraJumbo)) Perda2:= 0 senao TotalBobinas:= int((LarguraTotal / LarguraJumbo)) + 1 Perda2:= 100 - (((LarguraTotal / LarguraJumbo) - int((LarguraTotal / LarguraJumbo))) * 100) fimse se Perda2 = 100 entao Perda2 := 0 TotalBobinas:= TotalBobinas-1 fimse fimprocedimento //Optimizao do Corte procedimento optimiza_corte () inicio limpatela cabecalho() Cont:= TotalPedidos //Salva ototal de pedidos para ordenao Retirar("<") //Rerira do Maior para o Menor Recalcula() //Recalcula Perda e Largura Total //Verifica se o calculo reduziu a perda senao tenta de outro modo Se Perda2 > Perda entao ordena_sequencia("<") //Ordena para Recolocar o que tirou Recoloca() //Recoloca Retirar(">") //Manda Retirar dessa vez do Menor para o Maior Recalcula() //Recalcula para conferir a Perda //Verifica se o novo calculo reduziu a perda senao desfaz toda a operacao se Perda2 > Perda entao ordena_sequencia("<") //Ordena para Recolocar o que tirou Recoloca() //Recoloca ordena_sequencia("<") //Ordena do maior para o menor Retorno:= "Nao foi Possivel Optimizar os Pedidos" //Define a resposta CalculaPerda () //Chama funcao de interface fimse senao ordena_sequencia("<") Retorno:= "Pedidos Optmizado" CalculaPerda () fimse fimprocedimento //Procedimento Incial Construo de interface amigavel procedimento inicial () inicio Cabecalho () escreval("") escreval(" Bem vindo ao sistema de optimizacao e cauculo das bobinas Jumbo esse") escreval(" sistema foi desenvolvido com o objetivo de facilitar o calculo de uma") escreval(" determinada quantidade de bobinas do mesmo tipo de diametro e peso de") escreval(" cada vez.") escreval("") escreval(" O sistema capaz de calcular at 20 pedidos por vez, desse modo ele") escreval(" no ir funcionar caso voc entre um valor maior que 20.") escreval("") escreval(" ---------------------------------------------------------------------") escreval(" Para iniciar o calculo digite INICIAR, para sair digite FIM ") escreva (" -> ") leia(resposta) resposta:= maiusc(resposta) se resposta = "INICIAR" entao limpatela EntraPedidos() senao

fimalgoritmo fimse fimprocedimento inicio //Inicio do Codigo Inicial() fimalgoritmo

Concluso:
Conclui-se que os operadores so indispensveis em nossos programas e que a linguagem C possui um nmero muito grande de operadores. Vimos nesse artigo mais um importante tpico para qualquer linguagem de programao as estruturas de repetio, aprendemos sobre os diversos tipos na linguagem C entre eles: lao for, lao while, lao do.. while e lao foreach.

Bibliografia:
http://www.cenapad.unicamp.br/servicos/treinamentos/apostilas/apostila_C.pdf https://docs.google.com/a/aedu.com/file/d/0Bx2ZnHfyWt9QMnFjLXd4OHZ3V28/preview https://docs.google.com/a/aedu.com/file/d/0Bx2ZnHfyWt9QN1JyTy0xaU9tVTA/preview https://docs.google.com/a/aedu.com/file/d/0Bx2ZnHfyWt9QRTM1bVBOYllSYlk/preview http://www.linhadecodigo.com.br/artigo/1177/serie-aprenda-csharp-estrutura-de-repeticao.aspx#ixzz2OhUlUiQn (MIZRAHI, Victorine Viviane. Treinamento em Linguagem C. 1 ed. So Paulo: Pearson, 2007. p. 106 a 155; p. 185 a 215) (MIZRAHI, Victorine Viviane. Treinamento em Linguagem C. 1 ed. So Paulo: Pearson, 2007. p. 106 a 155; p. 215 a 236 http://pt.wikipedia.org/wiki/Algoritmo

http://algoritmizando.com/desenvolvimento/aprender-algoritmos http://equipe.nce.ufrj.br/adriano/c/apostila/algoritmos.htm http://www.apostilando.com/download.php?cod=2143