Comandos em Linguagem C Prof Omero Francisco Bertol
Comandos em Linguagem C Prof. Omero Francisco Bertol http: //www. pb. utfpr. edu. br/omero/
Codificação Sentenças, Instruções, Comandos Ações, o que é executado
Definições básicas (1/2) • dispositivo de entrada (usuário computador) – meio pelo qual as informações são transferidas pelo usuário ou pelos níveis secundários de memória ao computador – teclado, discos magnéticos, fitas, cartão perfurado • dispositivo de saída (computador usuário) – meio pelo qual as informações são transferidas pelo computador ao usuário ou aos níveis secundários de memória – monitor de vídeo, impressora, fitas, discos magnéticos
Definições básicas (2/2) • sintaxe (escrita do comando) – forma como os comandos devem ser escritos, a fim de que possam ser entendidos pelo tradutor (compilador, interpretador) de programas. – a violação das regras sintáticas é considerada um erro sujeito à pena do não-reconhecimento do comando por parte do tradutor. • semântica (lógica do comando) – significado, conjunto de ações que serão exercidas pelo computador durante a execução do referido comando.
Interface com o usuário output Usuário scanf (teclado) Interface Meio pelo qual um programa e o usuário “conversam”. printf (vídeo) Programa input
Estrutura mínima de um programa escrito em “Linguagem C”: void main() { *** } ponto inicial da execução de um programa escrito em Linguagem C
#include • A diretiva #include instrui o compilador a ler (ou incluir) outro arquivo-fonte àquele que contém a diretiva #include. • O nome do arquivo adicional deve estar entre aspas ou símbolos de maior e menor. #include “stdio. h” #include <stdio. h> • stdio. h: • conio. h: • stdlib. h: scanf, printf clrscr, gotoxy, getche random, randomize
Comentários • o compilador ignora qualquer texto entre os símbolos de comentário • os comentários podem ser colocados em qualquer lugar em um programa desde que não apareçam no meio de uma palavra-chave ou identificador O comentário de uma linha utiliza duas barras (//) para marcar seu início: // comentário de uma linha a partir do ínicio da linha int x = 0; // comentário de um linha após um comando // tudo após as duas barras é considerado // comentário O segundo tipo utiliza a combinação /* e */ para delimitar uma ou mais linhas, cujo conteúdo deverá ser considerado como um comentário /* (início) comentário de múltiplas linhas (fim) */
Definições: Comandos e Blocos (1/2) Formalmente, as “instruções”, ou comandos de um programa são chamadas diretivas (statements). Nas linguagens C/C++, tal como nas linguagens Java e Pascal, os comandos são separados uns dos outros pelo símbolo de pontuação “; ” (ponto-e-vírgula), sendo possível existir vários comandos em uma mesma linha, desde que separadas por um ponto-e-vírgula. comando 1; comando 2; … comando. N; comando 1; comando 2; comando 3; … comando. N;
Definições: Comandos e Blocos (2/2) Os comandos podem ser tratados individualmente ou como um conjunto, que é denominado bloco. Um bloco em C ou Java é um grupo de comandos delimitados por chaves: { comandos }. { comando 1; comando 2; comando 3; … comando. N; } Assim, as estruturas de controle podem tanto operar sobre um comando individual como sobre um bloco de comandos. Outra consequência da criação de blocos é que as estruturas de controle podem ser aninhadas de forma coletiva, isto é, dentro de um bloco podem existir várias estruturas de controle contendo, por sua vez, seus próprios blocos de comandos.
Comandos (instruções) • Simples (atômicas) – atribuição, controle de desvios, comandos de entrada / saída • Compostos (estruturados) – sequencial (ou composição) – condição: if – seleção: switch – repetição: for, while e do while
Comando de Atribuição nome. Da. Variável = expressão; Onde: • nome. Da. Variável – endereço de memória • expressão – valor atribuído (ou armazenado) a variável
Exemplos de expressões (1/3): Tendo as seguintes variáveis: int n, result; float nota 1, nota 2, media, raizq; // quadrado de n result = n * n; ou #include "math. h" result = pow(n, 2); // raiz quadrada de n #include "math. h" raizq = sqrt(n); // média aritmética simples de duas notas media = (nota 1 + nota 2) / 2;
Exemplos de expressões (2/3): Tendo as seguintes variáveis: float vlr, novovlr, salario, novosalario; // 90% do valor novovlr = vlr * (90 / 100. 0); // reajustar o salário em 10% novosalario = salario + (salario * (10 / 100. 0)); // desconto de 10% no valor novovlr = vlr - (vlr * (10 / 100. 0));
Exemplos de expressões (3/3): Tendo as seguintes variáveis: int n, digito, novon, a, b, aux; // retornando o último dígito do número digito = n % 10; // retirando o último dígito do número novon = n / 10; // fazendo a troca (swap) de dois valores aux = a; a = b; b = aux;
Tipos de variáveis mais frequentes • Contadores int i = 0; i = i + 1; ou i++; ou ++i; int j = 1; j = j + 2; • Somatórios, ou acumuladores int s = 0, idade; for (int i=1; i<=10, i++) { prinf("Informe a %da. Idade: ", i); scanf("%d", idade); s = s + idade; } • Produtórios. Fatorial de 4 = 1 * 2 * 3 * 4 int p = 1; for (int i=1; i<=4; i++) p = p * i;
Controles de desvios • objetivo = desviar a sequência natural do código fonte dos programas • goto: • break: vá para, desvio incondicional quebra instruções repetitivas (for, while e do while) • continue: interrompe apenas a interação corrente da instrução repetitiva (for, while e do while) • exit(0): termina a execução de um programa
Limpar a tela: clrscr • clear screen, limpa a tela e posiciona o cursor no canto superior esquerdo (1, 1) • prepara o vídeo para iniciar um processo de entrada ou saída de dados • procedimento disponível no arquivo de cabeçalhos “conio. h” #include "conio. h" void main() { clrscr(); . . . }
Posicionar o cursor: gotoxy • este procedimento, disponível no arquivo de cabeçalhos “conio. h”, permite posicionar o cursor em um determinado ponto da tela gotoxy(coluna, linha); onde: • coluna, valor numérico inteiro positivo entre 1 e 80 • linha, valor numérico inteiro positivo entre 1 e 24
gotoxy(01, gotoxy(80, (01, 01); 24); canto superior inferior x 1 esquerd direito (80, 01) 80 Terminal de Vídeo y (tela do computador) 24 (01, 24) 24 (80, 24)
Comando de entrada: scanf input • permite ao usuário do programa fornecer valores de entrada ao computador Comando de saída: printf output • permite ao computador exibir os resultados, determinados pelo programa, ao usuário obs. os protótipos de scanf() e printf() estão disponíveis no arquivo de cabeçalhos “stdio. h”
Entendendo o Código (1/2) scanf("%d", &n); onde: scanf %d & n comando de entrada (input) indica qual deve ser o formato do valor de entrada indica o endereço de memória de … nome da variável, ou seja, endereço de memória semântica de funcionamento: interrompe a execução do programa e através do dispositivo de entrada (teclado) o usuário deverá fornecer um número inteiro que será armazenado no endereço de memória correspondente a variável “n”.
Entendendo o Código (2/2) printf("n%2 d * %d = %3 d. ", i, n, (i*n)); onde: printf n %d comando de saída (output) código de barra invertida nova linha (LF- line feed) indica qual será o formato de exibição do valor semântica de funcionamento: exibe no dispositivo de saída padrão (terminal de vídeo) três valores: 1) o valor inteiro decimal da variável “i” usando duas posições do vídeo 2) o valor inteiro decimal da variável “n” 3) o resultado da expressão “i*n” usando três posições do vídeo atenção: deve haver o mesmo número de argumentos e de comandos (%) de formato
Especificadores de formato Os especificadores de formato são precedidos por um sinal % e informam que “tipo de dado” deve ser lido ou exibido. Código Significado %c lê ou exibe um caractere %s lê ou exibe uma string “sem” espaços em branco %d lê ou exibe um inteiro decimal %ld lê ou exibe um inteiro decimal longo %i lê ou exibe um inteiro decimal %f lê ou exibe um nro em ponto flutuante %lf lê ou exibe um nro do tipo double %o lê ou exibe um número octal %x lê ou exibe um número hexadecimal %% exibe o símbolo %
Para justificar (ou alinhar) o resultado à direita no comando de saída (printf): %3 d 1 2. . . 9 10 11. . . 99 100 101. . . 999 %6. 2 f 1. 00 2. 00. . . 9. 00 10. 00 11. 00. . . 99. 00 100. 00 101. 00. . . 999. 99 %15 s Brasil Pato Branco Curitiba UTFPR Mater Dei Programar é Bom
Códigos de barra invertida Funcionam para a maioria dos caracteres imprimíveis. É uma forma de facilitar o uso desses caracteres especiais (ou de controle) como constantes. Código r f a Significado retorno do carro (CR- carriage return) alimentação de formulário (FF- form feed) alerta (beep) n t " ' \ nova linha (LF- line feed) tabulação horizontal aspas duplas aspas simples nulo barra invertida
Interface amigável • programa “amigo do usuário” • regras básicas: – toda vez que um programa estiver esperando que o usuário forneça a ele um determinado dado (operação de leitura), ele deve enviar uma mensagem dizendo ao usuário o que ele deve digitar, por meio de uma instrução de saída de dados (printf); – antes de enviar qualquer resultado ao usuário, um programa deve escrever uma mensagem explicando o significado do mesmo.
Interrupções (paradas) Meios para interromper o fluxo normal de execução do programa e aguardar uma intervenção do usuário: • getch(); – é necessário pressionar qualquer tecla (ou caractere) para prosseguir sendo que ela não será “ecoada” na tela • getche(); – é necessário pressionar qualquer tecla (ou caractere) para prosseguir sendo que ela será “ecoada” na tela
Estruturas de Controle Um programa de computador é uma sequência de instruções organizadas de forma a produzir a solução de um determinado problema; o que representa uma das habilidades básicas da programação, que é a sequenciação. Naturalmente, as instruções de um programa são executadas em sequência, o que se denomina fluxo sequencial de execução. Mas, em inúmeras circunstâncias, é necessário executar as instruções de um programa em uma ordem diferente da estritamente sequencial. Tais situações são caracterizadas pela necessidade da repetição de instruções individuais ou conjuntos de instruções, e também pelo desvio do fluxo de execução, tarefas que podem ser realizadas por meio das “estruturas de controle” da linguagem.
Tipos de Estruturas de Controle fluxo sequencial de execução os comandos são executados um após o outro sequencialmente do início ({) até o final (}) fluxo repetitivo de execução os comandos são executados, de forma repetida, um determinado número de vezes: for, while e do while. fluxo de execução com desvio os comandos são executados dependendo do valor de uma condição, ou expressão lógica: if e switch.
Operadores Relacionais (1/2) relação (ou comparação) de valores: == igual a != diferente de > maior que < menor que >= maior igual a <= menor igual a
Operadores Relacionais (2/2) Variáveis: int a = 2; int b = 3; Expressões lógicas (testes lógicos) a == b a != b a > b a < b a >= b a <= b resultado falso verdadeiro
Operadores lógicos (ou booleanos) ! && || negação lógica “e” lógico “ou” lógico conjunção disjunção
Estruturas de Desvio de Fluxo (1/3) O if é um comando de desvio “condicional” simples do fluxo de execução, isto é, capaz de selecionar um entre dois caminhos distintos para execução, dependendo do resultado, falso ou verdadeiro, resultante da expressão lógica associada. if (expressão lógica, ou codição) comando 1; Esta primeira forma (simples) de desvio de fluxo permite executar ou não um certo comando, conforme o resultado de uma condição. falso condição verdadeiro comando 1
Exemplificando as Relações (1/3) #include <stdio. h> void main() { int n; printf("Informe um número inteiro: n"); scanf("%d", &n); printf("n"); if (n == 5) printf("%d é igual a 5", n); } Representação matemática: 5 n = 5 Representação computacional: if (n == 5) printf("%d é igual a 5", n);
Exemplificando as Relações (2/3) Representação matemática: 5 5 5 Representação computacional: n = 5 if (n == 5) printf("%d é igual a 5", n); n < 5 if (n < 5) printf("%d é menor que 5", n ); n ≤ 5 if (n <= 5) printf("%d é menor ou igual a 5", n); n > 5 if (n > 5) printf("%d é maior que 5", n); n ≥ 5 if (n >= 5) printf("%d é maior ou igual a 5", n);
Exemplificando as Relações (3/3) Representação matemática: 5 Representação computacional: if (n != 5) n # 5 printf("%d é diferente de 5", n); 5 9 if ((n == 5) || (n == 9)) n = 5, ou n = 9 printf("%d é igual a 5" " ou é igual a 9", n); 5 9 if ((n < 5) || (n > 9)) n < 5, ou n > 9 printf("%d está fora do intervalo" " entre 5 e 9. ", n); 5 9 if ((n != 5) && (n != 9)) n # 5, e n # 9 printf("%d é diferente de 5" " e diferente de 9", n); n ≥ 5, e n ≤ 9 if ((n >= 5) && (n <= 9)) printf("%d pertence ao intervalo" " de 5 até 9. ", n);
// // // Efetuar a leitura de um valor inteiro positivo ou negativo e apresentar o número lido como sendo um valor positivo, ou seja, o programa deverá apresentar o módulo de um número fornecido. Lembre-se de verificar se o número fornecido é menor que zero, sendo multiplique-o por – 1. #include "stdio. h" void main() { int numero; printf("Informe um nro inteiro: "); scanf("%d", &numero); falso numero < 0 verdadeiro numero = numero * (-1); if (numero < 0) numero = numero * (-1); printf("n. O módulo do nro informado eh = %d", numero); }
#include "stdio. h" void main() { int a, b; falso (a < b) verdadeiro printf("Informe o valor da variavel 'a': n"); scanf("%d", &a); printf("a < b"); printf("Informe o valor da variavel 'b': n"); scanf("%d", &b); falso if (a < b) printf("n%d eh menor do que %d", a, b); if (a == b) printf("n%d eh igual a %d", a, b); if (a > b) printf("n%d eh maior do que %d", a, b); (a == b) verdadeiro printf("a == b"); falso (a > b) verdadeiro } printf("a > b");
Estruturas de Desvio de Fluxo (2/3) Esta segunda forma (composta) de desvio de fluxo permite que seja executado o comando 1, caso o resultado da expressão lógica for verdadeiro e no caso do resultado da expressão lógica for “falso” o “comando 2” e que será executado. if (expressão lógica) comando 1; else comando 2; falso comando 2 condição verdadeiro comando 1
// Ler dois valores numéricos e apresentar a diferença // do maior pelo menor. #include "stdio. h" void main() { int a, b, dif; printf("Informe o primeiro valor: "); scanf("%d", &a); printf("Informe o segundo valor. : "); scanf("%d", &b); falso if (a > b) dif = a - b; else dif = b - a; a > b dif = b – a; printf("n. A diferença do maior pelo menor eh: %d", dif); } verdadeiro dif = a – b;
#include "stdio. h" void main() { int a, b; printf("Informe o valor da variavel 'a': n" ); scanf("%d", &a); printf("Informe o valor da variavel 'b': n" ); scanf("%d", &b); if (a > b) printf("n%d eh maior do que %d" , a, b); else if (a == b) printf("n%d eh igual a %d", a, b); else printf("n%d eh menor do que %d" , a, b); falso } falso printf("a < b"); (a == b) (a > b) verdadeiro printf("a > b"); printf("a == b");
Definir o maior entre 2 (dois) números: 2 n-1 = 22 -1 = 2 caminhos na árvore de decisão. Árvore de decisão: Representação computacional: a>b V a if (a > b) printf("O maior valor é %d", a); else printf("O maior valor é %d", b); F b
Definir o maior entre 3 (três) números: 2 n-1 = 23 -1 = 22 = 4 caminhos na árvore de decisão. Árvore de decisão: Representação computacional: a>b V F a>c V a b>c F c if (a > b) V b F c if (a > c) printf("O maior valor é %d", a); else printf("O maior valor é %d", c); else if (b > c) printf("O maior valor é %d", b); else printf("O maior valor é %d", c);
Definir o maior entre 4 (quatro) números: 2 n-1 = 24 -1 = 23 = 8 caminhos na árvore de decisão. Representação computacional: Árvore de decisão: if (a > b) a>b V a>c V b>c F V a>d c>d b>d V V V a F d c if (a > c) if (a > d) printf("O maior valor é %d", a); else printf("O maior valor é %d", d); F F d b F d F c>d V c F d else if (c > d) printf("O maior valor é %d", c); else printf("O maior valor é %d", d); else if (b > c) if (b > d) printf("O maior valor é %d", b); else printf("O maior valor é %d", d); else if (c > d) printf("O maior valor é %d", c); else printf("O maior valor é %d", d);
Outras Relações Impontantes (1/3) #include <stdio. h> void main() { int n; printf("Informe um número inteiro: n"); scanf("%d", &n); printf("n"); if ((n % 2) == 0) printf("%d é um número par. ", n); else printf("%d é um número ímpar. ", n); }
Outras Relações Impontantes (2/3) #include <stdio. h> void main() { int n; printf("Informe um número inteiro: n"); scanf("%d", &n); printf("n"); if ((n % 5) == 0) printf("%d é um nro múltiplo de 5. ", n); else printf("%d não é múltiplo de 5. ", n); }
Outras Relações Impontantes (3/3) #include <stdio. h> void main() { int n; printf("Informe um número inteiro: n"); scanf("%d", &n); printf("n"); if (((n % 2) == 0) && ((n % 3) == 0)) printf("%d é múltiplo de 2 e 3. ", n); else printf("%d não é múltiplo de 2 e 3. ", n); }
Uso “Aninhado” de if else (1/2) if (condição 1) if (condição 2) comando 1; else comando 2; Neste caso o comando 1 é executado quando a condição 1 e a condição 2 forem verdadeiras, e o “comando 2” é executado quando a “condição 1 for verdadeira e a condição 2 for falsa”. Isso porque a regra básica é que uma cláusula else sempre pertence ao comando if imediatamente anterior. O uso de chaves permite modificar esta regra. if (condição 1) { if (condição 2) comando 1; } else comando 2; Agora o comando 1 continua sendo executado quando a condição 1 e a condição 2 forem verdadeiras, entretanto, o “comando 2” é executado, simplesmentes, quando a “condição 1 for falsa”.
Uso “Aninhado” de if else (2/2) if (condição 1) if (condição 2) comando 1; else comando 2; falso verdadeiro falso Comando 1 Condição 1 e 2 - Verdadeiro Comando 2 Condição 1 - Verdadeiro Condição 2 - Falso if (condição 1) { if (condição 2) comando 1; } else comando 2; Comando 1 Condição 1 e 2 - Verdadeiro Comando 2 Condição 1 - Falso condição 1 condição 2 comando 2 falso comando 2 condição 1 falso verdadeiro comando 1 verdadeiro condição 2 verdadeiro comando 1
Aninhamentos (ou Embutimentos) Um aninhamento é o fato de se ter qualquer um dos tipos de construção de comandos dentro de em conjunto de comandos compostos (if, switch, for, while e do while). Regra: A construção mais interna deve estar inteiramente contida na construção imediatamente mais externa. Válido Inválido
Estruturas de Desvio de Fluxo (3/3) O switch é um comando de desvio “múltiplo” de fluxo, isto é, com base na avaliação de uma expressão ordinal é escolhido um caminho de execução “dentre muitos”. switch (expressão ordinal) { case ordinal 1: comando 1; break; case ordinal 2: comando 2; break; . . . default: comando. Default; } expressão ordinal Caso 1 comando 1 break; Caso 2 comando 2 break; default . . . comando. Default
Semântica do Comando switch O corpo do comando switch tem um ou mais casos (cláusulas case) rotulados por valores ordinais. Conforme o resultado da avaliação da expressão ordinal associada ao switch, é selecionado o caso correspondente, se existir. Se um caso for selecionado, serão executados os comandos encontrados a partir deste até o final do corpo do switch (mesmo que isso signifique “invadir” outros casos) ou até a primeiro comando break encontrada, que encerra o switch. Pode ser adicionado um caso especial, identificado pela cláusula default, cujos comandos são executados se nenhum caso for selecionado por meio do resultado da avaliação da expressão ordinal. A cláusula default e seus comandos sempre são posicionados no final do corpo do comando switch. char opcao = getche(); // obtém um valor para a variável opcao. switch (opcao) { case 'a': case 'A': printf("Alteração"); break; case 'i': case 'I': printf("Inclusão"); break; case 'e': case 'E': printf("Exclusão"); break; default: printf("Opção inválida !"); }
// Conta e exibe a quantidade de vogais existentes em uma cadeia de caracteres (string). #include "stdio. h" #include "string. h" void main() { char msg[80]; printf("Informe uma cadeia de caracteres (string): n" ); gets(msg); int ct. A, ct. E, ct. I, ct. O, ct. U; ct. A = ct. E = ct. I = ct. O = ct. U = 0; for (int i=0; i<=(strlen(msg)-1); i++) { switch (msg[i]) { case 'a': case 'A': ct. A++; break; case 'e': case 'E': ct. E++; break; case 'i': case 'I': ct. I++; break; case 'o': case 'O': ct. O++; break; case 'u': case 'U': ct. U++; } msg[i] 'a' ou 'A' msg[i] F V ct. A++; break; } %d %d %d vogais vogais A. n" , E. n" , I. n" , O. n" , U. n" , ct. A); ct. E); ct. I); ct. O); ct. U); F 'i' ou 'I' V ct. E++; break; } printf("Existem printf("Existem 'e' ou 'E' msg[i] F 'o' ou 'O' V ct. I++; break; msg[i] F 'u' ou 'U' V ct. O++; break; V ct. U++; break; F
Estruturas de Repetição Simples A repetição é uma das tarefas mais comuns da programação, sendo utilizada para realizar contagens, totalizações, a obtenção de múltiplos dados, impressão etc. A repetição simples é a execução consecutiva de um comando ou bloco de um número conhecido e fixo de vezes, o que muitas vezes se denomina laço automático. Cada repetição efetuada é o que se chama “iteração”. for ([inic]; [cond]; [incr/decr]) { comando(s); } Inicialização da variável de controle Falso Condição Execução Verdadeiro Comando(s) Incremento/Decremento da variável de controle
Sintaxe e Semântica do Comando for O for tem três seções distintas de controle, todas opcionais, delimitadas por um par de parênteses, nos quais cada seção é separada de outra por um ponto-evírgula. Após as seções de controle, é declarado o comando ou o bloco de comandos que será repetido. A primeira seção é utilizada para declarar e inicializar uma “variável de controle” (geralmente, um contador de repetições). A segunda seção determina a condição de execução do comando associado ao for e, geralmente, é uma expressão lógica que utiliza a variável de controle e outros valores. A última seção determina como a variável de controle será modificada a cada iteração. O for funciona como ilustrado no slide anterior, ou seja, após a execução da seção de inicialização, ocorre a avaliação da expressão lógica. Se a mesma for avaliada como verdadeira, o comando associado será executado uma vez (uma iteração); caso contrário, o comando for é encerrado e a execução do programa prossegue com o próximo comando após o for. A cada iteração, executa-se uma vez a seção de incremento ou decremento, que usualmente modifica o valor da variável de controle, e novamente é feita a verificação da condição para determinar se uma nova iteração, ou passo, deverá ser realizada ou não.
// Apresenta a tabuada de um número inteiro qualquer. #include "stdio. h" void main() { int n; int i=1; printf("Forneça. . . : "); scanf("%d", &n); for (int i=1; i<=10; i++) { printf("n%2 d * %d = %3 d. ", i, n, (i*n)); } Falso } i<=10; Verdadeiro printf(…); 1ª seção = a variável de controle "i" é inicializada com 1 int i=1; i<=10; i++) 2ª seção = determina o valor final para a variável de controle "i" (int i=1; i<=10; i++) 3ª seção = determina que o incremento na variável de controle "i" será realizado de um em um a cada iteração (int i=1; i<=10; i++) Em síntese: a variável de controle inicia com o valor 1 vai até 10 (inclusive) de um em um, ou seja, executando 10 vezes o comando: printf("n%2 d * %d = %3 d. ", i, n, (i*n)); i++
Contadores- quantificar coisas: Qtde de funcionários do sexo masculino Qtde de alunos aprovados Variavel. Contador = Variavel. Contador + 1; Variavel. Contador++; ou #include "stdio. h" void main() { int i, num, ct = 0; // inicializa o contador for (i=1; i<=10; i++) { printf("Informe o %2 do. número: ", i); scanf("%d", &num); // verifica "se" o i-ésimo valor informado é menor que 10 if (num < 10) ct = ct + 1; } // exibe o resultado printf("n. Foram informados %d valores menores que 10. ", ct); }
Somatórios- somar coisas: Soma dos salários dos funcionários do sexo masculino Qtde de peças em estoque Variavel. Somatorio = Variavel. Somatorio + Valor. ASer. Somado; ou Variavel. Somatorio += Valor. ASer. Somado; #include "stdio. h" void main() { int i, num, sm = 0; // inicializa o somatório for (i=1; i<=10; i++) { printf("Informe o %2 do. número: ", i); scanf("%d", &num); // verifica "se" o i-ésimo valor informado é par if ((num % 2) == 0) sm = sm + num; } // exibe o resultado printf("n. Soma dos pares = %d. ", sm); }
Médias- calcular médias: Salário médio dos funcionários do sexo masculino Idade média dos alunos da disciplina de algoritmos Média = Soma / Quantidade de valores; #include "stdio. h" void main() { int i, num, ct = 0, sm = 0; // declara e inicializa as variáveis float media = 0; for (i=1; i<=10; i++) { printf("Informe o %2 do. número: ", i); scanf("%d", &num); if ((num % sm = sm ct = ct media = } 2) == 0) { + num; + 1; float(sm) / ct; // soma os pares // conta os pares // calcula a média dos nros pares } // exibe os resultados printf("n. Soma dos pares = %5 d", sm); printf("n. Qtd. de pares = %5 d", ct); printf("n. Média dos pares = %8. 2 f", media); }
Percentuais- calcular valores percentuais: % de funcionários do sexo masculino % de números pares Percentual = Valor Parcial / Valor Total * 100; #include "stdio. h" void main() { float p = 0; // declara e inicializa as variáveis int i, num, ct = 0; for (i=1; i<=10; i++) { printf("Informe o %2 do. número: ", i); scanf("%d", &num); // verifica "se" o i-ésimo valor informado é par if ((num % 2) == 0) { ct = ct + 1; // conta os pares p = float(ct) / 10 * 100; // calcula o percentual de nros pares } } // exibe o resultado printf("n. Qtd. de pares = %d, ou seja, %. 2 f%%", ct, p); }
Estruturas de Repetição Condicionais (1/2) As estruturas de repetição condicionais são os comandos cujo controle da repetição de execução é feito por meio da avaliação de uma expressão lógica associada ao comando, sendo então chamados de laços condicionais. Essas estruturas são adequadas para permitir a execução repetida de um ou mais comandos por um número indeterminado de vezes, isto é, um número que não é conhecido durante a programação, mas que se torna conhecido durante a execução do programa, tal como um valor fornecido pelo usuário, obtido de um arquivo, ou ainda de cálculos realizados com outros dados. Na linguagem C, tais estruturas são o while e do while (condição) comando(s); Condição Execução Falso Verdadeiro Comando(s)
// Apresenta a tabuada de um número inteiro qualquer. #include "stdio. h" void main() { int n; printf("Informe um número para a tabuada: "); scanf("%d", &n); int i = 1; while (i <= 10) { printf("n%2 d * %d = %3 d. ", i, n, (i*n)); i++; } } int i = 1; (i <= 10) Falso Verdadeiro printf(…); i++ // // no comando while, um conjunto de instruções é repetido, enquanto o resultado de uma expressão lógica (a condição) é avaliado como verdadeiro. É importante observar que o while avalia o resultado da expressão lógica antes (a priori) de executar o comando associado; assim, é possível que este comando nunca seja executado, caso a condição seja inicialmente falsa.
Estruturas de Repetição Condicionais (2/2) O comando do while é outro laço condicional, no qual um conjunto de instruções também é repetido, enquanto o resultado da condição é avaliado como verdadeiro, mas, diferentemente do while, o comando associado é executado “uma primeira vez antes” da avaliação da expressão lógica e da eventual continuação da repetição. do { diretiva(s); } while (condição); Comando(s) Condição Execução Falso Verdadeiro
// Apresenta a tabuada de um número inteiro qualquer. #include "stdio. h" void main() { int n; int i = 1; printf("Informe um número para a tabuada: "); scanf("%d", &n); int i = 1; do { printf("n%2 d * %d = %3 d. ", i, n, (i*n)); i++; } while (i <= 10); printf(…); i++ } (i <= 10) Verdadeiro Falso no comando do while, um conjunto de instruções é repetido, enquanto o resultado de uma expressão lógica (a condição) é avaliado como verdadeiro. É importante observar que o do while avalia o resultado da expressão lógica depois (a posteriori) de executar o comando associado; assim, é garantido que este comando será executado pelo menos uma vez.
for, while e do while #include "stdio. h" void main() { int i; printf("Usando o comando "for"n"); for (i=1; i<=5; i++) { printf("%dn", i); } printf("n. Usando o comando "while"n"); i=1; while (i<=5) { printf("%dn", i); i++; } printf("n. Usando o comando "do while"n"); i=1; do { printf("%dn", i); i++; } while (i<=5); }
- Slides: 67