ATPS

ALGORITMOS E PROGRAMAÇÃO

Engenharia de Produção Professor: Eriovaldo Coelho Magalhães

NOME: FABIANO GALDINO MOREIRA RA: 5222980262NOME: NELSON GABRIEL DE GODOI RA: 5212967730NOME: JOSIAS CUSTÓDIO JUNIOR RA: 5638119576NOME: LEANDRO DE ANDRADE DOMINGOS RA: 5667749592

INDICE

APRESENTAÇÃO

ETAPA 2 – PROGRAMAÇÃO ESTRUTURADA

1 - Definições de operadores1.1-Operadores aritméticos1.2-Operadores de incremento e decremento1.3-Operadores aritméticos de atribuições1.4-Operadores relacionais1.5-Operadores lógicos1.6-Operadores bit a bit1.7-Operador cast1.8-Operador sizeof

2 - Precedências3 - Controle de fluxo

3.1-Instruções condicionais4 - Operador ternario

4.1- switch5 - Estrutura de repetição

5.1-Laço for5.2-Laço while5.3-Laço do-while5.4-Desvio incondicional5.5-Comando goto

Passo 3 - Exercicios

ETAPA 3 – VETORES E MATRIZES, MODULARIZAÇÃO

1-Vetores1.1-Inicialização1.2-Vetores como argumentos de funções1.3- Vetores de caracteres

1.3.1-A função strlen()1.3.2-A função strcmp()1.3.3-A função strcpy()1.3.4-A função atrcat()

2 - Matrizes2.1 - Inicialização2.2 - Matrizes como argumento de funções

3 - Modularização3.1 - Introdução 3.2 - Procedimentos3.3 – Funções

3.3.1 - Protótipos de Funções3.3.2 - Escopo de Variáveis

3.3.2.1 - Variáveis locais3.3.2.2 - Parâmetros formais3.3.2.3 - Variáveis globais

3.3.3 - Passagem de parâmetros por valor e passagem por referência3.4 – Funções recursivas3.5 - Estruturação de módulos de um algoritmo

ETAPA 4 – STRINGS E RELATÓRIOS ESTRUTURADOS

1 - Strings2 - Manipulando strings3 - Definição de Estruturas

3.1 - Declarando uma estrutura3.2 - Declarando variáveis do tipo de uma estrutura criada3.3 - Acessando os campos de uma estrutura3.4 - Acessando uma estrutura com ponteiros

Passo 3 – Exercicios ETAPAS 3 e 4

CONCLUSÃO E BIBLIOGRAFIA

ETAPA 2 – PROGRAMAÇÃO ESTRUTURADA

1 - Definição dos Operadores Os operadores indicam ao compilador a necessidade de se fazer manipulações matemáticas ou lógicas. 1.1 - Operadores aritméticos Os operadores aritméticos são usados para calcular expressões matemáticas. Sendo classificados em duas categorias: os binários ou unários. Os operadores unários atuam na inversão de valores. Veja a tabela abaixo. 

Operador binário Descrição

= Atribuição

+ Soma

- Subtração

/ Divisão

% Modulo (obtém o resto da divisão) 

Operador unário Ação

- 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 pós-fixados conforme mostra a tabela abaixo: 

Operador Instrução Pós-fixado Pré-fixado

++ var = var+1;var = var++; 

ou var++;

var = ++var; ou

++var;

-- var = var-1;var = var--;

ou var--;

var= --var; ou

--var;

 No caso das instruções mostradas acima não existe diferença, podemos aplicar tanto o pós-fixado quanto o pré-fixado. Mas quando esses operadores são usados em outras expressões necessita-se de cuidado, pois o uso incorreto pode ocasionar resultados inesperados. A diferença entre eles é que o pré-fixado incrementa a variável para depois executar a instrução e a pós-fixado executa a instrução para depois fazer o incremento da variável. Veja o exemplo abaixo: 

 O programa acima incrementa a variável var e coloca o valor na var2 que no nosso caso será 6. Já o código abaixo coloca o valor da variável var na var2 que é 5 para depois incrementar a variável var.

 

Saída do programa: var=6var2=5 1.3 - Operadores aritméticos de atribuições São combinações de operadores que simplificam as instruções e que geralmente são usados por programadores experientes. Dessa forma uma instrução escrita da forma: Var= var operador + expressão Pode ser reduzida obedecendo à sintaxe: Var operador= expressão Veja alguns exemplos utilizando duas variáveis (var e expr) que devem ser declaradas em seus programas. 

Instrução normal Instrução reduzida

var = var + expr; var+=expr;

Var=var – expr; Var-=expr;

Var=var/expr; Var/=expr;

Var=var*expr; Var*=expr; 

1.4 - Operadores relacionais Esses operadores são responsáveis pelas comparações de expressões nos programas. A lista completa se encontra abaixo: 

Operador Descrição

> Maior

>= Maior igual

< Menor

<= Menor igual

== Igualdade

!= Diferente

 É importante distinguir (=) de (==). O primeiro atribui um valor e o segundo comprara expressões. 1.5 - Operadores lógicos Os operados lógicos servem para interligar mais de uma operação relacional. E assim como os relacionais retornam zero para falso e um para verdadeiro. 

Operador Descrição

&& AND

|| OR

! NOT (operador de negação)

 Exemplo de utilização de operadores lógicos: 

 

Saída do programa: O número 76 esta entre 65 e 80 Nesse programa o operador lógico (&&) faz a ligação das operações relacionais (x>65) e (x<=80), verificando se o número dado (x) está entre essa faixa. A instrução if será estudada no próximo artigo. 1.6 - Operadores bit a bit Como já sabemos a linguagem C é considerada de baixo nível, pois permite a manipulação de bits. Isto é feito através dos operadores bit a bit listados a seguir. 

