Disciplina: Linguagem de Programação I

Aula 2: Exibindo No Display

Apresentação
A linguagem C não tem, como na maioria das linguagens, comandos para exibir
mensagens, constantes numéricas, conteúdo de variáveis, retorno de funções, entre
outros, no dispositivo padrão de saída, display.

Em contrapartida, apresenta funções que fazem parte da biblioteca padrão da

linguagem C: stdio.h ( standard input output).

O fato da linguagem C não apresentar comandos para exibir no display é considerado

uma grande vantagem, uma vez que se distancia do hardware aumentando a sua
portabilidade.

Além das funções que vamos estudar (Função que exibe uma cadeia de caracteres;
Função que exibe um caracter; Função que exibe formatado um, ou vários
caracteres, constante numérica, conteúdo de variável, retorno de função), veremos,
em outra aula, funções, também da stdio.h, que gravam em dispositivos, como por
exemplo, no HD.

A maioria dos exemplos foi compilada no gcc / Linux, pois quem sabe desperta a
curiosidade de trabalhar nesse sistema operacional, uma das razões do
desenvolvimento da linguagem C.

Vamos ao conteúdo?
Objetivos
Identificar e usar as funções puts(), putchar() e printf();
Reconhecer e usar os caracteres de controle;
Identificar e usar as funções das bibliotecas math.h, ctype.h, stdlib.h;
Reconhecer e usar os especificadores de formato;
Identificar os operadores aritméticos;
Conhecer funções ou sequência de caracteres que possibilitam formatar a saída
no Dev–C++ e no Linux.
Função que exibe uma cadeia de
caracteres

puts("cadeia de caracteres ");

/*ou vertor de char*/

Essa função não consegue trabalhar com constantes numéricas nem com
variáveis de qualquer tipo, mas é ideal quando só temos mensagens para
exibir. É bom ressaltar que ela já tem embutida uma alimentação de linha,
embora você possa incluir outros elementos.

Portabilidade é isso!

O mesmo código foi compilado em dois compiladores do Windows (Dev-C++ e

Visual Studio 2008) e em um compilador no Linux. Observe que nada foi
alterado e as saídas ficaram iguais. Fantástico!

Código:

#include < stdio.h >

int main()

puts ("\n\t\t*****************************************");

puts ("\t\t* Engenharia *");

puts ("\t\t* Linguagem de Programação *");

puts ("\t\t* ESTACIO *");

puts ("\t\t* Prof. ANITA MACIEL *");

 puts ("\t\t******************************************\n");

getchar();/*Na proxima aula, você vai aprender*/

Saída:

 Saída


Saiba mais

Você pode alterar a cor da saída, no Linux, na opção editar do ambiente.

Você pode fazer isso também no prompt, tanto no Dev-C++ quanto no
Visual Studio 2008, clicando com o botão direito sobre a barra de título,
selecionando propriedades, e fazendo as trocas nas guias fonte e cores.

Função que exibe um caracter

putchar("caracter ");
/*ou variável de um caracter*/
Essa função não exibe uma saída formatada e só pode ser usada para variável
ou constante char de um. Talvez seja a menos usada das 3 apresentadas
nesta aula.

Não ache estranho se você encontrar uma linha dessa putchar('\n'); com \ e n
entre aspas simples porque na linguagem C, quando só existe 1 caracter, é
obrigatório o uso de aspas simples.

Também não estranhe o fato de dizermos um caracter e você estar

visualizando dois porque, você verá, nesta aula, que os dois juntos são
considerados um caracter.

Vamos observar no exemplo que a função é muito limitada, uma vez que
precisamos de puts() para exibir mensagens.

#include < stdio.h >

int main()

putchar ('a');

puts ("-> É a primeira das vogais");

puts ("putchar exibe um caracter enter \' \'");

puts

Função que exibe formatado

printf(“cadeia de caracteres", arg1,

arg2, ..., argn );
/* a lista de argumentos pode estar
ausente */
Essa função exibe um, ou vários caracteres, constante numérica, conteúdo de
variável, retorno de função - uma função completa.

