1) O documento discute streams, que são sequências de bytes que fluem de dispositivos de entrada para a memória principal e da memória principal para dispositivos de saída. 2) São mostrados exemplos de como imprimir diferentes tipos de dados como inteiros, pontos flutuantes, strings e caracteres usando a função printf em C. 3) São explicados conceitos como largura de campo, precisão, flags e sequências de escape usadas na string de controle de formato de printf.

1. ENTRADA E SAÍDA
Profª Ms. Engª Elaine Cecília Gatto
Curso de Bacharelado em Engenharia de Computação
Universidade do Sagrado CoraçãO – USC
Bauru/SP

2. Streams
• Streams: significa FLUXO e são sequencias de bytes
• Os dados FLUEM de um dispositivo de entrada para a
memória principal e também FLUEM da memória principal
para um dispositivo de saída

3. Imprimindo inteiros
#include <stdio.h>
int main() {
printf(“ Inteiro com sinal: %d n”, 455);
printf(“ Inteiro com sinal: %i n”, 455);
printf(“ Inteiro com sinal: %d n”, +455);
printf(“ Inteiro com sinal: %d n”, -455);
printf(“ HD = shortint: %hd n”, 32000);
printf(“ LD = longint: %ld n”, 2000000000000L);
printf(“ Inteiro octal sem sinal: %o n”, 455);
printf(“ Inteiro sem sinal: %u n”, 455);
printf(“ Inteiro sem sinal: %u n”, -455);
printf(“ Inteiro sem sinal: %u n”, +455);
printf(“ Inteiro hexadecimal minusculo: %x n”, 455);
printf(“ Inteiro hexadecimal maiusculo: %X n”, 455);
Return 0;
}

4. Imprimindo ponto flutuante
#include <stdio.h>
int main(void) {
/* Especificadores de conversão “e, E, f” mostram seis dígitos de
* precisão à direita do ponto decimal. O especificador “f” imprime sempre
* pelo menos um dígito à esquerda do ponto decimal. “e, E” imprimem
* precedendo o expoente, extamente um dígito à esquerda do ponto decimal.
*/
printf(“ Imprime um valor de ponto flutuante em notação exponencial: %e n”,
1234567.89);
printf(“ Imprime um valor de ponto flutuante em notação exponencial: %e n”,
+1234567.89);
printf(“ Imprime um valor de ponto flutuante em notação exponencial: %e n”,
- 1234567.89);

5. Imprimindo ponto flutuante
printf(“ Imprime um valor de ponto flutuante em notação exponencial: %E n”,
1234567.89);
printf(“ Imprime um valor de ponto flutuante em notação exponencial: %f n”,
1234567.89);
/* Especificador de conversão “G ou g” imprime no formato E/e/f sem zeros no
* final. Exemplo: 0.0000875 = 8.75e-05, 8750000.0 = 8.75e+06, 8.75 = 8.75, 87.50
* = 8.75, 875 = 875
*/
printf(“ Imprime um valor de ponto flutuante em notação exponencial: %g n”,
1234567.89);
printf(“ Imprime um valor de ponto flutuante em notação exponencial: %G n”,
1234567.89);
return 0;
}

6. Impressão de strings e
caracteres
#include <stdio.h>
int main(void){
//Especificador de conversão “s e c”. “s” requer um ponteiro para
char como argumento
char character = ‘A’; //inicializando char
char string*+ = “ Isso é uma string ” //inicilizando a string
const char *stringPtr = “ Isso também é uma string ” //ponteiro de
char
printf(“ %c n ”, character);
printf(“ %s n ”, “ Isso também é uma string ”);
printf(“ %s n ”, stringPtr);
return 0;
}