Operador Descrição

& AND

| OR

^ XOR (OR exclusivo)

<< Deslocamento para esquerda

>> Deslocamento para direita

 Embora a descrição na tabela seja parecida com as dos operadores Lógicos eles não devem ser confundidos. Os operadores bit a bit são muito usados em rotinas de modens e de impressoras. 1.7 - Operador Cast Tem como função forçar para que uma expressão seja de um determinado tipo. Sua sintaxe é: (tipo de dado) expressão O tipo de dado pode ser qualquer um dos definidos pelo padrão ANSI. Um exemplo da utilização deste operador pode ser visto no programa mostrado neste artigo para exemplificar o uso dos operadores aritméticos. Nesse programa o operador cast é usado para forçar a divisão de dois números inteiros ser do tipo float.

1.8 - Operador Sizeof Este operador é usado em tempo de execução e tem como objetivo retornar o tamanho em bytes da variável. 

 

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

2 - Precedências Precedência é a prioridade com que os operadores são executados pelo compilador. Caso os operadores tenham o mesmo nível de precedência eles são analisados da esquerda para direita. 

Prioridades dos operadores aritméticos

Alta Incremento(++), decremento (--)

Menos unitário (-)

Multiplicação(*), divisão(/), modulo(%)

Baixa Soma(+), subtração(-) 

A precedência dos operadores pode ser mudada utilizando parentes. Para entender melhor veja o exemplo abaixo, onde as duas expressões são iguais, porém o uso de um parêntese fez mudar a precedência obtendo assim resultados diferentes. 4/2*5+1=114/2*(5+1)=12 3 - Controle de Fluxo Os comandos de controle de fluxo podem ser divididos em três grupos: Instruções condicionais, estrutura de repetição e os desvios incondicionais que serão apresentados a seguir. 3.1 - Instruções Condicionais As instruções condicionais existentes no padrão ANSI são: if, switch e o operador ternário (?). 

Instrução If Esta instrução obedece à sintaxe: 

if (condição) instrução para condição verdadeira ;else instrução para condição falsa;

 Pode-se utilizar uma ou mais instruções verdadeiras e falsas no if. Caso seja mais de uma deve-se colocar entre chaves. Se a condição é verdadeira serão executadas apenas as instruções localizadas após a instrução if. Caso contrario somente as instruções após o else serão executadas. O else é opcional conforme mostra o exemplo abaixo que efetua a soma de dois números e avisa ao usuário quando o resultado obtido for um número 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 instrução scanf que será ensinada num próximo artigo. O importante agora é saber que ela é a responsável pela entrada de dados pelo console. Abaixo pode ser visto a entrada do usuário e saída do programa. Digite o primeiro valor inteiro a ser somado: 2Digite o segundo valor inteiro a ser somado: 4Soma:6 – numero par Esse mesmo programa pode ser reescrito para que avise também ao usuário 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");elseprintf(" - numero impar\n");}

 Isto é feito acrescentando o else a instrução 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 padrão também permite o uso de ifs alinhados, obedecendo à forma: 

If(condição)Instrução;ElseIf(condição)Instrução;ElseIf(condição)Instrução;...ElseInstrução;

 