Essa função, como já dito, não faz parte da Linguagem C, mas é a mais
importante função para exibir na tela. Por isso, ela precisa ser bem explorada
com muitos exemplos para que você se torne capaz de saber usá-la com
competência, otimizando seus códigos. Além disso, pretendemos desmistificar
sua tão propagada dificuldade.

Vamos começar analisando sua sintaxe:

Cadeia de caracteres entre aspas

Tudo que você desejar que apareça na tela, exatamente na ordem, deverá
estar dentro dessa cadeia de caracteres, também referenciada por alguns
autores de String.

Pode ser somente uma mensagem, caracteres especiais, uma mensagem com
“lugares reservados” para os argumentos através de códigos formadores,
caracteres especiais etc.

Lista de argumentos separados por vírgulas

Os argumentos são variáveis, constantes, chamadas de funções, expressões,

entre outros.

Caracteres especiais
Vamos conhecer alguns caracteres especiais que lhe ajudarão a formatar a
saída de seus programas? Eles também são conhecidos como caracteres de
controle ou sequência de escape por serem sempre precedidos pela \, cujo
nome em inglês é backslash, mas por aqui é conhecida como barra invertida
ou contrabarra.

Caracteres de Controle/Especiais Sequência de escape

Nulo (null) \0
Campainha (bell) \a
Retrocesso (backspace) \b
Tabulação horizontal \t
Nova linha (new line) \n
Tabulação vertical \v
Alimentação de folha (form feed) \f
Retorno de carro (carriage return) \r
Aspas(“”) \”
Apóstrofo (‘) \’
Barra invertida (\) \\


Atenção

A contrabarra tem um significado grande na programação e tem até sua

história na internet. Sua finalidade é alertar para que seja dado um
tratamento especial para o caracter que a sucede podendo ser uma letra,
um algarismo ou um caracter gráfico.

Vamos conhecer com mais detalhes alguns desses caracteres:

Aspas duplas

As aspas duplas precisam de um tratamento especial uma vez que a

cadeia de caracteres da função fica entre elas.

Veja o código:

#include < stdio.h >

int main()

