Upload
others
View
22
Download
0
Embed Size (px)
Citation preview
Linguagem de Programação
C
Universidade Federal Rural de Pernambuco
Departamento de Estatística e Informática
Disciplina : Paradigmas de ProgramaçãoProf.: Gláucya Carreiro Boechat
Entrada/Saída Básica� Saída Formatada: printf
#include <stdio.h>
int printf(const char *formato[, arg1, ...]);
� formato possui caracteres comuns que são simplesmente copiados para a saída padrão, ou sequências de caracteres especiais, que irão formatar os argumentos passados.
� Sequências de formatação são iniciadas por %, e possuem o seguinte formato geral
%[flags][width][.prec][F|N|h|l|L]type_ch
flags: controla o alinhamento da saída, a colocação de sinais numéricos, o preenchimento com zeros e a adição de prefixos octal ou hexa
width: Número mínimo de caracteres a imprimir (preenchendo com zeros ou brancos)
prec: Para cadeias de caracteres estabelece o máximo de caracteres a imprimir; para numéricos float ou double, indica o número de dígitos após o ponto decimal; para numéricos inteiros ou longos indica o número mínimo de dígitos a serem apresentados, preenchendo com 0’s.
Entrada/Saída Básica
� Saída Formatada: printfF|N|h|l|L: Modificador de tamanho de entrada
Altera o tamanho em bytes do próximo argumento de entrada.
N = Ponteiro Near h = int Curto
F = Ponteiro Far l = int longoL = double longo
type_ch: Caracter indicador de tipo de argumento
C A R A C T E R A R G U M E N T O C O N V E R S Ã Od , i In te iro N u m é ric o e m b a s e 1 0o In te iro N u m é ric o e m b a s e 8 s / s in a lu In te iro N u m é ric o e m b a s e 1 0 s / s in a l
x In te iro N u m é ric o e m b a s e 1 6 s / s in a l,c o m d íg ito s h e xa a , b , c , d , e , f
X In te iro N u m é ric o e m b a s e 1 6 s / s in a l,c o m d íg ito s h e xa A , B , C , D , E , F
c c h a r C a ra c te r A S C IIs c h a r * C a d e ia d e C a ra c te re s
f flo a t o u d o u b le N ú m e ro d e p o n to flu tu a n te e mn o ta ç ã o d e c im a l
e flo a t o u d o u b le N ú m e ro d e p o n to flu tu a n te e mn o ta ç ã o c ie n tíf ic a
Entrada/Saída Básica
� Exemplos� printf(“|%10s|\n”, “string”);
� printf(“|%-10s|\n”, “string”);
� printf(“|%5d|\n”, 100);
� printf(“|%-5d|\n”, 200);
� printf(“|%5.2f|\n”, 3.141592);
� printf(“|%-10.3s|\n”, “string”);
� printf(“|%8d|\n”, 40000);
� printf(“|%8ld|\n”, 40000);
� printf(“|%10.5d|\n”, 102);
� printf(“|%.5d|\n”, 102);
� printf(“|%010d|\n”, 102);
� printf(“|%010.5d|\n”, 102);
� printf(“|%5.2Lf|\n”, 314.1592);
� printf(“|%5.2Le|\n”, 314.1592L);
Entrada/Saída Básica
� Retorno� printf() devolve o número total de bytes impressos em
caso de sucesso ou EOF em caso de falha
� Saída de strings: puts#include <stdio.h>
int puts(const char *s);
� Escreve uma string na saída padrão e salta de linha (envio de caracter new-line: \n).
� Exemplos� puts(“Teste”); puts(“Teste\n”);
� puts(“Teste\n”); puts(“Teste\rSobre”);
� Retorno� puts() devolve um valor positivo em caso de sucesso ou EOF
em caso de falha
Entrada/Saída Básica
� Saída de caracteres: putchar
#include <stdio.h>
int putchar(int c);
� Escreve um caracter na saída padrão.
� Exemplos� putchar(‘a’);
� putchar(‘\b’);
� putchar(‘b’);
� putchar(‘\7’);
� Retorno� putchar() devolve o próprio caracter em caso de
sucesso ou EOF em caso de falha
Entrada/Saída Básica
� Entrada de strings: gets
#include <stdio.h>
char *gets(char *s);
� Recebe uma string da entrada padrão. Caracteres são lidos até que um new-line (ASCII 10) seja lido. Este caracter é substituído por ‘\0’.
� Exemplo� gets(str1);
� printf(“|%s|\n”, str1);
� Retorno� gets() devolve um apontador para s em caso de
sucesso ou NULL em caso de falha
Entrada/Saída Básica
� Entrada de caracteres: getchar#include <stdio.h>
int getchar(void);
� Lê um único caracter da entrada padrão. Aguarda até que seja digitado um new-line.
� Exemplochar ch;
ch = getchar(); /* Digite 123<Enter> */
putchar(ch);
putchar(getchar());
putchar(getchar());
putchar(getchar());
� Retorno� getchar() devolve o caracter escrito em caso de sucesso
ou EOF em caso de fim de arquivo ou de uma falha
Entrada/Saída Básica
� Entrada Formatada: scanf
#include <stdio.h>
int scanf(const char *formato[, end1, ...]);
� formato possui como em printf, sequências de formatação que são iniciadas por %, que vão indicar os campos a serem lidos;
� Caracteres “brancos” (‘ ‘, ‘\t’, ‘\n’) indicarão que todos os caracteres “brancos” na entrada devem ser descartados até que um caracter não “branco” seja encontrado;
� Qualquer outro caracter no formato será combinado e descartado;
� Para cada sequência de formatação deve existir um endereço na lista de argumentos;
Entrada/Saída Básica� Sequências de formatação têm o seguinte formato geral
%[*][width][F|N][h|l|L]type_ch
*: suprime a associação (descarta) o próximo campo do tipo especificado em type_ch
width: Estabelece o número máximo de caracteres lidos para o campoF|N: Muda o tamanho default dos endereços passados como parâmetrosh|l|L: Modificador do tipo default do argumento.
h = int Curto l = long int para type_ch = dl = double para type_ch = f L = double longo para type_ch = f
type_ch: Caracter indicador de tipo de argumento
CARACTER ARGUMENTO CONVERSÃOd, i int * Decimal inteiroo int * Inteiro Octalx int * Inteiro Hexadecimalc char * Um único caracters char * Cadeia de Caracteres[...], [^...] char * Cadeia de Caracteres
e, f float * Número de ponto flutuante emnotação decimal ou científica
Entrada/Saída Básica
� Exemplos� scanf(“%d”, &i);
printf(“%d\n”, i);
� scanf(“%f”, &f1);
ch = getchar();
printf(“f1 = %f\nch = %hd\n”, f1, ch);
� scanf(“%f%*c”, &f1);
ch = getchar();
printf(“f1 = %f\nch = %hd\n”, f1, ch);
� scanf(“%s”, str1);
gets(str2);
printf(“|%s|\n|%s|\n”, str1, str2);
� scanf(“%s ”, str1);
gets(str2);
printf(“|%s|\n|%s|\n”, str1, str2);
Entrada/Saída Básica
� Exemplos� scanf(“%s%d”, str1, &i);
gets(str2);
printf(“str1=%s, i=%d, str2=%s\n”, str1, i, str2);
� scanf(“%[^0-9]%d%*c”, str1, &i);
gets(str2);
printf(“str1=%s, i=%d, str2=%s\n”, str1, i, str2);
� scanf(“%f%*f%f”, &f1, &f2);
printf(“f1=%f, f2=%f\n”, f1, f2);
� scanf(“%f%*d%f”, &f1, &f2);
printf(“f1=%f, f2=%f\n”, f1, f2);
� Retorno� scanf() devolve o número de campos convertidos com
sucesso ou EOF em caso de encontrar um final de arquivo
Entrada/Saída Básica
� Observações� Além destas rotinas estudadas há várias outras
funções de E/S na biblioteca C padrão que serão exploradas quando formos trabalhar com arquivos.
� Embora estas rotinas sejam utilizadas para ler da entrada e escrever na saída padrão, é possível utilizá-las para tratar arquivos, desde que se faça o redirecio-namento da entrada ou saída padrão para o arquivo desejado:
C:\> exemplo < arqent.txt > arqsai.txt
Comandos de Controle de Fluxo
� Comandos� Um comando em C é formado de três maneiras:
� Uma expressão seguida de um ponto e vírgula (;)x = 0;printf(“Alô mundo”);++i;
� Um bloco de comandos delimitados por { e }.{
x = 0;printf(“Alô mundo”);++i;
}� Um comando de controle de fluxo
if (nota >= 7.0)printf(“Aluno aprovado por média\n”);
Comandos de Controle de Fluxo
� Comando if - else� É usado para tomar decisões� Seleciona a execução de um comando se uma expressão
lógica for avaliada como VERDADEIRA (Diferente de Zero)� Opcionalmente (quando se utilizar o else) é executado um
outro comando quando a expressão for avaliada como FALSA (Valor Zero).
� Sintaxe Geralif (<expressao>)
<comando-1>
[ else
<comando-2> ]
Comandos de Controle de Fluxo
� Exemplo
if (nota >= 7.0 && faltas < 60)printf(“Aluno aprovado por média\n”);
else {printf(“Aluno não foi aprovado por média\n”);printf(“Vai passar parte das férias estudando!\n”);
}� Quando se aninham comandos if, o else é sempre associado ao
if mais recente (mais próximo) que ainda não tem nenhum elseassociado
� pode-se forçar uma outra forma de associação dos comandos usando-se os delimitadores de blocos { e }.
Comandos de Controle de Fluxo
� Para esclarecer veja o seguinte exemplo:if (n > 0)
for (i = 0; i < n; ++i)if (s[i] == ‘\0’) {
printf(“%s tem tamanho menor que %d\n”, s, n);
return}
else /* Erro dificil de ver */printf(“Valor de n é inválido\n”);
� Neste exemplo há um erro, pois o else está associado ao segundo if, apesar da indentação sugerir o contrário.
� Corrige-se adicionando os delimitadores de bloco { e } em torno dos comandos do primeiro if.
Comandos de Controle de Fluxo
� Comando switch� Verifica se uma dada expressão corresponde a um dos valores
especificados. Permite tomar múltiplas decisões a partir da avaliação de uma expressão.
� Sintaxe Geralswitch (<expressao>) {
case <constante-1>:
<comando-1>
[ break; ]
case <constante-2>:
<comando-2>
[ break; ]
...
[ default: <comando-extra> ]
}
Comandos de Controle de Fluxo
� Observações� Constantes que aparecem junto com a palavra reservada
case podem ser caracteres, inteiros, longos ou uma expressão de constantes, mas nunca poderão ser usadas variáveis ou referências a funções.
� Estas constantes não poderão se repetir em casesdiferentes.
� Execução começa no primeiro case com valor igual ao da expressão, e continua pelos cases seguintes atéencontrar o final do switch ou um comando de escape (break).
� O rótulo default é opcional e é executado quando nenhum dos cases corresponde ao valor da expressão.
Comandos de Controle de Fluxo
� Exemplo...
opcao = getche();switch (opcao) {
case ‘1’:incluir();break;
case ‘2’:alterar();break;
case ‘3’:excluir();break;
default:puts(“opção inválida”);
}...
Comandos de Controle de Fluxo
� Comando while� Executa um comando, ou um bloco destes, enquanto uma
expressão (condição) lógica for avaliada como VERDADEIRA.
� Sintaxe geralwhile (<expressao>)
<comando>
� O while é um comando de repetição (loop) com teste “antes” (em cima)
� Expressão lógica é avaliada antes da execução do comando associado, de tal forma que se a expressão for avaliada for avaliada como FALSA na primeira vez, o comando não será executado nenhuma vez.
Comandos de Controle de Fluxo
� Comando while
�Exemplo
...
i = 0;
while (i < 256) {
printf(“%03d - %c\n”, i, i);
++i;
}
Comandos de Controle de Fluxo
� Comando do-while� Executa um comando, ou um bloco destes, e em seguida
avalia uma expressão. Caso a mesma seja avaliada como VERDADEIRA os comandos são repetidos.
� Sintaxe geraldo
<comando>
while (<expressao>);
� O do-while é um comando de repetição (loop) com teste “depois” (em baixo), ou seja, a expressão lógica é avaliada após a execução do comando associado
� O comando será executado ao menos uma vez
Comandos de Controle de Fluxo
� Exemplo...
do {clrscr();puts(“Menu Principal\n\n”);puts(“1 - Incluir”);
...puts(“4 - Sair”);do
opcao = getche();while (opcao < ‘1’ || opcao > ‘5’);switch (opcao) {
case ‘1’:incluir();break;...
}} while (opcao != ‘4’);
...
Comandos de Controle de Fluxo
� Comando for� Possui semelhanças com a forma do comando for de
outras linguagens, mas é bem mais genérico e versátil� Sintaxe geralfor (<inicializações>; <exp. lógica>; <incrementos>)
<comando>
onde:<inicializações> - expressão que será executada antes do comando associado.
<exp. lógica> - teste lógico que será executado antes da execução dos comandos associados. Caso seja avaliada como VERDADEIRA, os comandos serão executados, caso contrário o loop encerrará.<incrementos> - expressão que será executada após cada iteração
Comandos de Controle de Fluxo
� Exemplo...
for (i = 0; i < 256; ++i) {printf(“%03d - %c\n”, i, i);
}� Qualquer das 3 partes do for pode ser omitida, no
entanto os ponto e vírgula (;) devem permanecer. � No caso da <exp. lógica> ser omitida, a
avaliação será sempre VERDADEIRA. Desta forma, o exemplo abaixo criará um laço infinito:
...for (;;) {
/* Loop infinito */}
Comandos de Controle de Fluxo
� Comando break� Interrompe a execução de um loop independentemente da
expressão lógica que controla o mesmo� Quando usado em um switch interrompe a sequência de
execução do mesmo, fazendo com que todos os case’s posteriores ao break sejam descartados
� O comando break permite a saída antecipada de um for, while, do-while ou switch.
� Toda vez que um comando break é encontrado, o loop (ou switch) mais interno é interrompido.
� Sintaxe geralbreak;
Comandos de Controle de Fluxo
� Exemplo...
clrscr();for (nl = 0, i = 0; i < 256; ++i) {
printf(“%03d - %c\n”, i, i);if (++nl > 23) {
printf(“<Esc> aborta. Qualquer tecla continua ...”);if (getch() == 27) break;clrscr();nl = 0;
}}
Comandos de Controle de Fluxo
� Comando continue� Desvia o fluxo de execução de um loop para a próxima
iteração do mesmo� Ao contrário do break, o continue se aplica somente aos
loops, e não ao switch. � O comando continue num switch dentro de um loop,
provoca a próxima iteração do loop
� Quando o loop é um while ou um do-while, a expressão lógica será imediatamente executada. Quando o loop é um for, no entanto a expressão de incremento será executada primeiro, seguida então da expressão lógica.
� Sintaxe geralbreak;
Comandos de Controle de Fluxo
� Exemplo...
for (i = 0; i < 10; ++i) {
if (array[i] == 0)
continue; /* Salta elementos iguais a zero */
/* Trata elementos diferentes de zero */
soma += 1/array[i];
}...
Comandos de Controle de Fluxo
� Comando goto� Desvia, incondicionalmente, o fluxo de execução para um
bloco de comandos iniciados por um rótulo (label)� Sintaxe geralgoto <rótulo>;
� As regras de formação para o nome do rótulo são as mesmas para a formação do nome de identificadores em C. No ponto de início do bloco de comandos, o rótulo tem seu nome acrescido de dois pontos (:).
� Uso indiscriminado deve ser evitado, pois em geral dificulta o entendimento da lógica do programa
� Só quando se tem um aninhamento de vários loops e se deseja encerrar todos eles, o goto deve ser utilizado.
Comandos de Controle de Fluxo
� Exemplo...
for (...) {for (...) {
...if (houve erro)
goto ERRO;}
}ERRO:/* arruma a casa */
...