Para entender melhor veja o próximo 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");elseif((nota>=6)&&(nota<=7))printf("Nota correspondente a B!!!\n");elseif((nota>=4)&&(nota<=5))printf("Nota correspondente a C!!!\n");elseif((nota>=2)&&(nota<=3))printf("Nota correspondente a D!!!\n");elseif((nota>=0)&&(nota<=1))printf("Nota correspondente a E!!!\n");elseprintf("Nota invalida!!!\n");}

 4 - O operador ternário (?) O operador ? é muito utilizado no lugar da instrução if. Este operador requer três operando e pode ser escrito da seguinte forma: Exp1? Exp2: Exp3 Neste exemplo o usuário entra com o valor de x, se o valor de x for menor ou igual a 0 então o valor de x é incrementado de 1 é atribuído 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(expressão){case constante1:seqüência de comandosbreak;case constante2:seqüência de comandosbreak;case constante3:seqüência de comandosbreak; ...default:seqüência de comandos

Esta instrução compara a expressão com todas as constantes caso seja verdadeira ela executa as seqüências de comandos daquela constante. Caso todas as alternativas sejam falsas o comando default é executado. A instrução break demonstrada acima é opcional, é ela que para a execução do switch case. O Padrão ANSI permite usar 257 comandos case. O comando switch compara apenas igualdades, enquanto que o if comparar qualquer expressão lógica ou relacional. Como exemplo será criado um menu para que o usuário escolha entre fazer a soma de dois números ou calcular a media. 

#include<stdio.h>void main(){int entrada;printf("Digite 1 para calcular a soma de dois numeros\n");printf("Digite 2 para calcular a media\n");scanf("%d",&entrada);switch(entrada){case 1:printf("Vc escolheu a opcao de somar dois numeros");case 2:printf("Vc escolheu a opcao de calcular a media");default:printf("Nenhuma das opcoes foi selecionada");}} 

5 - Estrutura de repetição As estruturas de repetição são utilizadas para que um conjunto de instruções seja executado até que ocorra uma certa condição. O laço for diferencia dos restantes( while e do-while) por ter condições pré-definidas, ou seja, o numero de vezes a ser executada já é conhecido. 5.1 - Laço for Sintaxe do laço: 

For(inicialização; condição ; incremento) comando; Na inicialização é atribuído um valor para variavel que controla o laço, a condição determina quando o laço deve ser encerrado e por ultimo temos o quanto a variável 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 variável n com o valor, a instrução que escreve o valor de n será executada enquanto n for menor ou igual a 10, sendo que n é incrementada de 1 em iteração. Sendo assim a saída do programa será: n=1n=2n=3n=4n=5n=6n=7n=8n=9n=10 5.2 - Laço While Sua forma geral é: 

while (condição) Instrução; Este laço executa a instrução até que a condição 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 laços while, o primeiro executa a soma de dois números 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 números ou 2 para terminar o programa. 5.3 - Laço do-while A grande diferença entre o laço do-while e os vistos anteriormente é que ele analisa a condição no final do laço. Dessa forma todas as instruções localizadas dentro do do-while será executada pelo menos uma vez. O laço termina quando a condição se torna falsa. Sintaxe: 

Do{Instrução;}while(condição) 

O programa anterior também 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 diferença é que este programa permite digitar outro número além de 1 e 2, porém será exibida a mensagem “Programa finalizado, este numero não existe no menu”.

 5.4 - Desvio incondicional A linguagem C tem como desvio incondicional o comando goto.

5.5 - Comando goto Esta instrução ou comando é muito pouco utilizado, pois tornam os códigos difíceis de se compreender. Por esse motivo não entraremos em muitos detalhes. Veja o exemplo abaixo, ele faz o mesmo do que o exemplo que utilizando o laço for (mostrado anteriormente). Repare que o programa que utiliza o for é muito mais fácil de se entender. 

#include<stdio.h> void main(){int n;n=1;loop1: /*rótulo*/printf("n=%d\n",n);n++;if(n<=10) goto loop1; /*caso n seja menor ou igual a 10 volta para o rótuloacima, executando assim as instruções outra vezaté que a condição do if seja falsa*/}

  PASSO 3 - Exercícios

Utilizando conceitos de Algoritmos em linguagem “C”, utilizando o programa DEV C++ para desenvolver o exercício 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, MODULARIZAÇÃO

1 - Vetores

Um vetor armazena uma determinada quantidade de dados de mesmo tipo. Vamos supor o problema de encontrar a média 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 desejássemos encontrar a média das idades de 500 pessoas. A tarefa passa a ser bem mais trabalhosa, sendo em diversos casos impraticável se resolver da maneira apresentada acima.A solução para este problema é a utilização de vetores. Um vetor é uma série de variáveis de mesmo tipo referenciadas por um único nome, onde cada variável é diferenciada através de um índice, que é representado entre colchetes depois do nome da variável.A declaração int idade[4], aloca memória para armazenar 4 inteiros e declara a variável idade como um vetor de 4 elementos.O programa da média das idades poderia ser substituído 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 código fica independente do tamanho do vetor.

Para acessar um determinado elemento do vetor, deve-se chamar o elemento pelo nome da variável seguido do índice, entre colchetes. Note que o índice começa em 0, e não em 1. Ou seja, o elemento idade[2] não é o segundo elemento e sim o terceiro, pois a numeração começa de 0. Em nosso exemplo utilizamos uma variável 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 variável idade como um vetor de 5 elementos (0 a 4). Definimos os elementos do vetor mas, na última definição, ultrapassamos o limite do vetor. A linguagem C não realiza verificação de limites em vetores. Quando o vetor foi definido, o compilador reservou o espaço de memória equivalente a 5 variáveis inteiras, ou seja, 10 bytes. Quando tentamos acessar um elemento que ultrapasse o limite de um vetor, estamos acessando uma região de memória que não pertence a esse vetor.

1.1 - Inicialização

A linguagem C permite que vetores sejam inicializados. No caso, será inicializada uma variável contendo o número de dias de cada mês:

int numdias[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

O número 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 número for fornecido para inicializar o vetor, o compilador contará o número de itens da lista de inicialização e o fixará como dimensão do vetor.Na falta de inicialização explícita, variáveis extern e variáveis static são inicializadas com valor zero; variáveis automáticas têm valor indefinido (isto é, lixo).Se há menos inicializadores que a dimensão especificada, os outros serão zero. Se há mais inicializadores que o especificado, o compilador acusa um erro.Em C não há como se especificar a repetição 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 funções

Vetores podem ser passados também como argumentos de funções. Vamos rescrever o programa que calcula a média das idades para um programa contendo uma função que receba um vetor e retorne a sua média.

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 declaração da função, o argumento que representa o vetor é declarado com colchetes.Além dele, passamos como argumento da função também o tamanho do vetor. Sem ele, a função não tem como saber o tamanho do vetor que foi passado a ela como argumento.Na função main(), chamamos a função media() passando dois atributos: idade e 5. Para acessarmos um elemento do vetor, escrevemos após 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 endereço de memória acessado por esse vetor. Ou seja, ao passarmos um vetor como argumento da função, o compilador não cria uma cópia do vetor para ser utilizada na função. É o próprio vetor quem é passado como argumento e pode ser alterado na função.

1.3 - Vetores de caracteres

O vetor de caracteres, também 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, através 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 variável do tipo string, deve-se declará-la como um vetor de caracteres, ou seja:

char Nome[50];

Esta declaração cria a variável 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 declaração:

char Nome[5] = "Pedro";

é inválida, por não ter sido reservado espaço suficiente para as 6 variáveis ('P', 'e', 'd', 'r', 'o' e '\0').Para manipulação de strings, são fornecidas diversas funções na biblioteca C (arquivo string.h).Algumas dessas funções são descritas a seguir. A sintaxe apresentada para cada função não é exatamente a sintaxe fornecida pela biblioteca, mas representa basicamente o que a função executa e jáfoi explicado até o presente momento.

1.3.1 - A função strlen()

A função strlen() retorna o número 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 espaços fazem parte da string, e são simplesmente caracteres, assim como letras e algarismos.

1.3.2 - A função strcmp()

A função 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 pôr comparação entre strings, sua posição em ordem alfabética. A ordem alfabética é baseada na tabela ASCII (Anexo A). Portanto, cuidado ao comparar maiúsculas com minúsculas, pois na tabela ASCII as letras maiúsculas possuem um valor menor que as letras minúsculas, 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"));}

Espaços e outros caracteres especiais também são considerados na comparação, algumas vezes não fornecendo o que se espera de uma ordenação alfabética.

1.3.3 - A função strcpy()

A função strcpy() copia o conteúdo de uma string para outra. A string de destino já tem que ter espaço reservado na memória antes de ser chamada a função.Sintaxe:

void strcpy(char[] destino, char[] origem);

Exemplo:

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

1.3.4 - A função strcat()

A função strcat() concatena duas strings, ou seja, anexa o conteúdo de uma na outra. Similarmente à função strcpy(), a string de destino tem que ter espaço reservado na memória.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 são vetores. Com dois pares de colchetes, obtemos uma e, para cada par de colchetes adicionado, obtemos uma matriz com uma dimensão a mais.Por exemplo, a declaração

int A[5][6];

indica que A é uma matriz 5x6 e seus elementos são inteiros.

2.1 – Inicialização

As matrizes são inicializadas como os vetores, ou seja, os elementos são colocados entre chaves e separados por vírgulas. Como seus elementos são vetores, estes, por sua vez, também são inicializados com seus elementos entre chaves e separados por vírgulas. 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 inicialização pode se dar da forma

char Nome[5][10] = {"Joao", "Jose", "Maria", "Geraldo", "Lucia"};A matriz será inicializada comoJ o a o \0 \0 \0 \0 \0 \0J o s e \0 \0 \0 \0 \0 \0M a r i a \0 \0 \0 \0 \0G e r a l d o \0 \0 \0L u c i a \0 \0 \0 \0 \0

2.2 - Matrizes como argumento de funções

A passagem de uma matriz para uma função é similar à passagem de um vetor. O método de passagem do endereço da matriz para a função é idêntico, não importando quantas dimensões ela possua, já que sempre é passado o endereço da matriz.Entretanto, na declaração da função, a matriz é um pouco diferente. A função deve receber o tamanho das dimensões a partir da segunda dimensão. Por exemplo:

void Determinante(double A[][5]);

Note que é fornecido a segunda dimensão da matriz. Isto é necessário para que, ao chamarmos o elemento A[i][j], a função saiba a partir de que elemento ela deve mudar de linha. Com o número de elementos de cada linha, a função pode obter qualquer elemento multiplicando o número da linha pelo tamanho de cada linha e somando ao número da coluna.Por exemplo, o elemento A[2][3], é o elemento de índice 13, já que 2 * 5 + 3 = 13.

3 - Modularização

3.1 - Introdução

Vimos que os algoritmos estruturados são desenvolvidos levando-se em conta algumas premissas básicas: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 módulos funcionais, organizados de preferência em um sistema hierárquico. Esses módulos trazem vantagens adicionais para testes, pois testa-se um módulo (ou seja, uma parte do programa) de cada vez, independentemente; e para reutilização de um módulo em outros algoritmos e programas, no futuro.Passaremos agora a formalizar a utilização de módulos nos nossos algoritmos e verificar as vantagens que os mesmos trazem para entendimento, construção, codificação, teste e reutilização dos mesmos. A grande maioria das linguagens de programação que são utilizadas, tem esta facilidade, seja com o nome de Sub-rotinas, Subprogramas, Procedimentos, Funções, Módulos, Blocos, etc., sempre é possível subdividir-se um programa de modo a facilitar o entendimento, permitir a reutilização, evitando-se a repetição de blocos dos programas. No nosso pseudo-código definiremos dois tipos de módulos: Os procedimentos ("procedures") e as funções ("functions"). Os procedimentos e funções são normalmente definidos antes de serem utilizados(chamados) pelo programa principal. Em se tratando de algoritmos, entretanto, poderemos definir nossos procedimentos e funções em qualquer parte do algoritmo principal ou depois dele, adotando os formatos que se seguem e as normas de documentação.

3.2 - Procedimentos

Um procedimento é uma seqüência de comandos precedida por uma seqüência de declarações que possui um identificador (nome do procedimento), uma lista de parâmetros opcional e pode realizar qualquer tipo de processamento que o programador ou analista deseje. As variáveis, os tipos e as constantes declaradas dentro de um procedimento só são acessáveis dentro dos comandos do procedimento. São chamadas variáveis locais. Em um Algoritmo, as variáveis, tipos e constantes declaradas logo após o identificador do algoritmo, são acessíveis e visíveis dentro de qualquer procedimento que esteja sendo usado pelo algoritmo. São chamadas variáveis Globais. É uma boa técnica ao se construir um procedimento, não fazer uso no mesmo, de variáveis globais e referenciar e utilizar apenas as variáveis locais e os parâmetros do procedimento. Isso fará com que cada procedimento, ao ser modificado, não afete outras partes o Algoritmo, e da mesma forma as variáveis globais poderão ser modificadas sem que haja efeitos colaterais nos procedimentos.

Sintaxe de declaração:

Procedimento < nome do Procedimento>Início<declarações>;C1;C2;Cn;Fim { nome do procedimento}.

Exemplo:

InícioInteiro: X,Y,A,B,C,D;Procedimento troca;InícioInteiro: AUX,X;AUX←X;X←Y;Y←AUX;Fim troca.

A←5;B←3;Imprima(A, B);X←A;Y←B;Troca;A←X;B←Y;Imprima(A, B);C←4;D←9;Imprima(C, D);X←C;Y←D;Troca;C←X;D←Y;Imprima(C, D);Fim.

Os módulos usados anteriormente são procedimentos sem parâmetros, ou seja, que fazem uso de variáveis globais e sua única importante vantagem é facilitar o entendimento e a solução do algoritmo.Utilizando parâmetros e não variáveis globais dentro do procedimento, podemos, por assim dizer, isolá-lo do meio exterior e obter vantagens adicionais na codificação, pois, uma vez que foram bem definidos os parâmetros, um programador poderá desenvolver seu procedimento sem se preocupar com o algoritmo que o vai chamar. Poderemos também testá-lo individualmente e isoladamente para verificar sua correção. Isto será comprovado na disciplina LP. A isto se denomina Encapsulamento. Uma lista de parâmetros consiste em uma lista de variáveis e seus respectivos tipos.

Procedimento < nome do Procedimento> (<lista de parâmetros>)

Início<declaração de variáveis locais> C1;C2;Cn;Fim. { nome do procedimento}

Exemplo de Procedimento:

Procedimento TROCAINTEIROS (Inteiro NUM1,inteiro NUM2)

InícioInteiro AUXNUM;AUXNUM = NUM1;NUM1 = NUM2;NUM2 = AUXNUM;

Fim.

3.3 – Funções

Funções são as estruturas que permitem ao usuário separar seus programas em blocos. Se não as tivéssemos, os programas teriam que ser curtos e de pequena complexidade. Para fazermos programas grandes e complexos temos de construí-los bloco a bloco.Uma função é um módulo que tem por objetivo calcular e retornar ao algoritmo, procedimento ou função "chamador" um valor. A chamada de uma função para execução é feita apenas citando-se o seu identificador no meio de uma expressão. Vide as funções previamente existentes no nosso pseudo-código. Uma função é dita recursiva quando chama a ela própria.

Uma função no C tem a seguinte forma geral:

tipo_de_retorno nome_da_função (declaração_de_parâmetros)

Iníciocorpo_da_funçãoFim.

Aqui no nosso Pseudo-Código utilizaremos a seguinte forma

Pseudo - Código

Tipo-de-retorno<nome da função>(<declaração dos parâmetros>)InícioCorpo da FunçãoFim.

Onde:

A lista de parâmetros é semelhante à dos procedimentos.Antes do nome da função dá o tipo do valor que a função retorna ao algoritmo ou procedimento chamador. O tipo-de-retorno é o tipo de variável que a função vai retornar. O default é o tipo inteiro (int), ou seja, uma função para qual não declaramos o tipo de retorno é considerada como retornando um inteiro. A declaração de parâmetros é 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 variáveis de entrada. É na declaração de parâmetros que informamos ao compilador quais serão as entradas da função (assim como informamos a saída no tipo-de-retorno).O corpo da função é a sua alma. É nele que as entradas são processadas, saídas são geradas ou outras coisas são feitas.O comando return tem a seguinte forma geral:

retorna valor_de_retorno; ou retorna;

Digamos que uma função está sendo executada. Quando se chega a uma declaração retorna (return) a função é encerrada imediatamente e, se o valor de retorno é informado, a função retorna este valor. É importante lembrar que o valor de retorno fornecido tem que ser compatível com o tipo de retorno declarado para a função.Uma função pode ter mais de uma declaração retorna (return). Isto se torna claro quando pensamos que a função é terminada quando o programa chega à primeira declaração retorna (return). Abaixo estão dois exemplos de uso do retorna (return):

Exemplo de função:

Inteiro VALORABSOLUTO (inteiro X)

InícioSe X > = 0 EntãoVALORABSOLUTO =X;SenãoVALORABSOLUTO = (-X);Fim Se;Fim.

3.3.1 - Protótipos de Funções

Até agora, nos exemplos apresentados, escrevemos as funções antes de escrevermos a função principal, main(). Isto é, as funções estão fisicamente antes da função principal main(). Isto foi feito por uma razão. Imagine-se na pele do compilador. Se você fosse compilar a função main(), onde são chamadas as funções, você teria que saber com antecedência quais são os tipos de retorno e quais são os parâmetros das funções para que você pudesse gerar o código corretamente. Foi por isto que as funções foram colocadas antes da função main(): quando o compilador chegasse à função main() ele já teria compilado as funções e já saberia seus formatos. Mas, muitas vezes, não poderemos nos dar ao luxo de escrever nesta ordem. Muitas vezes teremos o nosso programa espalhado por vários arquivos. Ou seja, estaremos chamando funções em um arquivo que serão compiladas em outro arquivo. Como manter a coerência? A solução são os protótipos de funções. Protótipos são nada mais, nada menos, que declarações de funções. Isto é, você declara uma função que irá usar. O compilador toma então conhecimento do formato daquela função antes de compilá-la. O código correto será então gerado. Um protótipo tem o seguinte formato:

tipo_de_retorno nome_da_função (declaração_de_parâmetros);

onde o tipo- de-retorno, o nome-da-função e a declaração-de-parâmetros são os mesmos que você pretende usar quando realmente escrever a função. Repare que os protótipos têm uma nítida semelhança com as declarações de variáveis. Vamos implementar agora um dos exemplos da seção anterior com algumas alterações e com protótipos:

Em Pseudo-Código

inteiro Square (inteiro a); Algoritmo Principal início 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) início 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 função Square() está colocada depois do algoritmo principal, mas o seu protótipo está antes. Sem isto este programa não funcionaria corretamente.Usando protótipos você pode construir funções que retornam quaisquer tipos de variáveis. É bom ressaltar que funções podem também retornar ponteiros sem qualquer problema. Os protótipos não só ajudam o compilador. Eles ajudam a você também: usando protótipos, o compilador evita erros, não deixando que o programador use funções com os parâmetros errados e com o tipo de retorno errado, o que é uma grande ajuda!

3.3.2 - Escopo de Variáveis

O escopo é o conjunto de regras que determinam o uso e a validade de variáveis nas diversas partes do programa.

3.3.2.1 - Variáveis locais

O primeiro tipo de variáveis que veremos são as variáveis locais. Estas são aquelas que só têm validade dentro do bloco no qual são declaradas. Podemos declarar variáveis dentro de qualquer bloco. Só para lembrar: um bloco começa quando abrimos uma chave e termina quando fechamos a chave. Até agora só tínhamos visto variáveis locais para funções completas. Mas um comando para(for) pode ter variáveis locais e que não serão conhecidas fora dali. A declaração de variáveis locais é a primeira coisa que devemos colocar num bloco. A característica que torna as variáveis locais tão importantes é justamente a de serem exclusivas do bloco. Podemos ter quantos blocos quisermos com uma variável local chamada x, por exemplo, e elas não apresentarão conflito entre elas.A palavra reservada do C auto serve para dizer que uma variável é local. Mas não precisaremos usá-la pois as variáveis declaradas dentro de um bloco já são consideradas locais.Abaixo vemos um exemplo de variáveis locais:

Em Pseudo-Código

funcao1 (...)Iníciointeiro abc,x;Fim....funcao (...) Iníciointeiro abc;Fim....inteiro principal () Iníciointeiro 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 três funções. As variáveis locais de cada uma delas não irão interferir com as variáveis locais de outras funções. Assim, a variável abc de func1() não tem nada a ver (e pode ser tratada independentemente) com a variável abc de func2(). A variável x de func1() é também completamente independente da variável x da função principal main(). As variáveis a, b e c são locais ao bloco para(for). Isto quer dizer que só são

conhecidas dentro deste bloco e são desconhecidas no resto da função Principal(main()). Quando usarmos a variável a dentro do bloco para (for) estaremos usando a variável a local ao para(for) e não a variável a da função main().

3.3.2.2 - Parâmetros formais

O segundo tipo de variável que veremos são os parâmetros formais. Estes são declarados como sendo as entradas de uma função. Não há motivo para se preocupar com o escopo deles. É fácil: o parâmetro formal é uma variável local da função. Você pode também alterar o valor de um parâmetro formal, pois esta alteração não terá efeito na variável que foi passada à função. Isto tem sentido, pois quando o C passa parâmetros para uma função, são passadas apenas cópias das variáveis. Isto é, os parâmetros formais existem independentemente das variáveis que foram passadas para a função. Eles tomam apenas uma cópia dos valores passados para a função.

3.3.2.3 - Variáveis globais

Variáveis globais são declaradas, como já sabemos, fora de todas as funções do programa. Elas são conhecidas e podem ser alteradas por todas as funções do programa. Quando uma função tem uma variável local com o mesmo nome de uma variável global a função dará preferência à variável local. Vamos ver um exemplo no nosso pseudo-Código:

inteiro z,k;func1 (...){inteiro x,y;...}func2 (...){inteiro x,y,z;...z=10;...}principal{inteiro count;...}

No exemplo acima as variáveis z e k são globais. Veja que func2() tem uma variável local chamada z. Quando temos então, em func2(), o comando z=10 quem recebe o valor de 10 é a variável local, não afetando o valor da variável global z.Evite ao máximo o uso de variáveis globais. Elas ocupam memória o tempo todo (as locais só ocupam memória enquanto estão sendo usadas) e tornam o programa mais difícil de ser entendido e menos geral.

3.3.3 - Passagem de parâmetros por valor e passagem por referência

Já vimos que, na linguagem C, quando chamamos uma função os parâmetros formais da função copiam os valores dos parâmetros que são passados para a função. Isto quer dizer que não são alterados os valores que os parâmetros têm fora da função. Este tipo de chamada de função é denominado chamada por valor. Isto ocorre porque são passados para a função apenas os valores dos parâmetros e não os próprios parâmetros. Veja o exemplo abaixo:

Exemplo

Em Pseudo-Código

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 parâmetro formal num da função sqr() sofre alterações dentro da função, mas a variável num da função principal main() permanece inalterada: é uma chamada por valor.Outro tipo de passagem de parâmetros para uma função ocorre quando alterações nos parâmetros formais, dentro da função, alteram os valores dos parâmetros que foram passados para a função. Este tipo de chamada de função tem o nome de "chamada por referência". Este nome vem do fato de que, neste tipo de chamada, não se passa para a função os valores das variáveis, mas sim suas referências (a função usa as referências para alterar os valores das variáveis fora da função).O C só faz chamadas por valor. Isto é bom quando queremos usar os parâmetros formais à vontade dentro da função, sem termos que nos preocupar em estar alterando os valores dos parâmetros que foram passados para a função. Mas isto também pode ser ruim às vezes, porque podemos querer mudar os valores dos parâmetros fora da função também. O C++ tem um recurso que permite ao programador fazer chamadas por referência. Há entretanto, no C, um recurso de programação que podemos usar para simular uma chamada por referência. Quando queremos alterar as variáveis que são passadas para uma função, nós podemos declarar seus parâmetros formais como sendo ponteiros. Os ponteiros são a "referência" que precisamos para poder alterar a variável fora da função. O único inconveniente é que, quando usarmos a função, teremos de lembrar de colocar um & na frente das variáveis que estivermos passando para a função. 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;}

