Linguagem de Programação C

(1)

Linguagem de Programação

C

Universidade Federal Rural

de Pernambuco

Departamento de Estatística e Informática

Disciplina : Paradigmas de Programação

Prof.: Gláucya Carreiro Boechat

(2)

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.

(3)

Entrada/Saída Básica

Saída Formatada: printf

F|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 longo L = 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 Ã O d , i In te iro N u m é ric o e m b a s e 1 0 o In te iro N u m é ric o e m b a s e 8 s / s in a l u 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 x a 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 x a A , B , C , D , E , F c c h a r C a ra c te r A S C II s 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 m n 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 m n o ta ç ã o c ie n tífic a

(4)

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);

(5)

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

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

(6)

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

(7)

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

(8)

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.

Exemplo

char ch;

ch = getchar(); /* Digite 123<Enter> */

putchar(ch);

putchar(getchar()); putchar(getchar()); putchar(getchar());

Retorno

getchar() devolve o caracter escrito em caso de sucesso

(9)

Entrada/Saída Básica

Entrada Formatada: scanf

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

(10)

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 campo F|N: Muda o tamanho default dos endereços passados como parâmetros h|l|L: Modificador do tipo default do argumento.

h = int Curto l = long int para type_ch = d

l = double para type_ch = f L = double longo para type_ch = f type_ch: Caracter indicador de tipo de argumento

CARACTER ARGUMENTO CONVERSÃO

d, i int * Decimal inteiro o int * Inteiro Octal

x int * Inteiro Hexadecimal c char * Um único caracter s char * Cadeia de Caracteres [...], [^...] char * Cadeia de Caracteres

e, f float * Número de ponto flutuante em notação decimal ou científica

(11)

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);

(12)

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

(13)

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:

(14)

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)

(15)

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 Geral

if (<expressao>)

<comando-1>

[ else

(16)

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 else

associado

pode-se forçar uma outra forma de associação dos comandos

(17)

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

(18)

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 Geral switch (<expressao>) { case <constante-1>: <comando-1> [ break; ] case <constante-2>: <comando-2> [ break; ] ... [ default: <comando-extra> ] }

(19)

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 cases

diferentes.

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.

(20)

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”); } ...

(21)

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 geral

while (<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.

(22)

Comandos de Controle de Fluxo

Comando

while

Exemplo

...

i = 0;

while (i < 256) {

printf(“%03d - %c\n”, i, i);

++i;

}

(23)

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 geral do

<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

(24)

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’); ...

(25)

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 geral

for (<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

(26)

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 */**

}

(27)

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 geral break;

(28)

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; }

(29)

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 geral break;

(30)

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];

}

(31)

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 geral

goto <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 (:).