7. Outros
#include <stdio.h>
int main(void){
int *ptr; //ponteiro para int
int x = 12345; //inicializando x
int y;
ptr = &x; /atribuindo o endereço de x a ptr
//Especificador “p” imprime o valor de um ponteiro e o endereço de
uma variável – que são idênticos
printf(“ O valor de ptr é %p n ”, ptr);
printf(“ O endereço de x é %p n n ”, &x);
//Especificador “n” armazena o número de caracteres enviados até esse
ponto no printf atual.
printf(“ Total de caracteres impressos nessa linha: %n ”, &y);
printf(“ %d n n”, y);

8. Outros
printf(“ Total de caracteres impressos nessa linha: %n ”, &y);
printf(“ %d n n”, y);
y = printf(“ Essa linha tem 29 caracteres n ”);
printf(“ %d caracteres foram impressos n n”);
//%% imprime %
printf(“ Imprimindo um %% em uma string de controle de formato n ”);
return 0;
}

9. Impressão com larguras de
campo e precisão
#include <stdio.h>
int main(void) {
printf( “ %4d n ”, 1);
printf( “ %4d n ”, 12);
printf( “ %4d n ”, 123);
printf( “ %4d n ”, 1234);
printf( “ %4d n n”, 12345);
printf( “ %4d n ”, -1);
printf( “ %4d n ”, -12);
printf( “ %4d n ”, -123);
printf( “ %4d n ”, -1234);
printf( “ %4d n n”, -12345);
return 0;
}
• Largura de campo: é o tamanho
exato de um campo em que os
dados são impressos.
• Um inteiro que representa a
largura do campo é inserido
entre o sinal de porcentagem e
o especificador de conversão
• Se a largura do campo for maior
que os dados a serem
impressos, eles normalmente
são linhados à direita dentro
desse campo.

10. Impressão com larguras de
campo e precisão
#include <stdio.h>
int main() {
int i = 873;
double f = 12.94536;
char s*+ = “ Feliz Aniversário “;
printf(“Usando precisão para inteiros n”);
printf(“ t %.4d n t %.9d n n ”, i, i);
printf(“Usando precisão para números em ponto flutuante n”);
printf(“ t %.3f n t %.3e n t %.3g n n ”, f, f, f);
printf(“Usando precisão para strings n”);
printf(“ t %.11s n”, s);
return 0;
}

11. Uso de flags na string de
controle de formato de printf
#include <stdio.h>
int main(void) {
// “ - ” alinha a saída à esquerda dentro do campo especificado
// “ + ” exibe um sinal de adição antes dos valores positivos e um sinal
// de subtração antes de valores negativos
printf(“ %10s %10d %10c %10f n n”, “olá”, 7, ‘a’, 1.23 );
printf(“ %-10s %-10d %-10c %-10f n n”, “olá”, 7, ‘a’, 1.23 );
printf(“ %+d n %+d n ”, 786, -786);
printf(“ % d n % d n ”, 547, -547); //espaço em branco
return 0;
}

12. Literais e sequencias de escape
Sequencia de escape Descrição
‘
Mostra aspas simples na tela
“
Mostra aspas duplas na tela
?
Mostra o ponto de interrogação na tela
Mostra a barra na tela
a
Alerta/campainha
b
Backspace: move o cursor uma posição para trás da linha
f
Form feed: move o cursor para o início da página seguinte
n
Newline: move o cursor para o início da linha seguinte
r
Carriage return: move o cursor para o início da linha atual
t
Tabulação horizontal
v
Tabulação vertical

13. Diretiva #include
• Faz com que uma cópia de um arquivo especificado seja
incluída no lugar da diretiva. (include = incluir)
• Cabeçalho da biblioteca-padrão: #include <>
• #include “”: diretório em que o arquivo está sendo compilado
– normalmente arquivos criados pelo usuário
• A diretiva é usada para incluir arquivos de cabeçalho, com
programas que consistem de diversos arquivos-fonte que
devem ser compilados juntos.

14. Diretiva #define
• Cria constantes simbólicas (constantes representadas por
símbolos) e macros (operações definidas por símbolos)
• MACRO:
• #define areadocirculo(x) ( (pi) * (x) * (x) )
• Torna-se no código fonte
• Area = areadocirculo(4);
• Area = ((3.14159) * (4) * (4) );
• Macros podem ser criadas como funções
• Vantagem: evita o overhead das chamadas as funções

15. exercícios