Não é muito difícil. O que está acontecendo é que passamos para a função Swap o endereço das variáveis num1 e num2. Estes endereços são copiados nos ponteiros a e b. Através do operador * estamos acessando o conteúdo apontado pelos ponteiros e modificando-o. Mas, quem é este conteúdo? Nada mais que os valores armazenados em num1 e num2, que, portanto, estão sendo modificados!

3.4 – Funções recursivas

Existem casos em que um procedimento ou função chama a si próprio. Diz-se então que o procedimento ou função é recursivo. Por exemplo, o fatorial de um número n pode ser definido recursivamente, ou seja:

n ⋅(n −1)! n! =1 se n = 0

inteiro fat(inteiro n) InícioSe n==0 Então fat=1;Senãofat=n*fat(n-1);Fim Se;Fim.

Por exemplo, o fatorial de 3 será calculado a partir da chamada à função pelo comando x =fat(3) que retornará em fat o valor 6.

3.5 - Estruturação de módulos de um algoritmo

Um procedimento nada mais é que um algoritmo hierarquicamente subordinado a um outro algoritmo, comumente chamado de Módulo principal ou programa principal ou ainda algoritmo principal.Da mesma forma, um procedimento poderá conter outros procedimentos (e também funções) 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 criação, um algoritmo estruturado, com módulos hierarquicamente subordinados e muito menos suscetível a erros de lógica na fase de codificação do programa.