{
 printf("\n\ "Linguagem que mudou o cenário da

programação\". Disse ANITA LOPES.\n");

Veja a saída:

\n

Essa sequência é chamada de new line e equivale ao pressionamento da

tecla Enter em um editor de texto. Como é usada a letra n, ser precedida
pela \ (barra invertida) se justifica porque ficaria impossível determinar
quando seria uma nova linha ou, a letra n.

Você poderá, com uma única função printf, exibir em várias linhas, pois
várias sequências \n podem ser usadas juntas, ou separadas.

Veja o código:

#include < stdio.h >

int main()

printf("Digitando em um processador, você pressiona

enter quando deseja passar para linha abaixo.\nUse a barra

invertida seguida da letra n para produzir o mesmo

efeito.\n\nObservou? Usei duas vezes \\n. \nE duas vezes a barra

invertida para que ela fosse exibida assim \\. \n");

 }

Veja a saída:

\t

Essa sequência é chamada de horizontal tabulation e equivale ao

pressionamento da tecla Tab em um editor de texto. Como é usada a
letra t, ser precedida pela \ (barra invertida) se justifica porque ficaria
impossível determinar quando seria uma tabulação ou, a letra t.

Você poderá, com uma única função printf, exibir em várias posições pré-
definidas das linhas, pois várias sequências \t podem ser usadas juntas,
ou separadas.

Veja o código:

#include < stdio.h >

int main()

printf("12345678901234567890123456789012345678901

2345678901234567890 \nLPI\tEAD\t\tESTACIO\n\tLinguagem

C.\nUma função possibilitou exibir em várias linhas\n");

Veja a saída:
 \v

Essa sequência é chamada de Vertical Tabulation. Como é usada a letra

v, ser precedida pela \ (barra invertida) se justifica porque ficaria
impossível determinar quando seria uma tabulação vertical ou, a letra v.

A saída abaixo é no Linux. Teste nos Windows!

Veja o código:

#include < stdio.h >

int main()

printf("\nEstacio\vLPI\n");

Veja a saída:

Códigos de formatação
Você deve ter percebido a importância das sequências \n e \t. Pratique muito
para que se sinta seguro em usá-las.
Agora vamos identificar os códigos de formatação, também conhecidos como
especificadores de formato.

Procure guardá-los porque, sem eles, você não consegue exibir nenhum valor
dos argumentos. Observe que todos serão precedidos pelo símbolo de %.

%d

Exibe valores inteiros.

%f

Exibe valores reais com 6 casas decimais.

%c

Exibe 1 caracter.

%s

Exibe uma cadeia de caracteres.

%0

Exibe uma constante octal.

%x ou %X

Constante hexadecimal.

%u

Inteiro sem sinal.

%Id

Longo inteiro.
 %e

Exponencial.

%p

Ponteiro.

%+..

Coloca sinal.

%%

Coloca na tela um %.

% <n> d

Formata valores inteiros com n casas, deixando espaços nas posições não
usadas à esquerda.

%<0n>d

Formata valores inteiros com n casas, colocando 0 nas posições não usadas à
esquerda.

%<n.f>f

Formata real com determinado n de casas que incluem a parte inteira, o ponto
decimal e o número de casas na parte decimal.

Os operadores < (menor que) e> (maior que) NÃO deverão ser
colocados na expressão. Eles indicam que o conteúdo de n é variável.

Veja alguns exemplos:

%c %d %f %s %t.decf

Nesse exemplo, apresentamos 4 formatos básicos e 1 com uma

formatação completa para os tipos float e double. Nesse último, com, ou
sem presença de zeros à esquerda.

A letra t corresponde ao total de posições e dec, o total de casas

decimais. Veja exemplo: %10.2f.

#include < stdio.h >

int main()

printf("\n Exibe a letra : %c", 'E');

printf("\n Exibe a palavra : %s", "Engenharia");

printf("\n 0 ano %d", 2012);

printf("\n Um bom CR é %.1f", 9.5);

printf("\n Salário para um Engenheiro R$%10.2f", 12350.00);

printf("\n Salário para um Engenheiro R$%010.2f\n\n", 12350.00);

Veja a saída:

%nd
Aqui, apresentamos um número inteiro formatado com n casas. Observe
o alinhamento e o que acontece com posições não usadas.

#include < stdio.h >

int main()

printf("\n %6d", 6);

printf("\n %6d", 56);

printf("\n %6d", 456);

printf("\n %6d", 3456);

printf("\n %6d", 23456);

printf("\n %6d", 123456);

printf("\n\n");

Veja a saída:

%0nd

Nesse exemplo, apresentamos um número inteiro formatado com n

casas. Observe o alinhamento e o que acontece com posições não usadas
pela presença do 0 no código de formatação.
 #include < stdio.h >

int main()

printf("\n código: %06d", 6);

printf("\n código: %06d", 56);

printf("\n código: %06d", 456);

printf("\n código: %06d", 3456);

printf("\n código: %06d", 23456);

printf("\n código: %06d", 123456);

printf("\n\n");

Veja a saída:

%t.decf

Nesse exemplo, mostramos o que pode acontecer se a formatação de um

número real não for precisa. A princípio, você pode achar que são iguais,
mas veja o que acontece, lendo os textos na saída.
 #include < stdio.h >

int main()

printf("\n%8f -> exibe com 8 dígitos", 13.17891);

printf("\n%8.2f -> exibe em 8 colunas, sendo duas depois do . e uma

para o .", 13.17891);

printf("\n%7.5f -> por ser insuficiente(7), exibe tudo", 13.17891);

printf("\n\n");

Veja a saída:

%+..

Normalmente, o sinal de + não aparece quando o número é positivo,

mas se você precisar que ele apareça, use antes da letra d ou f. Se o
número for negativo, aparecerá o sinal de – como sempre.

#include < stdio.h >

int main()

printf("\n%+d\t%+d\n", -23, 23);

 getchar();

Veja a saída:

Mais argumentos do que especificadores

Nesse exemplo, mostramos a importância de ficarmos atentos quando

formos escrever a String, pois o número de códigos deve corresponder
ao número de argumentos. Nesse caso, tem mais argumentos e,
aparentemente, não percebemos nada estranho, mas um valor não foi
exibido.

#include < stdio.h >

int main()

printf("\n%%d\t%+d\n", 23, 24/5, 24%5);

getchar();

Veja a saída:
Menos argumentos do que especificadores

Já dissemos sobre a importância da cadeia de caracteres da função

printf(), pois tudo que está dentro dessa cadeia sairá no display. Sendo
assim, todo cuidado é pouco, uma vez que podemos colocar mais
especificadores do que argumentos e aparecerem números estranhos
que, às vezes, demoramos a perceber que foi esse tipo de erro.

#include < stdio.h >

int main()

printf("\n%%d\t%d\ t%d\n", 23, 24/5);

getchar();

Veja a saída:

Especificador diferente do tipo do argumento

Muito cuidado ao escolher o especificador, pois se ele for diferente do tipo

do argumento, irá aparecer 0 para int e float ou um número estranho
para int e 0 para float, depende do compilador/SO.
 #include < stdio.h >

int main()

printf("\nArgumento real e foi usado %%d -> %d \nArgumento inteiro

e foi usado %%f -> %f\n”, 23.5, 23);

getchar();

Veja a saída:


Atenção

Nos 4 últimos exemplos, todas as saídas alertam para algum tipo de

erro.

printf
Vamos exibir resultados de operações com a função printf. Acreditamos que
você já deva conhecer os 4 símbolos dos operadores aritméticos, mas vamos
apresentar aqui só para não termos dúvidas do tipo de resultado que eles
retornam. Além dos 4, a Linguagem C tem mais um que é muito válido.
printf - Operadores Aritméticos
Cada operador aritmético está relacionado a uma operação elementar: adição,
subtração, multiplicação e divisão. Existe ainda um operador (%) chamado
operador de módulo cujo significado é o resto da divisão inteira.

Operador Operação Tipo de resultado

+ adição
- subtração
* multiplicação Para as 4 operações o tipo do resultado será igual
/ divisão ao tipo do operando que pertence ao conjunto
módulo (resto mais abrangente.
% da divisão
inteira)


Atenção

Fique atento ao operador /, pois se os operandos forem inteiros, inteiro

será o quociente. Veja exemplo: 2/4 terá como resultado, zero.

Quanto ao operador %, ele efetua uma divisão, mas retorna o quociente.

Veja exemplo: 8 % 5 retorna 3 que é o resto da divisão inteira.

Todos os operadores

Nesse primeiro exemplo, apresentamos o operador resto. Observe que mesmo

os operandos sendo inteiros, se você acrescentar um ponto em um deles, o
quociente passa a ser real. Mais tarde você aprenderá outra forma de fazer
conversão.

Observe também que usamos dois %% para que pudesse ser exibido na tela.
 #include < stdio.h >

int main()

printf("\n######## Operadores Aritméticos e outros ########\n);

printf("\n\tAdição 13 + 4 : %d", 13+4);

printf("\n\tSubtração 13 - 4 : %d", 13-4);

printf("\n\tMultiplicação 13 * 4 : %d", 13*4);

printf("\n\tDivisão Inteira 13 / 4 : %d", 13/4);

printf("\n\tDivisão Real de 13./ 4 : %.2f", 13./4); /*Observe o ponto */

printf("\n\tResto da divisão Inteira de 13%% 4: %d", 13%4);

printf("\n\n");

Veja a saída:

/ e % no programa da data

Esse é o exemplo mais convincente para apresentar o operador % e a barra

usada para divisão inteira. Em todas as linguagens que estudamos não pode
faltar.
 #include < stdio.h >

int main()

printf("\ndia: %02d", 18081917/1000000);

printf("\nmes: %02d", (18081917/10000)%100);

printf("\nano: %d", 18081917%10000);

printf("\n\n");

getchar();

Veja a saída:


Saiba mais

Você precisará de alguns conceitos básicos da Matemática que

aprendemos lá no Ensino Fundamental.

Se precisar recordá-los, faça o download da apostila de Matemática

e Programação <http://www.anitalopes.com/MATEMATICA-
PROGRAMACAO-umaParceriaPperfeita.pdf> .

A senha é: leicam2010.
Para finalizar, abordaremos 3 bibliotecas e algumas das funções delas para
que possamos exercitar a função printf().

Como já dissemos, por toda a história da Linguagem C, teríamos que

apresentar tudo em ambiente Linux, mas a portabilidade permitirá que você
teste tudo em compiladores do Windows.

Biblioteca math.h

Calcula o valor absoluto real d

fabs (double d)
Funções trigonométricas do ângulo arco, em radianos
sin (double arco) Seno
cos (double arco) Cosseno
tan (double arco) Tangente
asin (double arco) Arco seno
acos (double arco) Arco cosseno
atan (double arco) Arco tangente
Funções de arredondamento
ceil (double num) Arredonda para cima. Ex.: ceil(3.2 )= > 4.0
Floor (double num) Arredonda para baixo. Ex.: ceil(3.2) = > 3.0
Funções logarítmicas: log() é log10() é logaritmo
decimal (base 10)
log (double num) Logaritmo natural (base e)
log10 (double num) Logaritmo decimal (base 10)
Funções: potência e raiz quadrada
pow (double base, double exp) Potenciação. Ex.: pow(3.2, 5.6) = > 3.2 5.6

lsqrt (double num) Raiz quadrada. Ex.: sqrt (9.0) = > 3.0

ceil / floor

Funções que arredondam constantes do tipo real.

 #include < stdio.h >

int main()

printf("\nCeil : %.0f", ceil(13.01));

printf("\nCeil : %.0f", ceil(13.9));

printf("\nFloor : %.0f", floor(13.01));

printf("\nFloor : %.0f", floor(13.9));

printf("\n\n");

Saída:

fmod

Função que retorna o resto de uma divisão real.

#include < stdio.h >

int main()

{
 printf("\nResto da divisão real de %.2f" por %.2f : %.2f\n”, 13.4, 3.,
fmod(13.4,3));

Saída:

sin / cos / tan

Embora tenha muito mais funções, só apresentaremos as 3 básicas.

Reforçarmos que o ângulo precisa ser convertido de graus para radianos. Para
isso, multiplique por PI e divida por 180.

Assuma PI como sendo 3.14159265.

#include < stdio.h >

int main()

printf("\nseno : %.3f", sin(60*3.14159265/180));

printf("\nCo-seno : %.3f", cos(60*3.14159265/180));

printf("\nTangente : %.3f", tan(60*3.14159265/180));

printf("\n\n");

}
Saída:

pow / sqrt / log

Essas funções são bem básicas e muito usadas.

Com a função pow() poderemos extrair raiz a qualquer índice como mostrada
no exemplo.

Apesar de termos 2 funções para logaritmos, se desejarmos calcular o

logaritmo em qualquer base, use uma das propriedades do logaritmo como
também mostrada no exemplo.

#include < stdio.h >

int main()

printf("\npow - 2 elevado a 8 : %.2f", pow(2,8));

printf("\npow - raiz indice 8 de 256 : %.2f", pow(256, 1./8));

printf("\nsqrt - raiz quadrada de 256 : %.2f", sqrt(256));

printf("\nlogaritmo de 10 na base e : %.2f", log(10));

printf("\nlogaritmo de 100 na bse de 10 : %.2f", log(100));

printf("\nlogaritmo de 256 na bse de 2 : %.2f", log(256)/ log(2));

printf("\n\n");

}
Saída:

Biblioteca ctype.h
Essa biblioteca é composta de funções que manipulam um caracter.

Os códigos variam de 0x20 (32 em decimal) até 0x7E (126 em decimal) na

tabela ASCII.

Manipula caracteres
toupper(char) Retorna uma letra convertida para maiúscula
tolower(char) Retorna uma letra convertida para minúscula
isalnum(int Retorna diferente de 0 se o argumento for uma letra ou
ch) número
isalpha(int ch) Retorna diferente de 0 se o argumento for uma letra
isdigit(int ch) Retorna diferente de 0 se o argumento for um número
isspace(int ch) Retorna diferente de 0 se o argumento for um espaço

Existe uma relação muito intensa entre char e int na Linguagem C.

Vamos constatar essa relação através do próximo exemplo onde nos

argumentos são números inteiros e, quando se usa o especificador %c o
número é convertido para o caracter correspondente na tabela ASCII. No
caso, a letra A.

Se inserirmos essa linha:

printf("\n%c\t%d\t%o\t%x\n", 'A', 'A',

'A', 'A');
Obteremos o mesmo resultado:

toupper / tolower

Essas funções são convertidas para letra maiúscula e para letra minúscula,
respectivamente.

#include < stdio.h >

int main()

printf("\nCom 65: %c\tCom \'A\': %c\n", tolower(65), tolower('A'));

printf("\nCom 97: %c\tCom \'a\': %c\n", tolower(97), tolower('a'));

Saída:

isalnum

Como existe um conjunto de funções que uma lógica parecida, apresentamos

somente uma. Você pode testar as outras.
 #include < stdio.h >

int main()

printf("\nRetorna diferente de 0 se verdade\n");

printf("\n2 é Letra ou Dígito? %d\n", isalnum('2'));

printf("\nL é Letra ou Dígito? %d\n", isalnum('L'));

printf("\n* é Letra ou Dígito? %d\n", isalnum('*'));

Saída:

Biblioteca stdlib.h
Essa biblioteca é de propósito geral, pois as funções têm finalidades
diferentes.

Calcula o valor absoluto do inteiro i e do real d,

respectivamente
abs(int/float) Retorna número sem sinal
atoi(const char *str) Retorna um número inteiro ou 0
atof(const char *str) Retorna um número real ou 0
rand() Retorna um número inteiro positivo ou zero
system() Executa comandos do SO e carrega executáveis
atoi /atof

Essas funções serão muito úteis para trechos de proteção na entrada de dados
numéricos, evitando erros na execução, uma vez que o programa receberá a
entrada numérica como String e converterá através dessas funções para
números quando for possível.

#include < stdio.h >

int main()

printf("\n%d\n", atoi("234.56ab"));

printf("\n%.2f\n", atof("234.56ab"));

Saída:

abs

Essa função é uma das mais simples, pois retorna o valor absoluto do
número.

#include < stdio.h >

 int main()

printf("\nNúmero positivo: %d\tNúmero negativo: %d\n", abs(23),

abs(-23));

Saída:

rand

A função rand() retorna um número inteiro no intervalo de 0 até o maior

inteiro. Ela sempre deve ser usada com a função srand() feita para gerar o
incializador desse conjunto de números pseudo aleatórios.

#include < stdio.h >

int main()

printf("\nRetorna número aleatório entre 1 e 6\n");

printf("\n%d\n", 1+ rand()% 6);

Saída:
 A função system() será usada para chamar o comando pause, color, cls, um
bloco de notas, a calculadora etc.


Saiba mais

Para finalizar, convidamos a conhecer a biblioteca conio2.h

<galeria/aula2/anexo/a02_doc01.pdf> e como fazemos no Linux
para obtermos resultados semelhantes ao dessa biblioteca que foi
atualizada par o Dev-C++.

Próximos Passos

Identificar os tipos de dados na linguagem;

Conhecer e aplicar o conceito de variável;
Identificar e usar as funções que possibilitam a entrada de dados via teclado,
tais como: getchar(),getche, getch(), gets(), fgetc(stdin), fgets(), scanf;
Construir programas que possibilitem a interatividade com o usuário.

Explore mais

Veja uma lista de exercícios

<http://estaciodocente.webaula.com.br/cursos/DIS079/docs/A02_t15.pdf
?playTo=%5Btype+Function%5D> para praticar o conteúdo abordado na nossa
aula.