ETAPA 4 – STRINGS E RELATÓRIOS ESTRUTURADOS

1 - Strings

Um dos tipos de arranjos que mais ocorre em C é o arranjo de caracteres, ou string. C não suporta um tipo básico string; ao invés, há uma convenção para tratamento de arranjos de caracteres que permite o uso de diversas funções de manipulação de strings na linguagem.Por convenção, C considera como uma string uma seqüência de caracteres armazenada sob a forma de um arranjo de tipo char cujo último elemento é o caráter NUL, tipicamente representado na forma de caráter, '\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 espaço para o caráter '\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 três letras, já que o último caráter está reservado para o NUL.C suporta uma forma alternativa de representação de um string constante, que é através do uso de aspas:

char exemplo[4] = "abc";

Este exemplo é equivalente ao anterior -- a string "abc" contém quatro caracteres, sendo que o caráter '\0' é automaticamente anexado à string pelo compilador.

2 – Manipulando strings

Funções que manipulam strings trabalham usualmente com a referência para o início da seqüência de caracteres, ou seja, com um ponteiro para a string. A manipulação de ponteiros é fonte usual de confusão em qualquer linguagem. Por exemplo, tendo duas variáveis ponteiros char* s1 e char* s2 indicando o início de duas strings, não seria possível copiar o conteúdo de s2 para s1 simplesmente por atribuição,

s1 = s2; /* copia o endereco! */

ou comparar seus conteúdos diretamente,

if (s1 != s2) /* compara os enderecos! */ Diversas rotinas são suportadas para manipular strings na biblioteca padrão 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 protótipos para essas rotinas estão definidos no arquivo de cabeçalho string.h. Nesses protótipos, size_t é um nome de tipo para representar tamanhos correspondentes a algum tipo inteiro definido no arquivo de cabeçalho stddef.h.

A função strcat concatena a string apontada por s2 à string apontada por s1. O arranjo associado ao endereço s1 deve ter espaço suficiente para armazenar o resultado concatenado.

A função strncat permite limitar a quantidade de caracteres concatenados, agregando no máximo n caracteres de s2 a s1.

A função strcmp compara o conteúdo de duas strings. Se a string apontada por s1 for igual àquela de s2, o valor de retorno da função é 0. Se forem diferentes, o valor de retorno será negativo quando a string em s1for lexicograficamente menor que aquela de s2, ou positivo caso contrário.

A função strncmp compara no máximo até n caracteres das duas strings.

A função strcpy copia a string em s2 (até a ocorrência do caráter '\0') para o arranjo apontado por s1.

A função strncpy copia no máximo até n caracteres. Observe que neste caso, se a string em s2 for maior quen caracteres, a string resultante não será terminada pelo caráter '\0'.

A função strlen retorna o comprimento da string em s, sem incluir nessa contagem o caráter '\0'.

A função strchr retorna o apontador para a primeira ocorrência do caráter c na string em s, ou o apontador nulo se o caráter não está presente na string.

Além destas funções, é interessante destacar que existe uma função sprintf (declarada em stdio.h e parte da biblioteca padrão) que permite formatar valores seguindo o mesmo padrão utilizado em printf, com a diferença que a saída formatada é colocada em uma string ao invés de ser enviada para a tela. Seu protótipo é:

int sprintf (char *s, const char *format, ...);

É responsabilidade do programador garantir que o arranjo para a string apontado por s tenha espaço suficiente para armazenar o resultado.

3 - Definição de Estruturas

Através do conceito de estrutura, C oferece um mecanismo uniforme para a definição de registros, unidades de informação organizadas em campos de tipos que podem ser não-homogêneos.Como um exemplo, esse mecanismo pode ser aplicado tanto a uma linha de código assembly, com campos associados a rótulo, código de operação, operandos e comentários, como a tabelas, com campos símbolo e valor. Considere a definição de uma entidade linha, composta por quatro componentes -- rotulo, opcode, operand, comment. Cada componente é um arranjo de caracteres de tamanho adequado à recepção 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;

Variáveis deste tipo de estrutura podem ser definidas como

Linha l;

Apesar deste exemplo só ter como componentes seqüências de caracteres, qualquer tipo válido pode estar presente em uma estrutura -- até mesmo outra estrutura, como em

struct linCode { int posicao; Linha linha; };

Usando essa estrutura Linha, uma versão simplificada da função 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 aplicações sucessivas do operador . -- quando for necessário acessar estruturas aninhadas -- a associativadade é da esquerda para a direita.Em situações onde há a necessidade de se minimizar o espaço ocupado por dados de um programa, pode ser preciso compartilhar uma palavra da máquina para armazenar diversas informações. Neste caso, é preciso trabalhar a nível de subseqüências de bits internas à representação de um número inteiro.A forma básica de manipular bits em um inteiro seria através dos operadores bit-a-bit, trabalhando com máscaras e deslocamentos para isolar as informações individuais. Entretanto, a linguagem C suporta o conceito decampos de bits internos a um inteiro para facilitar este tipo de manipulação. Campos são baseados em estruturas.Por exemplo, considere uma instrução de um dado dispositivo que está sendo programado em C. Cada instrução neste dispositivo têm um formato binário de codificação em quatro bits que especificam a operação, seguidos por dois campos de seis bits cada que especificam a fonte e o destino associados à operação dada. Com o uso de campos, uma variável poderia ser definida como:

struct { unsigned int opcode: 4; unsigned int fonte: 6; unsigned int dest: 6; } instrucao;

Campos são acessados exatamente da mesma forma que membros de estruturas, comportando-se como inteiros sem sinal.

3.1 - Declarando uma estrutura

A sintaxe para a declaração (ou criação) de uma estrutura é:

struct NOME_DA_ESTRUTURA { TIPO CAMPO1; TIPO CAMPO2; ........... ........... TIPO CAMPOn; };

Para o caso exemplificado no item anterior poderíamos 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 declaração da estrutura não cria, ainda, uma variável. A declaração da estrutura apenas cria um novo tipo de dado. Após criar a estrutura você pode declarar variáveis do tipo de estrutura criado.

3.2 - Declarando variáveis do tipo de uma estrutura criada

Após a declaração da estrutura você pode declarar variáveis do tipo da estrutura com a sintaxe:

struct NOME_DA_ESTRUTURA NOME_DA_VARIÁVEL;

Exemplo:

struct produto item;

Observe que esta sintaxe obecede a sintaxe normal para a declaração de variáveis:

TIPO NOME_DA_VARIÁVEL;

sendo o TIPO da variável, a nova estrutura criada ( struct NOME_DA_ESTRUTURA ).

Você também pode declarar a variável logo após a declaração 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 código 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 variável "item" do tipo "struct

produto" */

printf("Preenchendo a variável \"item\"\n");

printf("Item............:"); fgets(item.nome,50,stdin); printf("Código..........:"); 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("Código..........:%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 após a primeira alteração\n"); printf("Nome: %s",ficha.nome); printf("Idade: %d.\n",ficha.idade);

altera_estrutura2(&ficha); printf("\nExibindo os dados após a segunda alteração\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 também e bem conhecida entre os programadores de linguagem “C” devido a melhor familiarização com a linguagem. Foi usado o programa de linguagem chamado VISUALG que realiza a interpretação do algoritmo de forma bem simples.

algoritmo "calculo_bobinas"// Função : Optimizar o corte de bobinas Jumbo// Autor : Fabiano G. Moreira// Data : 08/06/2013// Seção de Declarações

varNomeCliente,resposta,temp4,Retorno:caracterePedido_ID, Contagem, cont, TotalPedidos, i, j, Retirados:inteiroLargura, LarguraTotal, Peso, Perda2, PesoTotal, PesoTeorico, Diametro, ValidaBobinas:realLarguraJumbo, TotalBobinas, Perda, temp, temp2, temp3, QuantidadeRetirar, SomaRetira:realPorcentagem, Largura_Sequencia, Largura_Processada: real//VetoresSequenciaCorte: vetor[1..20] de real//MatrizesPedidosRetirar: vetor[1..3,1..20] de realPedidos: vetor[1..3,1..20] de realClientes: vetor[1..20] de caractereClientesRetirados: vetor[1..20] de caractereimprimir: vetor[1..20] de caractere//Cabeçalhoprocedimento Cabecalho ()inicioescreval("#########################################################################")escreval("#                                                                 #")escreval("#               Faculdade Anhanguera de São Jose dos Campos       #")escreval("#       ATPS Algoritimos e Programção - Professor Eriovaldo Magalhaes   #")escreval("# Turma de Engenharia de Producao #")escreval("#                                                               #")escreval("#########################################################################")fimprocedimento//Funcao para o Cauculo de Bobinasprocedimento EntraPedidos()  inicio  limpatela  Cabecalho()  escreval("")  escreval("==================================================================")  escreval(" Informações 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? (Máximo 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 número: ",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 aprovadoprocedimento 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  fimsefimprocedimento//Funcao Para Recolocar Pedidos Retiradosprocedimento Recoloca()iniciolimpatelaj:= Retiradospara Contagem de 1 ate j facaPedidos[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

fimparaordena_sequencia(">")//Reajusta Valores  Temp:= 0  para j de 1 ate TotalPedidos faca        Temp := Temp + Pedidos[2,j]  fimpara  LarguraTotal := Temp  PesoTotal := (LarguraTotal * (Diametro / 1000)) * Pesofimprocedimento//Imprimir apenas os pedidosprocedimento Pedidos_I()inicio// Seção 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  fimparafimprocedimento//Procedimento para Ordenar o Vetorprocedimento 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  fimescolhafimprocedimento//funcao para aprovacao dos pedidosprocedimento 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("Optimização: ", 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 sequência 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  fimsefimprocedimentoprocedimento 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

  fimparafimprocedimento//Recalculaprocedimento 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  fimsefimprocedimento//Optimização do Corteprocedimento optimiza_corte ()  inicio  limpatela  cabecalho()  Cont:= TotalPedidos //Salva ototal de pedidos para ordenação  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 ()  fimsefimprocedimento//Procedimento Incial – Construção de interface amigavelprocedimento 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("   não 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  fimsefimprocedimentoinicio//Inicio do CodigoInicial()fimalgoritmo

Conclusão: Conclui-se que os operadores são indispensáveis em nossos programas e que a linguagem C possui um número muito grande de operadores. Vimos nesse artigo mais um importante tópico para qualquer linguagem de programação as estruturas de repetição, aprendemos sobre os diversos tipos na linguagem C entre eles: laço for, laço while, laço do.. while e laço 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. São Paulo: Pearson, 2007. p. 106 a 155;

p. 185 a 215) (MIZRAHI, Victorine Viviane. Treinamento em Linguagem C. 1ª ed. São 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