Apostila GCC

UniversidadeCatlicadePelotas
EscoladeInformtica
CinciadaComputao
C
for
Linux
por
Prof.Dr.PauloRobertoGomesLuzzardi
luzzardi@atlas.ucpel.tche.br
http://infovis.ucpel.tche.br/luzzardi
Verso
2.02
(Junho/2007)
RefernciasBibliogrficas
KERNIGHAN,BriamW.CaLinguagemdeProgramaoPadroANSI,Riode
Janeiro:Campus,1990.
Pelotas,quintafeira,14dejunhode2007(15:06)
Sumrio
1. Introduo...................................................................................................................................................7
1.1 - Histrico.............................................................................................................................................7
1.2 - Evoluo.............................................................................................................................................7
1.3 - Caractersticas....................................................................................................................................7
1.4 - Utilizao...........................................................................................................................................7
2. Ambiente de Programao Anjuta..............................................................................................................8
2.1 Compilador gcc.....................................................................................................................................8
2.2 Instalao do Anjuta.............................................................................................................................8
2.3 Interface do Anjuta...............................................................................................................................8
3. Estrutura de um programa em C.................................................................................................................9
3.1 - Identificadores....................................................................................................................................9
3.2 Comentrios do programador............................................................................................................9
3.3 - Regras gerais para escrever um programa em C.................................................................................9
3.4 - Palavras reservadas...........................................................................................................................10
3.5 - Declarao de variveis....................................................................................................................10
3.5.1 - Onde as variveis podem ser declaradas....................................................................................11
3.5.2 - Inicializao de variveis...........................................................................................................12
3.6 - Constantes........................................................................................................................................12
3.6.1 - Constantes hexadecimais e octais..............................................................................................12
3.6.2 - Constantes strings......................................................................................................................13
3.6.3 - Constantes especiais..................................................................................................................13
3.7 - Comandos do pr-processador do C.................................................................................................14
3.7.1 - O comando #define...................................................................................................................14
3.7.2 - O comando #include.................................................................................................................14
4. Tipos de dados..........................................................................................................................................15
4.1 - Tipos bsicos....................................................................................................................................15
4.2 Modificadores de tipo.........................................................................................................................15
5. Operadores................................................................................................................................................16
5.1 - Operadores aritmticos.....................................................................................................................16
5.2 - Operadores relacionais.....................................................................................................................16
5.3 - Operadores lgicos...........................................................................................................................16
5.4 - Incremento e decremento.................................................................................................................17
5.5 - Operador de atribuio.....................................................................................................................18
5.6 - O operador sizeof.............................................................................................................................18
5.7 - Casts.................................................................................................................................................19
5.8 - Expresses........................................................................................................................................19
5.8.1 - Converso de tipos em expresses.............................................................................................19
6. Funes padres........................................................................................................................................21
6.1 abs....................................................................................................................................................21
6.2 fabs..................................................................................................................................................21
6.3 asin..................................................................................................................................................21
6.4 acos..................................................................................................................................................21
6.5 atan..................................................................................................................................................21
6.6 cos....................................................................................................................................................22
6.7 sin....................................................................................................................................................22
6.8 exp...................................................................................................................................................22
6.9 pow..................................................................................................................................................22
6.10 sqrt.................................................................................................................................................22
6.11 log..................................................................................................................................................22
6.12 atof.................................................................................................................................................23
6.13 atoi.................................................................................................................................................23
6.14 atol.................................................................................................................................................23
6.15 - log10...............................................................................................................................................23
6.16 tan..................................................................................................................................................23
6.17 rand................................................................................................................................................23
6.18 srand..............................................................................................................................................24
6.19 system............................................................................................................................................24
7. Comandos.................................................................................................................................................25
7.1 - Tipos de Comandos..........................................................................................................................25
7.1.1 - Seqncia..................................................................................................................................25
7.1.2 - Seleo......................................................................................................................................25
7.1.3 - Repetio...................................................................................................................................26
7.1.4 Atribuio....................................................................................................................................26
7.2 - Comando if.......................................................................................................................................26
7.2.1 - if encadeados.............................................................................................................................27
7.3 - O comando switch............................................................................................................................28
7.4 - Comando while................................................................................................................................31
7.5 - O comando for.................................................................................................................................33
7.6 - O loop do { } while..........................................................................................................................34
7.7 - Interrupo de loops.........................................................................................................................34
7.7.1 - O comando break......................................................................................................................34
7.7.2 - O comando continue.................................................................................................................35
7.8 - A funo exit ()................................................................................................................................35
8. Entrada e sada..........................................................................................................................................37
8.1 - Entrada e sada do console................................................................................................................37
8.2 - Entrada e sada formatada................................................................................................................37
8.2.1 - Sada formatada (printf)............................................................................................................37
8.2.2 - Entrada formatada (scanf).........................................................................................................38
8.2.3 Leitura de strings (fgets)...........................................................................................................39
9. Controle do vdeo e teclado......................................................................................................................41
9.1 Biblioteca ncurses - modo texto......................................................................................................41
10. Lista de exerccios (comandos)...............................................................................................................42
11. Vetores, matrizes e strings......................................................................................................................47
11.1 - Vetores...........................................................................................................................................47
11.2 Strings............................................................................................................................................48
11.3 - Matrizes (Multidimensional)..........................................................................................................48
11.4 - Vetor de strings...............................................................................................................................48
11.5 - Inicializao de matrizes e vetores..................................................................................................49
11.6 - Inicializao de um vetor de caracteres..........................................................................................49
11.7 - Inicializao de matrizes multidimensionais..................................................................................49
11.8 - Inicializao de vetores e matrizes sem tamanho............................................................................49
11.9 - Classificao de dados ou ordenao (sort).....................................................................................51
11.10 - Lista de exerccios (vetores)..........................................................................................................52
12. Manipulao de strings...........................................................................................................................55
12.1 - strcpy..............................................................................................................................................55
12.2 - strcmp.............................................................................................................................................56
12.3 - strcat...............................................................................................................................................56
12.4 - strlen...............................................................................................................................................57
12.5 strchr..............................................................................................................................................57
12.6 Lista de exerccios (strings)............................................................................................................58
13. Funes definidas pelo programador......................................................................................................61
13.1 - Valores de retorno..........................................................................................................................62
13.2 - Passagem de parmetros por valor..................................................................................................64
13.3 - Passagem de parmetros por referncia..........................................................................................65
13.4 - Funes que devolvem valores no-inteiros...................................................................................66
13.5 - Argumentos argc e argv do main....................................................................................................66
13.6 - Recursividade.................................................................................................................................68
13.7 - Lista de exerccios (funes)..........................................................................................................69
14. Ponteiros.................................................................................................................................................75
14.1 - Variveis ponteiros.........................................................................................................................76
14.2 - Operadores de ponteiros.................................................................................................................76
14.3 - Expresses com ponteiros..............................................................................................................76
14.3.1 - Atribuies com ponteiros.......................................................................................................76
14.3.2 - Aritmtica com ponteiros........................................................................................................77
14.3.2.1 - Incremento (++) .............................................................................................................77
14.3.2.2 - Decremento (--)................................................................................................................78
14.3.3 - Soma (+) e subtrao (-) .........................................................................................................78
14.3.4 - Comparao de ponteiros........................................................................................................78
14.4 - Ponteiros e vetores..........................................................................................................................78
14.4.1 - Indexando um ponteiro...........................................................................................................79
14.4.2 - Ponteiros e strings....................................................................................................................79
14.4.3 - Obtendo o endereo de um elemento de um vetor...................................................................80
14.4.4. Vetores de ponteiros.............................................................................................................80
14.5 - Ponteiros para ponteiros.................................................................................................................80

14.6 - Inicializao de ponteiros...............................................................................................................81
14.7 - Alocao dinmica de memria......................................................................................................81
14.7.1 malloc.....................................................................................................................................81
14.7.2 free..........................................................................................................................................82
15. Entrada e sada em disco.........................................................................................................................84
15.1 - Fila de bytes (stream).....................................................................................................................84
15.1.1 - Filas de texto...........................................................................................................................84
15.1.2 - Filas binrias............................................................................................................................85
15.2 - Sistema de arquivo bufferizado .....................................................................................................85
15.2.1 - fopen........................................................................................................................................85
15.2.2 putc.........................................................................................................................................87
15.2.3 getc.........................................................................................................................................87
15.2.4 feof.........................................................................................................................................87
15.2.5 fclose.......................................................................................................................................88
15.2.6 - rewind......................................................................................................................................88
15.2.7 getw e putw.............................................................................................................................88
15.2.8 fgets e fputs.............................................................................................................................89
15.2.9 fread e fwrite...........................................................................................................................89
15.2.10 fseek......................................................................................................................................89
15.2.11 fprintf e fscanf......................................................................................................................90
15.2.12 remove..................................................................................................................................90
15.3 - Sistema de arquivo no bufferizado................................................................................................92
15.3.1 open, creat e close...................................................................................................................93
15.3.2 write e read.............................................................................................................................93
15.3.3 unlink.....................................................................................................................................94
15.3.5 eof...........................................................................................................................................94
15.3.6 tell...........................................................................................................................................94
15.4 - Lista de exerccios (arquivos).........................................................................................................97
16. Tipos de dados definidos pelo programador..........................................................................................101
16.1 - Estruturas......................................................................................................................................101
16.1.1 - Referncia aos elementos da estrutura...................................................................................101
16.1.2 - Matrizes de estruturas............................................................................................................101
16.1.3 - Passando estruturas para funes...........................................................................................102
16.1.3.1 - Passando elementos da estrutura.....................................................................................102
16.1.3.2 - Passando estruturas inteiras............................................................................................102
16.1.4 - Ponteiros para estruturas........................................................................................................102
16.2 - Campos de bit...............................................................................................................................103
16.3 - Union............................................................................................................................................103
16.4 - typedef..........................................................................................................................................104
16.5 - Tipos de dados avanados.............................................................................................................104
16.5.1 - Modificadores de acesso........................................................................................................104
16.5.1.1 - O modificador const.......................................................................................................104
16.5.1.2 - O modificador volatile....................................................................................................104
16.5.2 - Especificadores de classe de armazenamento........................................................................104
16.5.2.1 - O especificador auto.......................................................................................................104
16.5.2.2 - O especificador extern....................................................................................................105
16.5.2.3 - O especificador static......................................................................................................105
16.5.2.4. O especificador register....................................................................................................105
16.5.3 - Operadores avanados...........................................................................................................105
16.5.3.1 - Operadores bit a bit.........................................................................................................105
16.5.3.2 - O operador ?...................................................................................................................106
16.5.3.3 - Formas abreviadas de C..................................................................................................106
16.5.3.4 - O operador ,....................................................................................................................106
17. Listas lineares........................................................................................................................................108
17.1 - Implementao de uma pilha........................................................................................................109
17.2 - Implementao de uma fila..........................................................................................................112
17.3 - Lista duplamente encadeada.........................................................................................................114
19. Programas exemplos usando ncurses....................................................................................................118
19.1 Jogo de Caa-Palavras.....................................................................................................................118
19.2 Relgio em Linux...........................................................................................................................127
19.3 Biblioteca conio.h + clock.c....................................................................................................129
19.4 Biblioteca conio.h completa........................................................................................................132
19.5 Jogo da Forca..................................................................................................................................140

20. Biblioteca ncurses.................................................................................................................................149
20.1 Conceitos Bsicos...........................................................................................................................149
20.2 Funes de inicializao.................................................................................................................151
20.3 Funes de entrada.........................................................................................................................152
20.4 Funes de sada.............................................................................................................................152
20.5 Funo de Formatao de texto......................................................................................................153
21. Outros Comandos ................................................................................................................................155
21.1 Comandos do Pr-Processador........................................................................................................155
21.2 Hierarquia dos operadores aritmticos, relacionais, lgicos e bit a bit............................................156
21.3 Declarao de constantes tipadas....................................................................................................157
21.4 Ponteiro para Ponteiro....................................................................................................................157
22. Programas escritos em C.......................................................................................................................160
1.Introduo
1.1Histrico
A linguagem de programao C foi desenvolvida nos anos 70 por
Dennis Ritchie em um computador DEC PDP11 que utilizava Sistema
OperacionalUNIX.
1.2Evoluo
ApartirdeumalinguagemmaisantigachamadaBCPL,desenvolvida
porMartinRichards,surgiuumalinguagemchamadaB,inventadaporKen
Thompsonqueinfluenciouodesenvolvimentodalinguagemdeprogramao
C.
1.3Caractersticas
Linguagem de nvel mdio (combina recursos de alto e baixo
nvel);
Bastanteportvel;
Nofortementetipada;
Permiteamanipulaodebits,byteseendereos;
Permiteescreverprogramasmodulareseestruturados.
1.4Utilizao
Permiteodesenvolvimentoeimplementaodesoftwarebsico,
taiscomo:
SistemasOperacionais;
Interpretadores;
SGBD(SistemaGerenciadordeBancodeDados);
Editores(detextoegrficos);
Compiladores;
Programaseducacionais.
2.AmbientedeProgramaoAnjuta
2.1Compiladorgcc
OcompiladorgccocompiladorCdoprojetoGNU,gratuitoede
cdigoaberto.OprojetoGNU(GnusNotUnix)foipropostoporRichard
Stallman em 1983. O projeto teve incio em 1984, e a proposta era
desenvolverumsistemaoperacionalcompletoelivre,similaraoUnix.
2.2InstalaodoAnjuta
Um dos ambientes de programao que podem ser utilizados no
Sistema Operacional Linux o Anjuta. Para instalar o pacote execute
osseguintespassos:
$aptgetupdate<enter>...............Atualizaalistadepacotes
$aptgetinstallgcc<enter>..........InstalaoCompiladorC
$aptgetinstallg++<enter>..........InstalaoCompiladorC++
$aptgetinstallanjuta<enter>.......Instalaoambienteanjuta
2.3InterfacedoAnjuta
Figura1:AmbientedeProgramaoAnjuta
3.EstruturadeumprogramaemC
3.1Identificadores
So os nomes criados pelo programador para fazer referncia a
variveis,constantes,funesertulos.
Regrasparaacriaodeidentificadores:
Oprimeirocaracterdeveserumaletraousublinha(_);
Oscaracteresseguintesdevemserletras,nmerosousublinhas;
Osprimeiros32(default)caracteressosignificativos;
No permitido a utilizao de caracteres em branco (caracter
espao).
Exemplosemvariveis: intnum_dentes=32;
floatinflacao;
chara,_a;
Exemplosemconstantes:#defineESC 27
#defineENTER
Exemplosemfunes:
10
x=raiz_quadrada(y);
printf(Valor:%.2f\n,inverso(n));
Observao:afunoinversodefinidapeloprogramador(1/n).
3.2Comentriosdoprogramador
Os comentrios do programador so linhas de cdigo que no so
compiladaspelocompilador,ouseja,servemapenascomoanotaespara
serem lembradas mais tarde (por exemplo, quando forem feitas
manutenes no programa). Em C os comentrios podem ser feitos da
seguintemaneira:
/*Istoumcomentriodevriaslinhas*/
//IstoumcomentrioemC++deumalinha
Um comentrio, pode ainda, utilizar vrias linhas do programa.
Vejaoexemploabaixo:
/*
Funo:STRING
Parmetrosdeentrada:x,y
Parmetrosdesada:c,t
Retorno:SemRetorno
*/
3.3RegrasgeraisparaescreverumprogramaemC
Um programa em C constitudo de uma ou mais funes

delimitadasporchaves{},ondeumadestasfunes,obrigatoriamente
chamadamain().Asprincipaisregrasso:
Letras maisculas e minsculas so tratadas como caracteres
diferentes;
Oformatodotextolivre;
A funo main() especifica onde o programa comea e termina de
serexecutado;
Todososcomandossoterminadosporpontoevrgula;
Todasasvariveisdevemserdeclaradas;
{funocomeaaserexecutada;
}funoterminadeserexecutada.
Programa exemplo (1): Imprimir a data no seguinte formato: [Data:
dd/mm/aaaa].
#include<stdio.h>
intmain(void)
{
intdia,mes,ano;
//variveislocaisutilizadassomentenafunomain
dia=12;
mes=6;
ano=2006;
printf("Data:%02d/%02d/%04d\n",dia,mes,ano);
return(0);
}
3.4Palavrasreservadas
DefinidasporK&R
(Kernighan&Ritchie)
auto
break
case
char
continue
default
do
doubleif
else
entry
extern
float
for
goto
int
long
register
return
sizeof
short
ANSI
static
struct
switch
typedef
union
unsigned
while
const
enum
signed
void
volatile
near
_ds
asm
Observao: As palavras reservadas no podem ser utilizadas pelo

programador como nome de variveis, constantes ou funes, ou seja,
noservemcomoidentificadores.
3.5Declaraodevariveis
Sintaxe:tipo_dado_baselista_de_variveis;
tipo_dado_base:deveserumtipodedadovlido(int,char,float,doubleouvoid)
lista_de_variveis:umoumaisidentificadoresseparadosporvrgula.
10
Exemplo:
intmain(void)
{
inti,j,k;
floata,b;
charch;
3.5.1Ondeasvariveispodemserdeclaradas
Definidas fora de todas as funes, incluindo a funo main()
so chamadas de variveis globais e podem ser acessadas em
qualquer parte do programa. Estas variveis so alocadas
estaticamente na memria RAM (Random Access Memory Memria de
acessorandmico).
Definidasdentrodeumafunosochamadasdevariveislocaise
spodemseracessadasdentrodestafuno.Estasvariveisso
alocadas dinamicamente na memria RAM. Depois que uma funo
executada,estasvariveissodesalocadas.
Na declarao de parmetros formais de uma funo. Sendo estas
locaisealocadasdinamicamentenamemriaRAM.
Observao: Memria ROM (Read Only Memory Memria somente de
leitura).
Alocaodememria:(Reservadeespaodememria(RAM)paraalocarumavarivel)
Alocaoestticadememria:Tipodealocaodememriaemqueuma
varivelalocada(temumespaoreservado)namemriaRAMdurante
toda a execuo do programa. Este espao de memria desalocado
somentequandooprogramaacaba.
Alocaodinmicadememria:Tipodealocaodememriaemqueuma
varivel alocada (tem um espao reservado) na memria RAM
temporariamente. Este espao de memria desalocado quando o
espaonomaisnecessrio.
Programaexemplo(2):OprogramarealizaumaoperaodepotnciaXy.
#include<stdio.h>
#include<math.h>
//oarquivostdio.hinseridodentrodesteprograma
floatPOT(floatbase,floatexpoente);
floatresultado;
//prottipodafunoPOT
//varivelglobal
intmain(void)
{
floatbase,expoente;
//definiodasvariveislocais
printf("Base:");
scanf("%f",&base);
//funoquepermiteimprimirdadosnatela
// funo que permite a entrada de dados via
teclado
printf("Expoente:");
scanf("%f",&expoente);
resultado=POT(base,expoente);
//chamadadafunoPOT
printf("Resposta=%7.2f\n",resultado);
11
return(0);
}
floatPOT(floatx,floaty)
{
floatresp;
//corpodafunoPOTdefinidapeloprogramador
//osparmetrosxeysovariveislocais
resp=exp(log(x)*y);
return(resp);
//retornodafuno
}
Variveisglobais:resultado,POT
Variveislocais:base,expoente,resp,x,y
Compilarporlinhadecomandos:
$gccprog2.coprog2lm<enter>
Onde:ogeraprogramaexecutvelprog2
lmlinkaabibliotecamath.h
3.5.2Inicializaodevariveis
Em C, possvel fornecer valores iniciais a maioria das
variveis ao mesmo tempo em que elas so declaradas, colocando um
sinaldeigualeumaconstanteapsonomedavarivel.
tipo_dado_basenome_da_varivel=constante;
Exemplos:
charch='a';
chars=UCPel;
intn=0;
floaty=123.45;
//tipo_dado_basenome_da_varivel=constante_caracter
//tipo_dado_basenome_da_varivel=constante_string
//tipo_dado_basenome_da_varivel=constante_inteira
//tipo_dado_basenome_da_varivel=constante_real
3.6Constantes
Valores fixos que o programa no pode alterar. As constantes
podemserdequalquertipobsico.
Tipo
Exemplosdeconstantes
char
int
float
char*
'a' 'n' '9'

1
123 2100 234
123.23
4.34e3
"CforLinux"
(formadedefinirumastring)
3.6.1Constanteshexadecimaiseoctais
A linguaguem de programao C permite especificar constantes
inteirasemhexadecimalouoctal.Umaconstanteoctalcomeacomum0
(zero),enquantoqueumahexadecimalcomeapor0x.
Exemplos:
12
intmain(void)
{
inthexadecimal=0xFF;
intoctal=011;
//255emdecimal
//9emdecimal
Observaes:
Qualquernmerooctalformadoporoitonmeros(0..7).
Qualquer nmero hexadecimal formado por dezesseis nmeros (0
..9,A,B,C,D,E,F).
3.6.2Constantesstrings
Uma string um conjunto de caracteres delimitados por aspas
duplas. Em C no existe um tipo de dado especifico para definir uma
string.
Uma string definida como um vetor (unidimensional) de
caracteres. Toda string deve ser finalizada pelo caracter especial
\0(chamadodeNULL).
Exemplo:
chars[6]="UCPel";ouchars[6]={'U','C','P','e','l',NULL};
\0igualaNULL
0
U
1
C
2
P
3
e
4
l
5
NULL
Figura2:Vetordecaracteres
Memriaocupada:6bytes
Observao:'a'diferentede"a"
'a'ocupa1bytenamemriaRAM(dotipochar)
"a"ocupa2bytesnamemria(todastringterminadacomocaracter'\0')
ApalavraNULL(querdizernulo)estdefinidadentrodoarquivo
deheader(cabealho)stdio.h(standardinputoutput).
#defineNULL0
//s[i]==(char)NULL;ous[i]='\0';
3.6.3Constantesespeciais
As constantes especiais so usadas para representar caracteres
quenopodemserinseridospeloteclado.Soelas:
Tabela1:Constantesespeciais
Constante
\b
\f
\n
\r
\t
\
Significado
Retrocesso
Alimentaodeformulrio
Novalinha
Retornodecarro<CR>
Tabhorizontal
Aspasduplas
13
\
\o
\\
\a
\o
\x
Aspassimples
Zero
Barrainvertida
Alerta
Constanteoctal
Constantehexadecimal
3.7ComandosdoprprocessadordoC
3.7.1Ocomando#define
O comando #define usado para definir uma macrosubstituo. O
compilador substitui o identificador pelo valor cada vez que aquele
forencontradonoprogramafonteantesdacompilaodoprograma.
#defineidentificadorvalor
Exemplos:
#defineTRUE !0
#defineFALSE
//ou#defineTRUE1
#defineENTER 10
#defineESC
27
3.7.2Ocomando#include
O comando #include faz o compilador incluir um arquivofonte
dentrodeoutroarquivofonte.
#include<header.h>
ou
#include"header.h"
//arquivodeheaderpadrodoC
//arquivodeheaderescritopeloprogramador
Observaes: Normalmente os arquivos de header esto localizados em

/usr/include. E os arquivos de header do programador esto
localizadosemseudiretriocorrente/home/luzzardi/fontes,enquanto
queasbibliotecasdogccestonodiretrio/usr/lib.
Exemplos:
#include<stdio.h>
#include"luzzardi.h"
//arquivodeheaderpadrodoC(/usr/include)
//arquivodeheaderdefinidopeloprogramador
14
4.Tiposdedados
4.1Tiposbsicos
A tabela abaixo exibe os cinco (5) tipos de dados bsicos que
podemserutilizadospeloprogramadorparadefinirsuasvariveis.So
exibidos os tipos bsicos, a quantidade de bits, a faixa de valores
vlidaeonmerodebytesquecadatipodedadosocupanamemriaRAM
(memria principal) ou em disco (quando armazenados na memria
secundria).
Tabela2:Tiposdedados
Tipo
char
int
float
double
void
Bits
8
32
32
64
0
Faixadevalores
128127
214748364821474483647
3.4E383.4E+38
1.7E3081.7E+308
Semvalor
Bytes
1
4
4
8
0
4.2Modificadoresdetipo
Osmodificadoresdetiposoutilizadosparamodificarostipos
de dados base, ou seja, se adaptando s necessidades do programador.
Os modificadores modificam a quantidade de bits e bytes dos tipos
base,alterando,destaforma,afaixadevaloresdestesnovostiposde
dados.
Tabeladosmodificadoresdetipos
Tabela3:Modificadoresdetipos
Modificadordetipo
signed
unsigned
long
short
Modificao
c/sinal
s/sinal
longo
curto
Descrio
Nmerospositivosenegativos
Nmerospositivos
Aumentaonmerodebytesdotipo
Diminuionmerodebytesdotipo
Tabeladetiposbsicosmodificados
Tabela4:Tiposdedadosbsicosmodificados
Tipo
unsignedchar
signedchar
Bits
8
8
Faixadevalores
0255
128127
Bytes
1
1
unsignedint
signedint
shortint
longint
32
32
32
32
04294967295
214748364821474483647
214748364821474483647
214748364821474483647
2
2
2
4
unsignedshortint
signedshortint
unsignedlongint
signedlongint
16
16
32
32
065535
3276832767
04294967295
214748364821474483647
2
2
4
4
longdouble
64
1.7E3081.7E+308
15
5.Operadores
So smbolos especiais que obrigam o compilador a executar
determinadas operaes. Estas operaes podem ser aritmticas,
comparativasoulgicas.
5.1Operadoresaritmticos
Sooperadoresquerealizamumaoperaomatemtica.
Tabela5:Operadoresaritmticos
Operadoraritmtico
+
*
/
%
++
Ao
Subtrao
Adio
Multiplicao
Diviso
Restointeirodadiviso
Decremento/incremento
Precednciadosoperadoresaritmticos(HierarquianasOperaes)
Tabela6:Precednciadosoperadoresaritmticos
Hierarquia
1
2
3
4
5
6
Operao
Parnteses
Funes
++
(menosunrio)
*/%
+
Observao: Quando houver duas ou mais operaes de mesma hierarquia,

o compilador executaas da esquerda para a direita (veja tabela
completadeprecedncianoitem21.2).
5.2Operadoresrelacionais
So operadores que permitem comparar valores, ou seja, so
utilizadosprincipalmemteemcomandosquepossuemcondies.
Tabela7:Operadoresrelacionais
Operador
>
>=
<
<=
==
!=
Ao
Maiorque
Maiorouiguala
Menorque
Menorouigual
Iguala
Diferentede
5.3Operadoreslgicos
So operadores utilizados em comandos que tem mais de uma
condio.
16
Exemplo:
if(condio1&&condio2||condio3)
Tabela8:Operadoreslgicos
Operadorlgica
&&
||
!
Ao
AND(e)
OR(ou)
NOT(no)
Precedncia(Hierarquiadosoperadoresrelacionaiselgicos)
Tabela9:Precednciadosoperadoresrelacionaiselgicos
Hierarquia
1
2
3
4
5
Operao
!
>>=<<=
==!=
&&
||
Observao: As expresses que utilizam operadores relacionais e

lgicosretornam0(zero)parafalsoe!0(nozero)paraverdadeiro,
ouseja:
#defineTRUE
#defineFALSE
!0
0
5.4Incrementoedecremento
So operadores aritmticos que permitem realizar operaes de
somaesubtraodeformasimplificada.
++adiciona(1)aooperando
subtrai(1)aooperando
Asseguintesoperaessoequivalentes:
x++;
x;
x=x+1;
x=x1;
Observao:
Os operadores (++ ou ) podem ser colocados antes ou depois do
operando. Quando precede seu operando, C efetua a operao de
incrementooudecrementoantesdeutilizarovalordooperando.Quando
ooperadorvierdepoisdooperando,Cutilizaovalordooperandoantes
deincrementlooudecrementlo.
Exemplo:
x=10;
y=++x;
//yser11
//xser11
x=10;
//yser10
17
y=x++;
//xser11
5.5Operadordeatribuio
O operador de atribuio o sinal de igual =. A sintaxe do
operadordeatribuiopodeserescritoemumadasseguintesformas:
varivel=constante;
varivel=varivel;
varivel=expresso;
varivel=funo(x);
x=3;
x=y;
x=a+b;
x=sqrt(y);
Programaexemplo(3):Oprogramacalculaaidadedeumapessoa.
#include<stdio.h>
intmain(void)
{
intidade,ano_atual,ano_nasceu;
printf("AnoATUAL:");
scanf("%d",&ano_atual);
printf("AnodeNASCIMENTO:");
scanf("%d",&ano_nasceu);
idade=ano_atualano_nasceu;
printf("SuaIDADEeh%d\n",idade);
return(0);
}
//leituradoanoatual
//leituradoanodenascimento
//atribuioclculodaidade
A linguagem de programao C permite utilizar o operador de

atribuio em expresses, junto com operadores matemticos, lgicos,
relacionais,chamadadefunes,eoutros(comofoimencionadoacima).
if((produto=x*y)<0)
Funcionamento: Primeiramente C atribui o valor x * y a varivel
produto, para depois avaliar a expresso, ou seja, comparar se o
produtomenor(<)quezero.
5.6Ooperadorsizeof
O operador sizeof (tamanho de) retorna o tamanho (em bytes) de
umavariveloudeumtipoqueestemseuoperando.
Programa exemplo (4): O programa exibe a quantidade de bytes das
variveisetipos.
#include<stdio.h>
intmain(void)
{
intx;
chary;
x=sizeof(shortint);
//xvale2
18
printf("x>%dy>%d\n",x,sizeof(y));
return(0);
}
//sizeof(y)1
5.7Casts
possvel forar que o resultado de uma expresso seja de um
determinadotipo.Paratantodeveserutilizadoumaconstruochamada
decast,ouseja,podeserutilizadopara"tipar"umavarivelcomum
tipodiferentedoresultadodaexpresso.
varivel=(tipo)expresso;
Programa exemplo (5): O programa imprime na tela o resultado de uma
diviso.
#include<stdio.h>
intmain(void)
{
intx,y;
floatresp;
printf("x=");
scanf("%d",&x);
printf("y=");
scanf("%d",&y);
resp=(float)x/y; //necessrioumcast(float)poisadivisodedois
printf("Divisao=%.2f\n",resp);
//inteirosresultaemuminteiro
return(0);
}
Observao: Em C, o tipo resultante de um inteiro dividido por outro
inteirouminteiro,logo,deveseutilizarumcast(float)paraque
otiporesultanteatribudoavarivelrespsejafloat.
5.8Expresses
Uma expresso em C qualquer combinao vlida de operadores
(aritmticos,relacionaisoulgicos),constantes,funesevariveis.
Exemplo:
c=sqrt(a)+b/3.4;
5.8.1Conversodetiposemexpresses
Quandoumaexpressocompostadetiposdiferentes,Cconverte
todos os operandos para o tipo do maior operando. Antes, os tipos
abaixosoconvertidospara:
charconvertidoparaint
floatconvertidoparadouble
Exemplo:
19
charch;
inti;
floatf;
doubled;
floatresult;
Figura3:Conversodetiposemexpresses
20
6.Funespadres
Nolinuxnecessrioincluirabibliotecamath.Porlinhade
comandoficaassim:
$gcccalc.cocalclm<enter>
NoambientedeprogramaoanjutatemqueincluiremDefinies
... Definies de Compilao e Link... ... Bibliotecas ... m
(mathroutines)...Adicionar.
6.1abs
Afunoabsretornaovalorinteiropositivoabsoluto.
Sintaxe:intabs(intx);
Prototype:math.h
6.2fabs
Afunofabsretornaovalorrealpositivoabsoluto.
Sintaxe:floatfabs(floatx);
Prototype:math.h
6.3asin
A funo asin retorna o valor do arco seno. A varivel x deve
estaremradianos.
Sintaxe:doubleasin(doublex);
Prototype:math.h
Faixa:pi/2pi/2
6.4acos
Afunoacosretornaovalordoarcocosseno.Avarivelxdeve
estaremradianos.
Sintaxe:doubleacos(doublex);
Prototype:math.h
Faixa:0pi
6.5atan
Afunoatanretornaovalordoarcotangente.Avarivelxdeve
estaremradianos.
Sintaxe:doubleatan(doublex);
21
Prototype:math.h
Faixa:pi/2pi/2
6.6cos
Afunocosretornaovalordocosseno.Avarivelxdeveestar
emradianos.
Sintaxe:doublecos(doublex);
Prototype:math.h
Faixa:11
6.7sin
Afunosinretornaovalordoseno.Avarivelxdeveestarem
radianos.
Sintaxe:doublesin(doublex);
Prototype:math.h
Faixa:11
6.8exp
x
Afunoexpretornaovalordoexpoente(e ).
Sintaxe:doubleexp(doublex);
Prototype:math.h
6.9pow
Afunopow(power)retornaovalordapotncia(xy).
Sintaxe:doublepow(doublex,doubley);
Prototype:math.h
6.10sqrt
Afunosqrt(squareroot)retornaovalordaraizquadrada.
Sintaxe:doublesqrt(doublex);
Prototype:math.h
6.11log
Afunologretornaovalordologaritmonatural.
Sintaxe:doublelog(doublex);
22
Prototype:math.h
6.12atof
Afunoatofconvertestringempontoflutuante.
Sintaxe:doubleatof(constchar*s);
Prototype:math.h
6.13atoi
Afunoatoiconverteumastringeminteiro.
Sintaxe:intatoi(constchar*s);
Prototype:math.h
6.14atol
Afunoatolconverteumastringeminteirolongo.
Sintaxe:longintatol(constchar*s);
Prototype:math.h
6.15log10
Afunolog10retornaologartmonabase10.
Sintaxe:doublelog10(doublex);
Prototype:math.h
6.16tan
A funo tan retorna o valor da tangente. A varivel x deve
estaremradianos.
Sintaxe:doubletan(doublex);
Prototype:math.h
6.17rand
Afunorandretornaumnmeroaleatrioentre0at4294967295.
Sintaxe:intrand(void);
Prototype:stdlib.h
Faixa:04294967295
intrandom(intn)
{
23
intt;
t=rand()%n;
return(t);
}
//retornaumnmeroaleatrioentre0en1
6.18srand
A funo srand inicializa o gerador de nmeros aleatrios. No
deveserutilizadodentrodelaos.
Sintaxe:voidsrand(unsignedintsemente);
Prototype:stdlib.h
Formadeusar:srand(time(NULL));
voidrandomize(void)
{
srand(time(NULL));
}
Observa
o
:Afunotime(NULL)retornaotempoemsegundosdesde1de
janeirode1970.
6.19system
A funo system executa comandos e arquivos executveis do
sistemaoperacionallinux.
Sintaxe:intsystem(constchar*comando);
Prototype:stdlib.h
Retorna:0(ok)e1(erro)
Exemplos:
system("lsl");
system("clear");
system("ls");
system("sleep3");
//pausa
Observao:lseclearsocomandosdosistemaoperacionalLinux.
24
7.Comandos
7.1TiposdeComandos
7.1.1Seqncia
So comandos, que no fluxo de controle do programa, so sempre
executados passando a execuo para a prxima instruo, ou seja,
todos os comandos de seqncia so executados desde que eles no
dependemdeumcomandodeseleo.
Exemplo:(todasasinstruesabaixosodeseqncia)
system(clear);
//limpaatela
printf("Digiteumaletra:"); //imprimenatela
letra=getchar();
//comandodeatribuio
printf("Digiteumvalor:");
scanf("%f",&valor);
//entradadedadosviateclado
resp=valor*1.25;
//atribuioumcomandodeseqncia
Observao: A funo getchar() permite a entrada de um caracter via
teclado.necessriodigitar<enter>.
7.1.2Seleo
So comandos, que no fluxo de controle do programa, permitem a
seleo entre duas ou mais instrues, ou seja, este tipo de comando
fazcomquealgunscomandosnosejamexecutados.
Exemplo:
if(numero%2==0)
//testaseonmeroparoumpar
printf("Nmero:PAR\n");
else
printf("Nmero:MPAR\n");
ou
#include<stdio.h>
#include<math.h>
//porcausadafunofabs
intmain(void)
{
floatx,raiz;
printf(Digiteumvalor:);
scanf(%f,&x);
if(x<0)
x=fabs(x); //estainstruosexecutadaseovalordexfornegativo
raiz=sqrt(x);
printf(RaizQuadrada:%.2f\n,raiz);
return(0);
}
25
7.1.3Repetio
So comandos, que no fluxo de controle do programa, permitem a
repetiodeumaoumaisinstrues.
ProgramaExemplo(6):Oprogramaexibenatelaateclaeocdigo(ASC
II) da tecla digitada pelo usurio. O programa encerra quando o
usuriodigitaratecla<esc>(escape).
#include<stdio.h>
#defineESC 27
intmain(void)
{
chartecla;
do{
printf(Digiteumatecla:);
tecla=getchar();
printf("Tecla:%cCdigo:%d\n",tecla,tecla);
}while(tecla!=ESC);
return(0);
}
7.1.4Atribuio
Vejaitem5.5(Operadordeatribuio).
7.2Comandoif
O comando if um comando de seleo que permite selecionar um
comando entre dois outros comandos (comandos simples) ou dois
conjuntos de comandos (comandos compostos). Isto feito atravs da
avaliao de uma condio. O resultado desta avaliao (teste da
condio) pode ser verdadeiro ou falso. Dependendo deste resultado um
doscomandosexecutadoeooutrono.
Sintaxe:
if(condio)
comando1;
else
comando2;
if(condio)
comando;
ou
//todososcomandososimples
Observao:Oelseopcional.
Se a condio for avaliada como verdadeira (qualquer valor
diferentede0),ocomando1serexecutado,casocontrrio(condio
falsa, valor igual a zero) o comando 2 ser executado. Comando 1,
comando2oucomandopodemsersimplesoucompostos(quandohmaisde
um comando ligado a outro, devese utilizar chaves ({ }). Veja
exemplosabaixo
26
if(condio)
{
comando1;
comando2;
}
else
{
comando3;
comando4;
}
if(condio)
{
comando1;
comando2;
comando3;
}
//todososcomandosocompostos
Programa exemplo (7): O usurio digita um nmero e o programa diz se

esteparoumpar.
#include<stdio.h>
intmain(void)
{
intnumero;
printf("Digiteumnmero:");
scanf("%d",&numero);
if((numero%2)==0)
printf("NmeroPAR\n");
else
printf("NmeroIMPAR\n");
return(0);
}
//comandosimples
//comandosimples
7.2.1ifencadeados
Um if aninhado (ou encadeado) um comando if dentro de outro
comandoifouif...else.
Programa exemplo (8): O usurio digita um nmero e o programa diz se
estezero,positivoounegativo.
#include<stdio.h>
intmain(void)
{
intnum;
printf("Digiteumnmero:");
scanf("%d",&num);
if(num==0)
printf("Zero\n");
//comando1doprimeiroif
else
if(num>0)
printf("Positivo\n");
else
printf("Negativo\n");
//comando2doprimeiroif
27
return(0);
}
Observao:Notequenocomando2(doprimeiroif)existeoutroif.
Exemplo:
if(x)
//primeiroif
if(y)
//segundoif
printf("1");
else
printf("2");
Primeira
dvida
:Oelsepertenceaqualif?
Funcionamento: Em C o else est ligado ao if mais prximo (mais
interno),ouseja,nesteexemplooelsepertenceaosegundoif.
Segunda
dvida
:Comofazerparaqueoelse(doexemploacima)pertena
aoprimeiroif?
Resposta: Devese utilizar chaves para anular a associao normal
(vejaexemploabaixo).
Exemplo:
if(x)
{
if(y)
printf("1");
}
else
printf("2");
7.3Ocomandoswitch
Ocomandoswitch umcomandodeseleoquepermiteselecionar
um comando entre vrios outros comandos. Isto feito atravs da
comparao de uma varivel a um conjunto de constantes. Cada um dos
comandosestligadoaumaconstante.
Sintaxe:
switch(varivel)
{
caseconstante_1:seqnciadecomandos;
break;
caseconstante_2:seqnciadecomandos;
break;
.
.
.
default:seqnciadecomandos;
}
28
Oprogramatestaumavarivelsucessivamentecontraumalistade
constantes inteiras ou caracteres (int ou char). Depois de encontrar
uma coincidncia, o programa executa o comando ou bloco de comandos
queestejamassociadosquelaconstante.Ocomandodefaultexecutado
senohouvernenhumacoincidncia.
O comando break utilizado para obrigar a sada do comando
switch.
Aopodefaultopcional.
Observao: A varivel no pode ser uma string (char *) e nem real
(float).
Programaexemplo(9):Oprogramarecebeumdgitode09eimprimena
tela, este dgito, por extenso. Neste exemplo a varivel dgito
inteira.
#include<stdio.h>
intmain(void)
{
intdigito;
printf("Dgito[0..9]:");
scanf("%d",&digito);
switch(digito)
{
case0:printf("Zero\n");
break;
case1:printf("Um\n");
break;
case2:printf("Dois\n");
break;
case3:printf("Trs\n");
break;
case4:printf("Quatro\n");
break;
case5:printf("Cinco\n");
break;
case6:printf("Seis\n");
break;
case7:printf("Sete\n");
break;
case8:printf("Oito\n");
break;
case9:printf("Nove\n");
break;
default:printf("ERRO:Noumdigito\n");
}
}
29
Programa exemplo (10): Oprogramarecebeumdgitode0 9 eimprime

na tela, este dgito, por extenso. Neste exemplo a varivel dgito
caracter,porcausadistoasconstantesestoentreapostrofes.
#include<stdio.h>
intmain(void)
{
chardigito;
printf("Dgito[0..9]:");
scanf("%c",&digito);
switch(digito)
{
case'0':printf("Zero\n");
break;
case'1':printf("Um\n");
break;
case'2':printf("Dois\n");
break;
case3:printf("Trs\n");
break;
case4:printf("Quatro\n");
break;
case5:printf("Cinco\n");
break;
case6:printf("Seis\n");
break;
case7:printf("Sete\n");
break;
case8:printf("Oito\n");
break;
case'9':printf("Nove\n");
break;
default:printf("ERRO:Noumdigito\n");
}
}
Programa exemplo (11): O programa constri um menu com trs funes:
incluso,alteraoetrmino.
#include<stdio.h>
intmain(void)
{
charopcao;
printf("[I]ncluso\n");
printf("[A]lterao\n");
printf("[T]rmino\n");
printf("Qualaopo:");
opcao=getchar();
switch(opcao)
{
case'i':
30
case'I':inclusao();
break;
case'a':
case'A':alteracao();
break;
case't':
case'T':termino();
break;
default:printf("ERRO:OpoInvlida\n");
}
}
voidinclusao(void)
{
}
voidalteracao(void)
{
}
voidtermino(void)
{
}
7.4Comandowhile
O comando while um comando de repetio que permite executar
um comando (simples) ou vrios comandos (composto) diversas vezes.
Istofeitoatravsdaavaliaodeumacondio.Enquantoacondio
forverdadeiraoscomandossorepetidos.Quandoacondiosetornar
falsa o comando while finalizado. O teste da condio feita no
incio do comando, ou seja, antes que todos os comandos sejam
executados.
Observao:Notequeoscomandospodemnoserexecutadosnenhumavez,
bastaacondiocomearcomofalsa.
Sintaxe:
while(condio)
ou
while(condio)
comando;{
comando1;
comando2;
//comandosimples}
//comandocomposto
Condio:QualquerexpressovlidaemCcomresultado0(false)ou!0
(true). Na condio podem ser utilizados ainda variveis, constantes,
funes,operadores(aritmticos,relacionaiselgicos).
Funcionamento

do
comando
:Oloop(lao)repetidoenquantoacondio
for verdadeira. Quando a condio se tornar falsa o controle do
programa passa para a prxima instruo. O lao while verifica a
31
condio no incio do lao, por causa disto, normalmente, a varivel

decontroledolaodeveserinicializado.
Exemplo:
inti=0; //inicializaodavariveldecontrole
while(i<=10)
//condioi<=10
{
printf(i=%d\n,i);
i=i+1;
//incremento
}
Comando: Pode ser um comando vazio, simples ou composto que sero
repetidos.
Comandovazio:while(1);
//comandowhilenorepetenenhumcomando
for(i=0;i<=1000;i++); //comandofornorepetenenhumcomando
Verifique: Note que no final dos dois comandos (while e for) existe
apenas um pontoevrgula, isto o sinal de comando vazio, ou seja,
os comandos while e for que teriam outros comandos no os tem,
caracterizandocomandosvazios.
Problema freqente de digitao: Muitas vezes o programador insere um
pontoevrgulanofinaldeumcomandoforouwhileporengano.Isto
umgraveproblema,poisestepontoevrgula(inseridoacidentalmente)
fazcomqueoscomandosqueseriamrepetidos,noso.Vejaoexemplo
abaixo:
Exemplo:
for(x=1;x<=10;x++);
printf(x=%d\n,x);
//noteopontoevrgulanofinaldocomandofor
//impressox=11natela,porque?
Explicao: O comando printf no faz parte do comando if devido ao

pontoevrgula no comando for. O comando for termina quando a
variveldecontrolexchegaaovalor11.
Comando
correto
:for(x=1;x<=10;x++)printf(x=%d\n,x);
Programaexemplo(12):OprogramaimprimecaracteresdeAatZna
tela.
#include<stdio.h>
intmain(void)
{
charletra='A';
//inicializaodavariveldecontrole
while(letra!='Z')
{
printf("Letra:%c\n",letra);
letra++;
//incremento
}
32
}
7.5Ocomandofor
Ocomandoforumcomandoderepetioquepermiteexecutarum
comando (comando simples) ou vrios comandos (comando composto)
diversas vezes. Isto feito atravs da avaliao de uma condio.
Enquantoacondiofor verdadeiraoscomandossorepetidos.Quando
acondiosetornarfalsaocomandoforfinalizado.
Sintaxe:
for(inicializao;condio;incrementooudecremento)
comando;
Inicializao: um comando de atribuio (ou vrios, separados por

vrgula) que o compilador utiliza para inicializar a(s) varivel(is)
decontroledolao.
Condio: uma expresso qualquer, que testa a varivel de controle
dolaocontraalgumvalorparadeterminarquandoolaoterminar.
Incremento ou decremento: Define a maneira como a(s) varivel(is) de
controledolaoseroalteradasapsarepetiodolao.
Olao(for)repetidoenquantoacondioverdadeira.
Acondiosempretestadanocomeodolao.
Qualquerumadas3partesdocomandofor(inicializao;condio;
incremento)podemserqualquerexpressovlidaemC.
Programaexemplo(13):Oprogramaimprimede1at10natela.
#include<stdio.h>
intmain(void)
{
inti;
for(i=1;i<=10;i++)
printf("%d\n",i);
}
//inicializao:i=1
//condio:i<=10
//incremento:i++
Programaexemplo(14):Oprogramaimprimenatela:i=1j=9
i=2j=8
#include<stdio.h>
i=3j=7
i=4j=6
intmain(void)
{
inti,j;
for(i=1,,j=9;i!=j;i++,,j)
printf("i=%dj=%d\n",i,j);
}
Olaoforequivalenteaoseguintecomando:
inicializao;
33
while(condio)
{
comando;
incremento;
}
//oudecremento
ou
inicializao;
do{
comando;
incremento;
}while(condio);
//oudecremento
7.6Oloopdo{}while
O comando do ... while um comando de repetio que permite
executar um comando (comando simples) ou vrios comandos (comando
composto) diversas vezes. Isto feito atravs do teste de uma
condio. Enquanto a condio for verdadeira os comandos so
repetidos.Quandoacondiosetornarfalsaocomandodo...while
finalizado.Otestedacondiofeitanofinaldocomando,ouseja,
depois que os comandos so executados (Note

que

os
comandos
so

executados
pelo
menos
uma
vez
).
Sintaxe:
do{
comando;
}while(condio);
Repeteolaoenquantoacondioforverdadeira.
Testa a condio no final, fazendo com que o lao seja executado
pelomenosumavez.
Programaexemplo(15):Imprimenatelade1at10.
#include<stdio.h>
intmain(void)
{
inti=1;
do{
printf("%d\n",i);
i++;
}while(i<=10);
}
7.7Interrupodeloops
7.7.1Ocomandobreak
34
Quando o programa encontra o comando break dentro de um lao,

eleimediatamenteencerraolao,eocontroledoprogramaseguepara
oprximocomandoapsolao.
Programaexemplo(16):Oprogramaimprimenatelaatecladigitadapelo
usurioatqueeledigite<esc>.
#include<stdio.h>
#defineESC27
intmain(void)
{
chartecla;
do{
tecla=getchar();
if(tecla==ESC)
//encerraolaoquandoousurioteclarESC
break;
printf("Tecla:%c\n",tecla);
}while(1);
//laoeterno
}
7.7.2Ocomandocontinue
O comando continue em vez de forar o encerramento, fora a
prximainteraodolaoe"pula",ouseja,noexecutaocdigoque
estiverdepoisdocomandocontinue.
Programa exemplo (17): O programa imprime na tela somente os nmeros
paresde0at100.
#include<stdio.h>
intmain(void)
{
inti;
for(i=0;i<100;i++)
{
if(i%2)
continue;
printf("Par:%d\n",i);
}
}
//0par,1impar
//imprimesomentenmerospares
Nos laos while e do {} while um comando continue faz com que o

controledoprogramaexecutediretamenteotestedacondioedepois
continueoprocessodolao.
Nocasodocomandofor,oprogramaprimeiroexecutaoincremento
(ou decremento) do lao e, depois, executa o teste da condio antes
definalmentefazerolaocontinuar.
7.8Afunoexit()
35
Afunoexitabortaoprogramaemqualquersituao.
Mododeusar:
exit(0); ou
exit(!0);
36
8.Entradaesada
EmC,asentradasesadassorealizadasatravsdautilizao
das funes da biblioteca padro do C, algumas so encontradas no
arquivostdio.h.
8.1Entradaesadadoconsole
Asseguintesfunesestodefinidasemstdio.h.
Tabela10:Funesdeentradaesadaviaconsole
Funo
Efeito(Entrada)
getchar() Lumcaracterdoteclado,esperapor<enter>
putchar() Escreveumcaracternatela
scanf()
Lqualquertipodedado,esperapor<enter>
printf
Imprimenatelaqualquertipodedado
fgets()
Lumastringdoteclado(aceitaespao)
puts()
Escreveumastringnatela
8.2Entradaesadaformatada
8.2.1Sadaformatada(printf)
Sintaxe:printf("stringdecontrole",listadevariveis);
Stringdecontrole:Formadapeloscaracteresqueafunoimprimena
tela,epeloscomandosdeformatao(%c,%s,%d,%f)quedefinema
maneiracomoasvariveisseroimpressasecaracteresespeciais(\n,
\t,...).
Tabela11:Comandosdeformatao
Cdigo
%s
%d
%i
%o
%u
%x
%X
%f
%e
%g
%E
%G
%c
%%
%n
%p
Tipo
char*
int
int
int
int
int
int
float
float
float
float
float
char
nada
int*
ponteiro
Formato
String(vetordecaracteres)
Inteirodecimalcomsinal
Inteirodecimalcomsinal
Inteirooctalsemsinal
Inteirodecimalsemsinal
Inteirohexadecimalsemsinal(coma,b,c,d,e,f)
Inteirohexadecimalsemsinal(comA,B,C,D,E,F)
Valorcomsinaldaforma[]dddd.dddd
Valorcomsinaldaforma[]d.dddde[+/]ddd
Valorcomsinalnaformaeoufbaseadonaprecisodovalordado
Mesmoquee,mascomEparaexpoente
Mesmoqueg,mascomEparaexpoente
Umcaracter
Ocaracter%impresso
Armazenaonmerodecaracteresescritosatomomento
imprimecomoumponteiro
Flags(Bandeiras):
() Alinha o resultado esquerda. Preenche o restante do campo com brancos. Se

no colocado, alinhaoresultado direita epreenche o restante esquerda
comzerosoubrancos.
(+) Oresultadosemprecomeacomosinal+ou
(#)Especificaqueoargumentoserimpressousandoumadasformasalternativas
37
Formasalternativas:
0
xouX
colocadozeros(0)antesdoargumento
colocado0x(ou0X)antesdoargumento
Especificadoresdelarguradocampoaserimpresso(exemplos):
Tabela12:Especificadoresdelarguradocampo
Prefixo
%+#0
%+#
%+0
%+
%#0
%#
%0
%
%+#0
%+#
%+0
%+
%#0
%#
%0
%
6d
+00555
+555
+00555
+555
000555
555
000555
555
+00555
+555
+00555
+555
000555
555
000555
555
6o
01053
01053
01053
1053
001053
01053
01053
1053
01053
01053
01053
1053
001053
01053
001053
1053
8x
0x0022b
0x22b
000022b
22b
0x00022b
0x22b
0000022b
22b
0x0022b
0x22b
000022b
22b
0x00022b
0x22b
0000022b
22b
10.2e
+5.50e+000
+5.50e+000
+5.50e+000
+5.50e+000
05.50e+000
5.50e+000
05.50e+000
5.50e+000
+5.50e+000
+5.50e+000
+5.50e+000
+5.50e+000
05.50e+000
5.50e+000
05.50e+000
5.50e+000
10.2f
+000005.50
+5.50
+000005.50
+5.50
0000005.50
5.50
0000005.50
5.50
+000005.50
+5.50
+000005.50
+5.50
0000005.50
5.50
0000005.50
5.50
8.2.2Entradaformatada(scanf)
Sintaxe:scanf("stringdecontrole",listadevariveis);
String de controle: Local onde definido o tipo de dado (%d, %c, %s,
&f, ...) que ser lido pelo teclado (no deve conter mais nenhum
caracter).
Lista de variveis: Nome da(s) varivel(is) que ser(o) lida(s) pelo
teclado.
Observao:Deveserpassadooendereodoargumentoaserlido.
intx;
scanf(%d,&x);
Programa exemplo (18): O programa permite a entrada (via teclado) do
nome,idadeesalriodeumapessoa.
#include<stdio.h>
intmain(void)
{
intidade;
floatsalario;
charnome[40];
printf("Qualseunome:");
scanf("%s",nome);
printf("Idade:");
scanf("%d",&idade);
//ATENO:nomeigualao&nome[0]
//scanfnoaceitaespaos
//&idadeoendereodavarivelidade
38
printf("Salrio:");
scanf("%d",&salario);
}
//&salriooendereodavarivelsalrio
ScanSet: Funciona como uma entrada seletiva de caracteres na funo

scanf.Vejaoprogramaexemploabaixo:
#include<stdio.h>
intmain(void)
{
chars[256]="",str[256]="";
scanf("%[aeiou]",s);
//lapenasasvogaisaeiou
printf("String(s):%s\n",s);
scanf("%[^AZ]",str);
//NolcaracteresmaisculosdeAZ
printf("String(str):%s\n",str);
return(0);
}
Modificadoresdeformato:
chars[31];
scanf(%30s,s);
//Copiaapenas30caracteresparas
8.2.3Leituradestrings(fgets)
Sintaxe:fgets(char*string,inttam,FILE*fp);
String de controle: Local onde definido o tipo de dado (%d, %c, %s,
&f, ...) que ser lido pelo teclado (no deve conter mais nenhum
caracter).
Lista de variveis: Nome da(s) varivel(is) que ser(o) lida(s) pelo
teclado.
#include<stdio.h>
intmain()
{
charstr[31];
printf("Digiteseunome:");
fgets(str,30,stdin);
puts(str);
return(0);
}
//stdinaentradapadro(teclado)
//putsimprimenatelaumastring
Observao: stdin (entrada), stdout (sada) e stderr (erro) so

arquivosespeciaisquesoabertosparacadaprogramaqueexecutado.
8.3Sadanaimpressora(fprintf)
Sintaxe:fprintf(stdprn,"stringdecontrole",listadevariveis);
39
stdprn:Filadeimpresso(standardprinter)
Programaexemplo(19):OprogramaimprimeUCPelnaimpressora.
#include<stdio.h>
intmain(void)
{
fprintf(stdprn,"UCPelUniversidadeCatlicadePelotas\n");
}
Observao:
//Saltaumapginanaimpressora
fprintf(stdprn,"%c\n",12);
//Comprimeoscaracteresnaimpressora
fprintf(stdprn,"%c\n",15);
40
9.Controledovdeoeteclado
9.1Bibliotecancursesmodotexto
Nolinuxparalimparatela,posicionarocursor,colorirtexto,
dentreoutrasfunes,podeseserutilizadaabibliotecancurses.O
programa exemplo 78 mostra o uso desta biblioteca atravs da
implementaodeumjogodecaapalavras.
Figura4:JogodeCaaPalavras
No linux necessrio incluir a biblioteca curses. Por linha
decomandoficaassim:
$gccpalavras.copalavraslcurses<enter>
...DefiniesdeCompilaoeLink......Bibliotecas...curses
(Screenhandlingandoptimizationroutines)...Adicionar.
Tutorial
da
biblioteca
ncurses
:
http://www.del.ufrj.br/~pcfilho/ncurses/ncurses.htm
Vejamaisdetalhesdabibliotecancursesnocaptulo20.
41
10.Listadeexerccios(comandos)
10.1 Escreva um programa em C que recebe dois valores via teclado:
cateto adjacente (b) e cateto oposto (a) e calcula o valor da
hipotenusadadopelaseguintefrmula:
Frmula:h2=a2+b2
Exemplo(Tela):
Catetoadjacente(b):3<enter>
Catetooposto(a):4<enter>
Hipotenusa:5
10.2EscrevaumprogramaemCquel4notasviateclado:n1,n2,n3e
n4obtidasporumalunoem4avaliaes.Calculeamdiautilizandoa
seguintefrmula:
n1+n2*2+n3*3+n4
Mdia=
7
Aseguirimprimanatelaamdiaeoconceitodoalunobaseadonaseguintetabela:
Mdia
9,0ouacimade9,0
entre7,5(inclusive)e9,0
entre6,0(inclusive)e7,5
abaixode6,0
Conceito
A
B
C
D
10.3 Escreva um programa em C que recebe via teclado: comprimento da

circunferncia.Oprogramadevecalculareimprimirnatelaodimetro
eoraiodacircunferncia(vejaexemploabaixo).
Exemplo:
Comprimentodacircunferncia:36<enter>
Dimetro:11.46
Raio:5.73
Continua[S/N]?N<enter>
comprimentodacircunferncia=2.PI.raio
dimetro=2.raio
Observao:OprogramaterminaquandoousuriodigitarN ou nnapergunta:Continua
[S/N]?
10.4DesenvolvaumprogramaemCquerecebeviateclado:pesodacarne
que ser vendida (em quilos) e preo por quilo. O programa deve
calculareimprimirnatelaototalapagar,ovalorpagoaoICMS(17%)
eolucrolquidodoaougue.
Exemplo(Tela):
Peso:3.5<enter>
42
PreoporKg(R$):4.90<enter>
Totalapagar:17.15
ICMS(17%):2.91
Lucrolquidodoaougue(R$):14.24
Sair[S/N]?n<enter>
Peso:1.5<enter>
PreoporKg(R$):9.00<enter>
Totalapagar:13.5
ICMS(17%):2.29
Lucrolquidodoaougue(R$):11.21
Sair[S/N]?S<enter>
10.5 Escreva um programa em C que recebe via teclado: tipo de animal

[1] Gado, [2] Eqinos ou [3] Ovinos, preo unitrio do animal e
quantidadedeanimaiscomprados.Oprogramadevecalculareimprimirna
tela:preototalpagoeacomissodoescritrioderemate(gado5%,
eqinos7%eovinos3%),conformeexemploabaixo:
Exemplo(Tela):
Tipodeanimal[1]Gado,[2]Eqinosou[3]Ovinos:1<enter>
Preounitriodoanimal(R$):200<enter>
Quantidadedeanimais:10<enter>
Preototalpago(R$):2100.00
Comissoapagar(R$):100.00
Continua[S/N]?s<enter>
Tipodeanimal[1]Gado,[2]Eqinosou[3]Ovinos:2<enter>
10.6 Reescreva o programa anterior recebendo via teclado uma letra

paraotipodeanimal[G]ado,[E]qinosou[O]vinos,preounitriodo
animal e quantidade de animais comprado. O programa deve calcular e
imprimirnatela:preototalpagoeacomissodoescritrioderemate
(gado:5%,eqinos:7%eovinos:3%),conformeexemploabaixo:
Exemplo(Tela):
Tipodeanimal[G]ado,[E]qinosou[O]vinos:g<enter>
10.7EscrevaumprogramaemCquerecebeviateclado:adata

de
hoje
da
seguinte forma: dia, ms, ano ea suaidade, da seguinte forma: anos,
meses e dias vividos. O programa deve calcular e imprimir a data de
nascimentonoseguinteformato:dd/mm/aaaa.
Exemplo(Tela):
Qualadatadehoje:
Dia:16<enter>
Ms:6<enter>
Ano:2003<enter>
43
Qualasuaidade:
Anos:41<enter>
Meses:4<enter>
Dias:6<enter>
DatadeNascimento:10/02/1962
Continuar[S/N]?s<enter>
10.8EscrevaumprogramaemCquerecebeviatecladoumnmerointeiro
de 0 99. O programa deve imprimir na tela este nmero por extenso
(conformeexemploabaixo).Oprogramaterminaquandoousuriodigitar
0(zero).
Exemplo:
Nmero[0..99]:23<enter>
Vinteetrs
Quarentaecinco
10.9 Escreva um programa em C que recebe via teclado: quantidade de

litrosvendidos,tipodecombustvel([A]lcool,[G]asolinaou[D]iesel)
eotipodepagamento([P]razoou[V]ista).Oprogramadevecalculare
imprimirnatela:totalprazo,descontoeototalvista.Oprograma
termina quando o usurio digitar 'N' ou 'n' na pergunta "Continua
[S/N]?".
Teladeexecuo:
Valores:
Quantidadedelitros?50<enter>
lcool1,23
Tipodecombustvel[A]lcool,[G]asolinaou[D]iesel?G<enter>Gasolina2,19
Tipodepagamento[P]razooua[V]ista?V<enter>
Diesel1,46
Totalprazo(R$):109.50
Desconto(R$):5.48
Descontovista:5%
Totalvista(R$):104.02
10.10 Escreva um programa em C que recebe via teclado duas notas:

nota1enota2.Oprogramadeveimprimirnatelaamdia,oconceitodo
aluno (dado pela tabela abaixo) e a situao (aprovado, exame ou
reprovado):
Conceito
A
B
C
D
Mdia
9,010,0
7,08,9
6,06,9
0,05,9
Nota1+Nota2
Mdia=
2
Situao
Aprovado
Aprovado
Exame
Reprovado
Exemplo:
Nota1:7<enter>
Nota2:8<enter>
Mdia:7.5
Conceito:B
Situao:Aprovado
Sair[S/N]?s<enter>
Observao: O programa termina quando o usurio digitar S ou s na pergunta: Sair

[S/N]?
44
10.11EscrevaumprogramaemCquerecebeviatecladoumatemperaturae
o tipo de converso (converter para: [C]elsius ou [F]ahrenheit).
Calcule e imprima na tela a temperatura correspondente a solicitao
dousurio,conformeexemplosabaixo:
Exemplo:
Temperatura:30<enter>
Tipodeconverso(convertepara:[C]elsiusou[F]ahrenheit):F<enter>
TemperaturaemFahrenheit:86
Continua[S/N]?S<enter>
Temperatura:86<enter>
Tipodeconverso(convertepara:[C]elsiusou[F]ahrenheit):C<enter>
TemperaturaemCelsius:30
Continua[S/N]?n<enter>
Frmula:C
9.=F32
5
10.12 Escreva um programa em C que recebe via teclado: graus (0

360),minutos(059)esegundos(059).Oprogramadevecalculare
imprimirnatelaonguloemgraus,dadopelaseguintefrmula:
Exemplo:
minutossegundos
ngulosemgraus=graus++
603600
Graus:45<enter>
Minutos:45<enter>
Segundos:45<enter>
nguloemGraus:45.76
Continua[S]imou[N]o?S<enter>
Graus:45<enter>
Minutos:10<enter>
Segundos:15<enter>
nguloemGraus:45.17
Continua[S]imou[N]o?N<enter>
Observao:Imprimirmensagensdeerroseosvaloresdeentradaestiveremforadafaixa:
ERRO:
Graus
fora
da
faixa
,ERRO:
Minutos
fora
da
faixa
ouERRO:
Segundos
fora
da
faixa
.
10.13 Escreva um programa em C que recebe via teclado: sexo

([M]asculino ou [F]eminino), altura e peso da pessoa. O programa deve
calcular e imprimir na tela: peso ideal, diferena de peso e situao
(MAGRO,IDEALouGORDO)(conformeexemploabaixo):
Exemplo:Sexo[M]asculinoou[F]eminino:M<enter>
Altura:1.65<enter>
Peso:92<enter>
PesoIdeal:62.0
DiferenadePeso:30.0
Situao:GORDO
45
PIM=72,7xaltura58
PIF=62,1xaltura44,7
Sair[S/N]?s<enter>
MAGROIDEAL
GORDO
||
5%
pi
5%
[S/N]?
46
11.Vetores,matrizesestrings
Um vetor uma coleo de variveis de mesmo tipo (agregados
homogneos) que so referenciadas pelo mesmo nome, utilizandose um
ndiceparadiferencialos.
Umvetorconsisteemlocaescontguasdememria,ouseja,os
elementos encontramse em seqncia (contigidade fsica). O menor
endereo corresponde ao primeiro elemento, e o maior corresponde ao
ltimoelemento.
Umavantagemnautilizaodeumavetorpoderarmazenarvrios
valores (elementos), na memria RAM, ao mesmo tempo, permitindo, por
exemplo,comparloseclassificlos.
Exemplo:Vetorunidimensionaldeinteiros(idades).
Tabela16:Exemplodeumvetorunidimensional
ndice
Valor
0
24
1
12
2
36
3
41
11.1Vetores
Vetor (matriz de uma dimenso 1D) um tipo especial de
matriz que possui apenas um ndice, ou seja, permite armazenar
variveisunidimensionais(permiterepresentarumatabela).
tipo_dos_dadosnome_do_vetor[nmero_de_elementos];
Onde:
tipo_dos_dados: tipo de dado de cada elemento (char, int, float,
double).
nome_do_vetor:nomedavarivelqueirrepresentarovetor
nmero_de_elementos:nmerototaldeelementosdovetor
primeiroelemento:0
ltimoelemento:nmero_de_elementos1
nmerodebytesocupadosnamemriaRAM:
nmero_de_elementosxquantidade_de_bytes_de_um_elemento
Exemplo:intx[10];
//10elementos:x[0]x[9]
primeiroelemento:x[0]
ltimoelemento:x[nmero_de_elementos1],ouseja,x[9]
nmerodebytes:10x2=20bytes(uminteiroocupa2bytes)
Observao: O programador deve verificar os limites do vetor, pois o
compilador C no verifica estes limites, ou seja, o programador pode
referenciar qualquer elemento do vetor, inclusive um que no existe.
Istopodecausarumgraveerro,travaroprograma.
47
11.2Strings
Umastring(cadeiadecaracteres)umtipodedadoqueconsiste
deumconjuntodecaracteres.Umastringpodearmazenarqualquertipo
decaractervlidodatabelaASCII.
ASCII:AmericamStandardCodeforInformationInterchange.
url:http://www.asciitable.com
Em C, uma string consiste em um vetor de caracteres finalizado
porumzero.Umzerorepresentadocomo(char)NULL.
Observao: Na inicializao de uma constante string "teste", por
exemplo, no necessrio acrescentar o NULL, pois o compilador faz
issoautomaticamente.
charstring[]=teste;
Observao: Note que no exemplo acima, no foi necessrio especificar
o nmero_de_elementos da string. O compilador C interpreta que o
tamanho da string a quantidade de caracteres da inicializao (5)
maisum(1)paraoNULL,totalizandomnestecaso,seis(6)elementos.
Isto um problema se quisermos (mais tarde) acrescentar mais
caracteres na varivel string, pois no foi reservado espao
prviamenteparaestesnovoscaracteres.
11.3Matrizes(Multidimensional)
tipo_dos_dadosnome_varivel[tamanho_1][tamanho_2]...[tamanho_n];
Exemplo:floaty[5][5];
//matriz2D
Paraacessaroelemento3,4damatrizy,deveseescrevery[3]
[4].Notequeoprimeiroelementoy[0][0]eoltimoelementoy[4]
[4].Ototaldeelementos25.
11.4Vetordestrings
Para criar um vetor de strings, devese utilizar uma matriz
bidimensional de caracteres, onde o tamanho do ndice esquerdo
determinaonmerodestringseotamanhodondicedireitoespecifica
ocomprimentomximodecadastring.
Exemplo:charnome[3][8];
0
1
2
Tabela17:Exemplodeumvetordestrings
0
1
2
3
4
5
6
U
C
P
e
l
NULL
lixo
U
C
S
NULL
lixo
lixo
lixo
U
P
e
l
NULL
lixo
F
48
7
lixo
lixo
lixo
Criaumvetorcom3stringscom7caracteres+'\0'(NULL)cada
uma. Para acessar uma string particular devese especificar apenas o
ndiceesquerdo,ouseja,nome[0],nome[1]ounome[2].
nome[0]>UCPel
nome[1]>UCS
nome[2]>UFPel
Observao: Podese acessar tambm qualquer caracter de qualquer uma
das strings, isto feito utilizando os dois ndices, como por
exemplo,nome[2][1]caracterF.
11.5Inicializaodematrizesevetores
tipo_dos_dadosnome_matriz[tam_1]...[tam_n]={lista_valores};
lista_valores: lista de constantes separadas por vrgulas que so
compatveisemtipocomotipobasedamatriz.
Exemplo:
inti[10]={0,1,2,3,4,5,6,7,8,9};
ou
inti[]={0,1,2,3,4,5,6,7,8,9};
//vetori1D
Observao: Quando um vetor declarado e inicializado (ao mesmo

tempo) o nmero de elementos (neste caso 10) pode ser suprimido, ou
seja,nestecasoopcional(vejaexemploanterior).
11.6Inicializaodeumvetordecaracteres
charnome_vetor[tamanho]="string";
Exemplo:
charstr[4]="sim";
0
s
1
i
2
m
3
NULLou'\0'
11.7Inicializaodematrizesmultidimensionais
inty[4][2]={{1,1},{2,4},{3,9},{4,16}};
y[0][0]=1
y[0][1]=1
y[1][0]=2
y[1][1]=4
y[2][0]=3
y[2][1]=9
y[3][0]=4
y[3][1]=16
11.8Inicializaodevetoresematrizessemtamanho
Na inicializao de uma matriz (ou vetor), se no for
especificado seu tamanho, ento o compilador C cria uma matriz (ou
49
vetor) grande o suficiente para conter todos os inicializadores

presentes.
Exemplo:
chars[]="UCPel";
//socupa6bytes
Programaexemplo(23):Oprogramapermitearmazenarnnomeseidadesem
doisvetores.
#include<stdio.h>
#include<string.h>
#defineMAX10
intmain(void)
{
charnome[MAX][41];
intidade[MAX];
inti,n;
charch;
i=0;
do{
printf("Nome:");
scanf("%s",nome[i]);
//entradadeumnome(somenteumnome)
fflush(stdin);
//limpaobufferdeentrada
printf("Idade:");
scanf("%d",&idade[i]);
//entradadeumaidade
i++;
printf("Continua[S/N]?");
do{
ch=getchar();
}while(ch!='S'&&ch!='s'&&ch!='N'&&ch!='n');
}while(ch!='N'&&ch!='n'&&i<MAX);
n=i1;
//nmerodeelementos
for(i=0;i<=n;i++)
printf("|%41s|%d|\n",nome[i],idade[i]);
}
Programaexemplo(24):Oprogramarealizaasomadeduasmatrizes(Ae
B)bidimensionais,gerandoumamatrizresultanteC.
#include<stdio.h>
#defineMAX10
intmain(void)
{
inta[MAX][MAX],b[MAX][MAX],c[MAX][MAX];
intcol,lin,j,m,n;
printf("InformeaORDEMdaMATRIZ:(mxn)\n");
do{
printf("Nmerodelinhas(m):");
scanf("%d",&m);
}while(m<1||m>MAX);
//mde110
do{
printf("Nmerodecolunas(n):");
scanf("%d",&n);
50
}while(n<1||n>MAX);
//nde110
for(lin=1;lin<=m;lin++)
for(col=1;col<=n;col++)
{
printf("A[%d,%d]=",lin,col);
scanf("%d",&a[lin][col]);
printf("B[%d,%d]=",lin,col);
scanf("%d",&b[lin][col]);
}
printf("\n");
for(lin=1;lin<=m;lin++)
for(col=1;col<=n;col++)
{
c[lin][col]=a[lin][col]+b[lin][col];
printf("C[%d,%d]=%d\n",lin,col,c[lin][col]);
}
}
11.9Classificaodedadosouordenao(sort)
Paraexemplificarmelhorasvariveisdotipovetor,abaixoso
mostrados dois tipos de ordenao, tambm chamado sort (classificao
dedados):
Programa exemplo (25): O programa classifica os nomes digitados pelo
usurio.
#include<stdio.h>
#include<ctype.h>
#include<string.h>
#defineQUANT50
intmain(void)
{
charnome[QUANT][41];
chartemp[41];
inti,j,n;
chartecla;
n=1;
do{
n++;
printf("Nome:");
scanf(%40s,&nome[n]);
//scanfpermiteaentradadeumnome
do{
tecla=toupper(getchar()); //toupper:converteocaracterparamaisculo
}while(!strchr(SN,tecla));//strchr:verificaseocaracterpertencestring
}while(tecla!='N'&&n<QUANT);
for(i=0;i<=n1;i++)
for(j=i+1;j<=n;j++)
if((strcmp(nome[i],nome[j]))>0)
{
strcpy(temp,nome[i]);
strcpy(nome[i],nome[j]);
strcpy(nome[j],temp);
}
printf("\nNomesORDENADOS\n");
for(i=0;i<=n;i++)
51
//strcmppermitecompararstrings
//strcpypermitecopiarstrings
printf("Nome:%s\n",nome[i]);
}
Observao: As funes strcpy, strcmp e strchr so discutidas na

prximaseo.
Programa exemplo (26): O programa utiliza um mtodo de sort chamado
bubblesort(mtodo
da
bolha
)paraclassificarnomes.
#include<stdio.h>
#include<string.h>
#defineTRUE
#defineFALSE
!0
0
#defineQUANT50
intmain(void)
{
charnome[QUANT][40];
chartemp[40],tecla;
inti,k,n;
intsort;
n=0;
do{
printf("Nome:");
scanf(%s,nome[n]);
//entradadeumnome
n++;
do{
tecla=getchar();
}while(!strchr(SsNn,tecla));
}while(strchr(Ss,tecla)&&n<QUANT);
n=n1;
//nonmerodeelementos
k=n;
do{
sort=FALSE;
for(i=0;i<k;i++)
if((strcmp(nome[i],nome[i+1]))>0)
{
strcpy(temp,nome[i]);
strcpy(nome[i],nome[i+1]);
strcpy(nome[i+1],temp);
sort=TRUE;
}
k;
}while(sort);
printf("\nNomesORDENADOS:\n");
for(i=0;i<=n;i++)
printf("Nome:%s\n",nome[i]);
}
11.10Listadeexerccios(vetores)
52
Bublesort
11.10.1EscrevaumprogramaemCquerecebeviatecladoumconjuntode
letras (mximo 20). Armazene todas as letras em um vetor (letras) at
que o usurio digite um ESC (cdigo 27). Logo aps copie todas as
letras (em ordem inversa) para outro vetor (inverso). Ao final imprima
osdoisvetores.
letras
0
2
L
M
0
Exemplo:
inverso
0
D5A
7B
Letra:L<enter>
Letra:I<enter>
Letra:M<enter>
Letra:A<enter>
Letra:<esc>
LIMA
AMIL
11.10.2 Escreva um programa em C que recebe via teclado: nmero de

idades(mximo50)easrespectivasidades.Armazenetodasasidadesem
um vetor (idade). Logo aps a entrada de todas as idades, o programa
devereceberviateclado:idadeparaconsulta.Oprogramadeveimprimir
na tela, o nmero de idades antes da idade de consulta e o nmero de
idadesdepoisdaidadedeconsulta.
Exemplo:
Nmerodeidades:6<enter>
Idade:30<enter>
Idade:60<enter>
Idade:10<enter>
Idade:50<enter>
Idade:20<enter>
Idade:40<enter>
Idadeparaconsulta:50<enter>
Antes:3
Depois:2
Continua[S/N]?n<enter>
11.10.3EscrevaumprogramaemCquerecebeviatecladoumconjuntode
nmeros inteiros(mximo50).Armazenetodososnmerosinteirosemum
vetorat queo usuriodigite0 (zero).Logoapspermita ao usurio
consultarumnmeroinformandooseuvalor.Oprogramadeveimprimirna
tela a posio do nmero no vetor ou ERRO: Nmero no encontrado (veja
exemplosabaixo):
Exemplo:Nmero:50<enter>
Nmero:30<enter>
Nmero:20<enter>
Nmero:10<enter>
Nmero:40<enter>
Nmero:0<enter>
Valor:20<enter>
Posionovetor:2
Valor:40<enter>
Posionovetor:4
Valor:60<enter>
ERRO:Nmeronoencontrado
Valor:0<enter>
Observao:Oprogramaterminaquandoousuriodigitar0(zero).
53
11.10.4 Escreva um programa em C que recebe via teclado "n" conceitos

(A, B, C, D e E) (mximo 25) at que o usurio digite ESC. Armazene
todososconceitosemumvetor(conceito).Imprimanatelaonmerode
alunos:aprovados(A,BeC),reprovados(D)eosinfreqentes(E).
Exemplo:
Conceito:B<enter>
Conceito:A<enter>
Conceito:E<enter>
Conceito:B<enter>
Conceito:D<enter>
Conceito:C<enter>
Conceito:A<enter>
Conceito:E<enter>
Conceito:<esc>
4Aprovado(s)
1Reprovado(s)
3Infreqente(s)
11.10.5 Escreva um programa em C que recebe via teclado n (mximo

50) nomes (mximo 80 letras). A entrada dos nomes termina quando o
usuriodigitarapenas<enter>.Logoapsaentradadetodososnomes
o programa deve permitir a entrada via teclado de uma letra. O
programadeveimprimirnatelatodososnomesquecomeamcomaletra
especificadapelousurio.Oprogramaterminaquantoousuriodigitar
<esc>naentradadaletra(conformeexemplosabaixo):
Exemplo:
Nome:Paulo<enter>
Nome:Roberto<enter>
Nome:Renato<enter>
Nome:Pedro<enter>
Nome:Fabio<enter>
Nome:<enter>
Letra:R<enter>
Nome:Roberto
Nome:Renato
Letra:P<enter>
Nome:Paulo
Nome:Pedro
Letra:T<enter>
Letra:<esc>
11.10.6 Escreva um programa em C que recebe via teclado n (mximo

30) nomes (mximo 40 letras) e idades. A entrada dos dados termina
quando o usurio digitar 'N' ou 'n' na pergunta "Continua [S/N]?".
Logoapsaentradadetodososdadosoprogramadeveimprimirnatela
todososnomeseidadesdesdeomaisvelhoatomaisnovo.
Exemplo:
Nome:Ana<enter>
Idade:12<enter>
Nome:Beatriz<enter>
Idade:13<enter>
Nome:Carla<enter>
Idade:14<enter>
Carla
14
Beatriz
13
Ana
12
54
12.Manipulaodestrings
Asfunesstrcpy,strcmp,strcatsonecessriaspoisumastring
nada mais do que um vetor de caracteres, ou seja, no se pode
atribuir vrios valores (ao mesmo tempo) para os elementos de um
vetor. Isto s pode ser feito quando o vetor declarado e
inicializadoouumdecadavez.
Exemplo:chars[]=UCPel;
//correto
ou
s[0]=U;
s[1]=C;
s[2]=P;
s[3]=e;
s[4]=l;
s[5]=NULL;
//corretoelementoporelemento
ou
s=UCPel;
//incorretoerroGRAVEemC
12.1strcpy
Afunostrcpy (cpiadestring) prdefinidadoC quepermite
copiarumastringparaoutraouinicializarumastring.
Sintaxe:char*strcpy(char*destino,constchar*origem);
Prototype:string.h
Funcionamento:Astringdeorigemcopiadaparaastringdestino.
Programa exemplo (27): Os programas abaixo mostram como copiar
caracteresparaumastring.
#include<stdio.h>
#include<string.h>
intmain(void)
{
charerro[]="ArquivonoExiste\n";
printf("ERROFATAL:%s",erro);
}
ou
#include<stdio.h>
intmain(void)
{
charerro[20];
strcpy(erro,"Arquivonoexiste\n");
55
printf("ERROFATAL:%s",erro);
}
12.2strcmp
A funo strcmp (comparao de duas strings) prdefinida do C
quepermitecompararduasstrings.
s1maiorques2
resultado>0
s1menorques2
resultado<0
s1igualas2
resultado==0
s1diferentedes2resultado!=0
Sintaxe:intstrcmp(constchar*s1,constchar*s2);
Prototype:string.h
Programaexemplo(28):Oprogramacomparaduasstrings.
#include<stdio.h>
#include<string.h>
intmain(void)
{
chars1[41],s2[41];
printf("String1:");
scanf(%s,s1);
printf("String2:");
scanf(%s,s2);
if(strcmp(s1,s2)==0)
printf("String1IGUALaString2");
else
if(strcmp(s1,s2)>0)
printf("String1MAIORaString2");
else
printf("String1MENORaString2");
}
12.3strcat
Afunostrcat(concatenaodeduasstrings)prdefinidadoC
quepermiteaconcatenaodeumastringnofinaldaoutrastring.
Sintaxe:char*strcat(char*destino,constchar*origem);
Prototype:string.h
Funcionamento: A string origem copiado para o final da string
destino.
Programa exemplo (29): O programa cpia e concatena caracteres a uma
stringresultandonapalavraPelotas.
56
#include<stdio.h>
#include<string.h>
intmain(void)
{
chars1[]="Pel",s2[]="ota",s3[]="s";
charsr[15]="";
printf("%s\n",s1);
printf("%s\n",s2);
printf("%s\n",s3);
strcpy(sr,s1);
strcat(sr,s2);
strcat(sr,s3);
printf("%s\n",sr);
}
//sr="Pel"
//sr="Pelot"
//sr="Pelotas"
12.4strlen
A funo strlen (comprimento de uma string) prdefinida do C
que retorna o comprimento de uma string, ou seja, a quantidade de
caracteresqueastringpossuinomomento.
Observao:ONULLnocontado.
Sintaxe:intstrlen(constchar*s);
Prototype:string.h
Programa exemplo (30): O programa imprime na tela a quantidade de
caracteresdeumavarivelstring,nestecaso,avarivelnome.
#include<stdio.h>
#include<string.h>
intmain(void)
{
charnome[41];
printf("Qualoseunome:");
scanf(%s,nome);
printf("%sseunometem%dcaracteres\n",nome,strlen(nome));
}
12.5strchr
Afunostrchr (Verifica se um caracter pertence auma string)
prdefinida do C que verifica se um caracter (chr) pertence a uma
string(str).
Sintaxe:intstrchr(constchar*s,charch);
Prototype:string.h
Programa exemplo (31): O programa imprime na tela o nmero de
caracteresdeumnome.
57
#include<stdio.h>
#include<string.h>
intmain(void)
{
charnome[41];
charch;
do{
printf("Qualoseunome:");
fgets(nome,40,stdin);
printf("Seunometem%dcaracteres\n",strlen(nome));
printf("Continua[S]imou[N]o?");
do{
ch=getchar();
}while(!strchr("SsNn",ch));
}while(strchr("Ss",ch));
}
12.6Listadeexerccios(strings)
12.6.1EscrevaumprogramaemCquerecebeviatecladoumnome(mximo
256caracteres).Logoapsaentradadonomeimprima:nmerodeletras
maisculas, nmero de letras minsculas,nmero de vogaiseonmero de
consoantes,conformeexemploabaixo:
Exemplo:
Nome:UniversidadeCatlicadePelotas<enter>
(3)Letrasmaisculas
(26)Letrasminsculas
(14)Vogais
(15)Consoantes
12.6.2 Escreva um programa em C que recebe via teclado uma palavra

(mximo40caracteres)eumaletra.Logo apsaentradadonomeeda
letraimprimaonmerodeletrasqueexistenonomeouERRO:Noexiste
aletra(?)napalavra(?),conformeexemploabaixo:
Exemplo:
Palavra:Luzzardi<enter>
Letra:z<enter>
2letra(s)
Continua[S]imou[N]o?S<enter>
Palavra:Luzzardi<enter>
Letra:w<enter>
ERRO:Noexistealetra(w)napalavra(Luzzardi)
Continua[S]imou[N]o?N<enter>
Observao: O programa deve ser encerrado quando o usurio digitar N ou n na

pergunta:Continua[S]imou[N]o?.

(mximo 20 letras) e uma posio. O programa deve imprimir na tela, a
letra antecessora, a letra (da referida posio) e a letra sucessora,
conformeexemploabaixo:
Exemplo:
Palavra:Universidade<enter>
58
Posio:7<enter>
Antecessora:s
Letra:i
Sucessora:d
Observao: O programa deve imprimir na tela as seguintes mensagens de erro, se for o
caso:Letraantecessoranoexiste,LetrasucessoranoexisteouPosioinvlida.
80 letras). O programa deve imprimir, na tela, as palavras do nome em
ordem
inversa,
uma
por
linha
,conformeexemploabaixo:
Exemplo:Nome:PauloRobertoGomesLuzzardi<enter>
Luzzardi
Gomes
Roberto
Paulo
12.6.5 Escreva um programa em C que recebe via teclado um nome

(mximo 60 caracteres). Logo aps a entrada do nome o programa deve
imprimir(EMLETRAMAISCULA)osobrenomedapessoa,conformeexemplos
abaixo:
Exemplo:
Nome:PauloRobertoGomesLuzzardi<enter>
Sobrenome:LUZZARDI
Sair[S/N]?N<enter>
Nome:RenatoSouza<enter>
Sobrenome:SOUZA
Sair[S/N]?s<enter>

[S/N]?
80caracteres).Logo apsaentradadonomeoprogramadeveimprimir
na tela: sobrenome, primeiro nome e demais nomes abreviados, conforme
exemplosabaixo:
Exemplo:
Autor:Luzzardi,PauloR.G.
Sair[S/N]?N<enter>
Nome:RenatoLimaSouza<enter>
Autor:Souza,RenatoL.
Sair[S/N]?s<enter>

[S/N]?
12.6.7 Escreva um programa em C que recebe via teclado o nome de um

estado (mximo 80 caracteres). Logo aps a entrada do nome do estado
imprima: a sigla do estado (2 letras maisculas), conforme exemplos
abaixo:
Exemplo:
Estado:RioGrandedoSul<enter>
Sigla:RS
Estado:sopaulo<enter>
Sigla:SP
Estado:riodejaneiro<enter>
59
Sigla:RJ
Estado:<enter>
Observao:Oprogramaencerraquandoousuriodigitarapenas<enter>naentradadonome
doestado.

(mximo20caracteres),incioefim.Logoapsaentradadetodosos
dados imprima a string resultante ou ERRO: Fim invlido ou Incio
invlido,conformeexemplosabaixo:
Exemplo:
Palavra:universidade<enter>
Incio:7<enter>
Fim:11<enter>
Stringresultante:idade
Palavra:eletricidade<enter>
Incio:7<enter>
Fim:15<enter>
ERRO:FimInvlido
Observao:OprogramaterminaquandoousuriodigitarN ou nnapergunta:Continua
[S/N]?.
60
13.Funesdefinidaspeloprogramador
A linguagem de programao C permite que o programador crie e
utilizesuasprpriasfunes.
FormaGeral:
tipo_do_retornonome_da_funo(parmetros)
tipo_dado_baseparmetros;
{
tipo_dado_basevariveis;
corpodafuno;
return();
}
ou
tipo_do_retornonome(tipo_dado_baseparmetros)
{
tipo_dado_basevariveis;
corpodafuno;
return();
}
tipo_do_retorno: Especifica o tipo de dado do retorno da funo. O
retornodafunofeitapelocomandoreturn(valor).
parmetros: uma lista, separada por vrgulas, com os nomes das
variveis (e seus tipos) que recebero os argumentos quando a funo
forchamada.
Observao: O tipo default de uma funo int, ou seja, se no for
especificadootipodafunoocompiladorassumeint.
Funoprocedural:umtipoespecialdefunoquenopossuiretorno,
ouseja,simplesmenteumprocedimento.Umafunodestetipovoid.
Exemplo:
intrandom(intn)
{
intt;
t=rand()%n;
return(x);
}
Chamadadafuno:n=random(256);
//retornaumnmeroaleatrioentre0e255
Programa exemplo (32): O programa possui uma funo que calcula o

inverso1/x.
61
#include<stdio.h>
floatinverso(floatx);
//prottipodafuno
intmain(void)
{
floatinv,resp;
printf("x:");
scanf("%f",&x);
inv=inverso(x);
//chamadadafunoinverso
printf("Inverso=%.2f\n",inv);
}
//Funodefinidapeloprogramador
floatinverso(floatx)
{
floati;
i=(float)1/x;
return(i);
}
ou
floatinverso(x)
floatx;
{
return((float)1/x);
}
13.1Valoresderetorno
Todas as funes, exceto aquelas que so declaradas como sendo
dotipovoid,devolvemumvalor.Ovalordevolvido(retornado)pela
funoatravsdocomandoreturn.
Normalmentesoescritastrstiposdefunes:
a)Funes
que
efetuam
operaes
com
os
parmetros
e
retornam

um
valor
com
base
nas
operaes
.
Programaexemplo(33):Oprogramacalculaeimprimenatelaovalorda
potnciaxy.
#include<stdio.h>
#include<math.h>
floatpotencia(floatx,inty);
intmain(void)
{
floatbase,resp;
intexpoente;
62
printf("Base:");
scanf("%f",&base);
printf("Expoente:");
scanf("%d",&expoente);
resp=potencia(base,expoente);
printf("Potencia=%7.2f\n",resp);
}
//chamadadafunopotencia
floatpotencia(floatx,inty)
{
floatvalor;
valor=exp(log(x)*y);
return(valor);
}
b)
Funes
que

manipulam
informaes
e
retornam
um
valor
que

simplesmente
indica
o
sucesso
ou
o
fracasso
da
manipulao
.
Programaexemplo(34):Oprogramacalculaeverificaodeterminantede
umaequaodesegundograu.
#include<stdio.h>
intverifica_determinante(floata,floatb,floatc);
intmain(void)
{
floata,b,c;
intretorno;
printf("a=");
scanf("%f",&a);
printf("b=");
scanf("%f",&b);
printf("c=");
scanf("%f",&c);
retorno=verifica_determinante(a,b,c);
if(retorno==0)
printf("DeterminanteZERO\n");
else
if(retorno>0)
printf("DeterminantePOSITIVO\n");
else
printf("DeterminanteNEGATIVO\n");
}
//funodefinidapeloprogramador
intverifica_determinante(floata,floatb,floatc)
{
floatdet;
63
det=b*b4*a*c;
if(det==0)
return(0);
else
if(det>0)
return(1);
else
return(1);
}
c)
Funes
que

no

retornam
nenhum
valor,
ou
seja,
so

puramente
procedimentos.
Programa exemplo (35): O programa possui uma funo que limpa toda a
telaemmodotexto.
#include<stdio.h>
voidlimpa_tela(void);
intmain(void)
{
limpa_tela();
}
//funodefinidapeloprogramador
voidlimpa_tela(void)
{
intc,l;
for(l=1;l<=25;l++)
{
for(c=1;c<=80;c++)
printf("%c",32);
printf(\n);
}
}
//32ocdigodocaracterespao
13.2Passagemdeparmetrosporvalor
Forma de chamada de uma funo onde o valor do argumento
apenascopiadoparaoparmetroformaldafuno.Portanto,alteraes
feitas nos parmetros no tero efeito nas variveis utilizadas para
chamla.
Programa exemplo (36): O programa possui uma funo que desenha um
retngulonatela.
#include<stdio.h>
voiddesenha_retangulo(intci,intli,intcf,intlf)
64
{
intc,l;
for(l=li;l<=lf;l++)
{
for(c=ci;c<=cf;c++)
printf("#");
printf("\n");
}
}
intmain(void)
{
desenha_retangulo(1,1,20,10);
}
Onde:ci>colunainicial
li>linhainicial
cf>colunafinal
lf>linhafinal
Ateno:Osparmetrosdafunorecebem,respectivamente:ci=1,li=
1,cf=20elf=10.
13.3Passagemdeparmetrosporreferncia
Forma de chamada de uma funo onde o endereo do argumento
passado como parmetro. Significa que as alteraes feitas nos
parmetrosafetaroavarivelutilizadaparachamarafuno.
Programa exemplo (37): O programa tem uma funo que troca o valor de
duasvariveis.
#include<stdio.h>
voidtroca(int*x,int*y)
{
inttemp;
/*xeysoponteiros*/
temp=*x;
*x=*y;
*y=temp;
}
intmain(void)
{
inta,b;
printf("a=");
//imaginequeousuriodigitou3
scanf("%d",&a);
printf("b=");
scanf("%d",&b);
//imaginequeousuriodigitou4
printf("a=%d|b=%d\n",a,b);
//foiimpressonatelaa=3|b=4
troca(&a,&b);
printf("a=%d|b=%d\n",a,b);
//foiimpressonatelaa=4|b=3
}
65
Ateno:Osparmetrosdafunorecebem,respectivamente:x>&aey>&b.
13.4Funesquedevolvemvaloresnointeiros
Todasasfunesquedevolvemvaloresnointeirosdevemterseu
tipoderetornodeclarado.
tipo_do_retornonome_da_funo(tipo_dado_baseparmetros);
Programa exemplo (38): O programa calcula e imprime na tela a diviso

dedoisvalores.
#include<stdio.h>
floatdivisao(intx,inty);
intmain(void)
{
intx,y;
floatresposta;
printf("x=");
scanf("%d",&x);
printf("y=");
scanf("%d",&y);
resposta=divisao(x,y);
printf("Diviso=%7.2f\n",resposta);
}
floatdivisao(intx,inty)
{
return((float)x/y);
}
13.5Argumentosargceargvdomain
A funo main possui dois argumentos argc e argv intrnsecos
utilizadosparareceberparmetrosdalinhadecomandodoDOS(Sistema
OperacionalemDisco).
argccontmonmerodeargumentosnalinhadecomando.
argvponteiroparaumamatriz(2D)decaracteres(vetordestrings).
Programa exemplo (39): O programa recebe parmetros do Sistema
Operacional (uma palavra qualquer) e imprime a palavra em sentido
inverso.OprogramacompiladoeexecutadoemumterminaldoSistema
OperacionalLinuxdaseguinteforma:
Execuopelalinhadecomandos(terminal):$invertepelotas<enter>
Resultadonatela:satolep
66
Programarecebe:
argc=2
argv[0]=inverte
agv[1]=pelotas
//inverte.c
//esteprogramadeveobrigatoriamentesechamarinverte.c
//depoisdecompiladosergeradooexecutvelinverte
#include<stdio.h>
#include<string.h>
intmain(intargc,char*argv[])
{
inti,n;
if(argc!=2)
printf("Sintaxe:INVERTE<palavra>\n");
else
{
n=strlen(argv[1]);
for(i=n1;i>=0;i)
printf("%c",argv[1][i]);
printf(\n);
}
}
Programaexemplo(40):OprogramadevereceberparmetrospeloSistema
Operacional (conjunto de caracteres) e deve ordenar (coloca em ordem
alfabtica),imprimindoosaseguir.
Execuopelalinhadecomandos:$ordenadbeacgf<enter>
Resultadonatela:abcdefg
Programarecebe:
argc=2
argv[0]=ordena
agv[1]=dbeacgf
//ordena.c
#include<stdio.h>
#include<string.h>
{
inti,j;
intn_car;
chartemp;
if(argc!=2)
printf("Sintaxe:ORDENA<palavra>\n");
else
{
67
n_car=strlen(argv[1]);
for(i=0;i<n_car1;i++)
for(j=i+1;j<n_car;j++)
if(argv[1][i]>argv[1][j])
{
temp=argv[1][i];
argv[1][i]=argv[1][j];
argv[1][j]=temp;
}
for(i=0;i<n_car;i++)
printf("%c",argv[1][i]);
printf(\n);
}
}
13.6Recursividade
Umafunorecursiva,seesta,fizerumachamadaasiprpria.
Programaexemplo(41):Osprximosdoisprogramascalculamofatoriale
asomadeumnmerorecursivamente.
//fatorial.c
#include<stdio.h>
longintFatorial(intn)
{
longintfat;
if(n<=1)
return(1);
fat=n*Fatorial(n1);
return(fat);
}
intmain(void)
{
intn;
longintfat;
do{
do{
printf("n=");
scanf("%d",&n);
}while(n<0||n>19);
fat=Fatorial(n);
printf("Fatorial:%d\n",fat);
}while(n!=0);
}
//soma.c
#include<stdio.h>
longintSoma(intn)
{
68
longints;
if(n==1)
return(1);
s=n+Soma(n1);
return(s);
}
intmain(void)
{
intn;
longints;
do{
do{
printf("n=");
scanf("%d",&n);
}while(n<0||n>19);
if(n>0)
{
s=Soma(n);
printf("Soma:%d\n",s);
}
}while(n!=0);
}
13.7Listadeexerccios(funes)
13.7.1 Escreva em C a funo PALAVRAS. A funo recebe uma string
(nome)eretornaonmerodepalavrasdonome(vejaexemploabaixo):
#include<stdio.h>
______________PALAVRAS(____________________);
intmain(void)
{
Exemplo:
charnome[41];
intn;
Seunometem4palavra(s)
printf(Nome:);
n=PALAVRAS(nome);
printf(Seunometem%dpalavra(s)\n,n);
}
Observao:NoutilizarafunostrlendoTurboC.
13.7.2EscrevaemCafunoVERIFICA_DATA.Afunorecebeumastring
(data, no formato: dd/mm/aaaa) e devolve via parmetros: dia, ms e
ano. A funo retorna: (1) se o dia for invlido, (2) se o ms for
invlido, (3) se o ano for invlido, (4) formato invlido e (5) se a
dataestivercorreta.
#include<stdio.h>
#include<string.h>
69
#include<stdlib.h>
______________VERIFICA_DATA(____________________);
intmain(void)
{
Exemplo:
chardata[11];
intdia,mes,ano,erro;
Data[dd/mm/aaaa]:11/07/2002<enter>
Dia:11
printf(Data[dd/mm/aaaa]:);
Ms:07
scanf(%10s,data);
Ano:2002
erro=VERIFICA_DATA(data,&dia,&mes,&ano);
if(erro==1)
printf(ERRO:Diainvlido\n);
else
if(erro==2)
printf(ERRO:Msinvlido\n);
else
if(erro==3)
printf(ERRO:Formatoinvlido\n);
Valores
Vlidos:
else
if(erro==4)
printf("ERRO:AnoInvlido\n");
else
{
printf(Dia:%d\n,dia);
printf(Ms:%d\n,mes);
printf(Ano:%d\n,ano);
}
}
Dia[1..31]
Ms[1..12]
Ano[2000..2999]
13.7.3 Escreva em C a funo PREENCHE. A funo recebe: nmero de

caracteres (n) e caracter (ch). A funo deve imprimir na tela, n
caracteresch.
#include<stdio.h>
_____________________PREENCHE(____________________);
intmain(void)
{
PREENCHE(5,#);
}
//#####
13.7.4 Escreva em C a funo GERA_STRING. A funo recebe via

parmetros nmero de caracteres (n) e caracter (ch). A funo devolve
navarivels,ncaracteresch.
#include<stdio.h>
___________________GERA_STRING(_______________);
intmain(void)
{
chars[10];
70
GERA_STRING(5,#,s);
printf(%s,s);
}
//sficarcom#####
13.7.5 Escreva em C a funo VERIFICA_QUADRANTE. A funo recebe um

valorparaxeumvalorparayeretornaonmerodoquadrante(1,2,3
ou4).
#include<stdio.h>
___________________VERIFICA_QUADRANTE(_______________);
Quadrantes
intmain(void)
{
intx,y,n;
|
|
2o
|
1o
|
|
3o
|
4o
|
|
printf(x=);
scanf(%d,&x);
printf(y=);
scanf(%d,&y);
n=VERIFICA_QUADRANTE(x,y);
printf(Quadrante:%d\n,n);
}
13.7.6 Escreva a funo: final_da_placa. A funo recebe uma placa de

automvel (placa) no formato: xxx9999 e retorna o ltimo dgito da
placa.
#include<stdio.h>
#include<string.h>
intmain(void)
{
charplaca[8];
intfinal;
printf(Qualaplacadeseucarro[xxx9999]:);
scanf(%7s,placa);
final=final_da_placa(placa);
printf(FinaldaPlaca:%d\n,final);
}
13.7.7 Escreva a funo: VOGAIS. A funo recebe uma string (nome) e
retornaaquantidadedevogaisdastring.
#include<stdio.h>
#include<string.h>
intmain(void)
{
charnome[41];
intvogais;
71
printf(Nome:);
vogais=VOGAIS(nome);
printf(Vogais:%d\n,vogais);
}
13.7.8Escrevaafuno:HIPOTENUSA.Afunorecebeocatetoadjacente
(b) e o cateto oposto (a) e retorna o valor da hipotenusa dado pela
seguintefrmula:
Frmula:
h2=a2+b2
#include<stdio.h>
#include<string.h>
intmain(void)
{
floata,b,h;
printf(CatetoAdjacente:);
scanf(%f,&b);
printf(CatetoOposto:);
scanf(%f,&a);
h=HIPOTENUSA(a,b);
printf(Hipotenusa:%.2f\n,h);
}
13.7.9EscrevaemCafunoCONTA.Afunorecebeumastring(nome)e
devolve via parmetros: nmero letras maisculas e o nmero letras
minsculas. A funo retorna o total de letras do nome (veja exemplo
abaixo).
#include<stdio.h>
#include<string.h>
______________CONTA(____________________);
intmain(void)
{
Exemplo:
charnome[41];
intn,maiusculas,minusculas;
Maisculas:4
clrscr();
Minsculas:21
printf(Nome:);
Totaldeletras:25
n=CONTA(nome,&maiusculas,&minusculas);
printf(Maisculas:%d\n,maiusculas);
printf(Minsculas:%d\n,minusculas);
printf(Totaldeletras:%d\n,n);
getch();
}
13.7.10 Escreva em C a funo REAJUSTE. A funo recebe o valor do
salrioeondicedereajusteeretornaosalrioatualizado.
72
#include<stdio.h>
___________________REAJUSTE(_______________);
intmain(void)
{
floatsalario,indice,sal;
Exemplo:
Salrio(R$):1000<enter>
ndicedeReajuste:10<enter>
SalrioAtualizado(R$):1100
printf(Salrio(R$):);
scanf(%f,&salario);
printf(ndicedeReajuste:);
scanf(%f,&indice);
sal=REAJUSTE(salario,indice);
printf(SalrioAtualizado(R$):%.2f\n,sal);
}
13.7.11EscrevaemCafunoCENTRALIZA.Afunorecebeumamensagem.
Afunodeveimprimirnatelaamensagemcentralizadanatela.
#include<stdio.h>
#include<string.h>
_____________________CENTRALIZA(____________________);
intmain(void)
{
CENTRALIZA(JogodeDamas);
}
13.7.12 Escreva em C a funo HIPOTENUSA. A funo recebe o valor da
base e da rea de um tringulo. A funo deve devolver na varivel
alturaaalturadotringulo.Afunodeveretornartambmovalorda
hipotenusa.
#include<stdio.h>
___________________HIPOTENUSA(_______________);
intmain(void)
{
floatbase,area,h,altura
base.altura
rea=
2
printf(Base:);
scanf(%f,&base);
printf(readoCrculo:);
scanf(%f,&area);
h=HIPOTENUSA(base,area,&altura);
printf(Hipotenusa:%.1f\n,h);
printf(Altura:%.1f\n,altura);
}
hipotenusa2=base2+altura2
13.7.13 Escreva em C a funo VERIFICA. A funo recebe um nmero

inteiro (n). A funo deve devolver na varivel resto o resto inteiro
dadiviso.Afunodeveretornarseonmero(n)par(1)oumpar
(0).
73
#include<stdio.h>
____________________VERIFICA(____________________);
intmain(void)
{
intn,resto;
printf(Nmero:);
scanf(%d,&n);
if(VERIFICA(n,&resto))
printf(Par\n);
else
printf(mpar\n);
printf(RestoInteirodaDiviso:%d\n,resto);
}
13.7.14 Escreva as seguintes funes: STRCPY (copia strings) e STRCAT
(concatenastrings)
#include<stdio.h>
____________________STRCPY(_______________________________)
____________________STRCAT(_______________________________)
intmain(void)
{
chars[]=Liber,r[]=dade,t[10];
STRCPY(t,s);
STRCAT(t,r);
printf(%s\n,t);
}
//funocopiasparat>Liber
//inserernofinaldet>Liberdade
//t>liberdade
74
14.Ponteiros
Umponteiroumavarivelquecontmumendereodememria.O
endereo pode ser a localizao de uma ou mais variveis na memria
RAM ou qualquer outro endereo da memria RAM, como por exemplo, a
memriadatela.
Figura5:Representaodeumponteironamemria
Exemplo:
#include<stdio.h>
intmain(void)
{
charx=65;
char*p;
p=&x;
printf("Valordex...:%d\n",*p);
printf("Caracter....:%c\n",*p);
printf("Endereodex:%p\n",p);
printf("Endereodep:%p\n",&p);
printf(Sizeofdep:%d\n,sizeof(p));
}
//precebeoendereodex(&x)
//*pvalor65
//caracter'A'
//endereodex
//endereodoponteirop
//ponteiroocupa4bytes
Figura6:Endereamentodeumponteiro
Resumo:
x>65
&x>100
p>&x>100
*p>65
&p>200
Observao:UmponteironoLinuxocupa4bytesnamemriaRAM.
75
14.1Variveisponteiros
Definio:
tipo_dado_base*nome_do_ponteiro;
tipo_dado_base:qualquertipobsicovlidoemC.
nome_da_ponteiro:nomedavarivelquerepresentaoponteiro.
Otipodedadosdoponteirodefineparaquetiposdevariveiso
ponteiro pode apontar e qual o tamanho ocupado na memria por estas
variveis.
14.2Operadoresdeponteiros
&endereodememriadooperando.
*contedodoendereoapontadopeloponteiro.
Exemplo:ponteiro=&varivel;
Logo: varivel=*ponteiro;
Observao: Como C sabe quantos bytes copiar para a varivel apontada
peloponteiro?
Resposta:Otipo_dado_basedoponteirodeterminaotipodedadoqueo
ponteiroestapontando.
14.3Expressescomponteiros
14.3.1Atribuiescomponteiros
Podese atribuir o valor (endereo) de um ponteiro para outro
ponteiro.
Programaexemplo(42):Oprogramamostraatribuiesutilizandodois
ponteiros.
#include<stdio.h>
intmain(void)
{
intx=7;
int*p1,*p2;
p1=&x;
p2=p1;
printf("%p\n",&x);
printf("%p\n",p1);
printf("%p\n",p2);
printf("%d\n",*p1);
printf("%c\n",*p1);
//p1recebeoendereodex
//p2recebeoendereodex
//impressoendereodex
//impressovalordex(contedodep1)
//impressocaracter7(Bellcontedodep1)
76
}
14.3.2Aritmticacomponteiros
14.3.2.1Incremento(++)
Faz com que o ponteiro aponte para a localizao de memria do
prximoelementodeseutipo_dado_base.
Exemplo:
p++;
(*p)++;
/*ponteiroapontaparaoprximoelemento*/
/*contedodoponteiroincrementado*/
Programaexemplo(43):Oprogramamostraumponteiroapontandoparaos
elementos de um vetor. Isto feito atravs da aritmtica de
ponteiros.
#include<stdio.h>
intmain(void)
{
charx[10]={65,66,67,68,69,70,71,72,73,74};
char*p;
inti;
p=&x[0];
for(i=0;i<=9;i++)
{
printf("Endereo:%p|Valor:x[%d]=%c\n",p,i,*p);
p++;
}
}
Resultadonatela:
Endereo:0xbfb70886|Valor:x[0]=A
Endereo:0xbfb70887|Valor:x[1]=B
Endereo:0xbfb70888|Valor:x[2]=C
Endereo:0xbfb70889|Valor:x[3]=D
Endereo:0xbfb7088a|Valor:x[4]=E
Endereo:0xbfb7088b|Valor:x[5]=F
Endereo:0xbfb7088c|Valor:x[6]=G
Endereo:0xbfb7088d|Valor:x[7]=H
Endereo:0xbfb7088e|Valor:x[8]=I
Endereo:0xbfb7088f|Valor:x[9]=J
Programaexemplo(44):Oprogramamostraumponteiroapontandoparaos
elementos de um vetor. Isto feito atravs da aritmtica de
ponteiros.
#include<stdio.h>
intmain(void)
{
intx[10]={0,1,2,3,4,5,6,7,8,9};
inti,*p;
p=&x[0];
77
for(i=0;i<=9;i++)
{
printf("Endereo:%p|Valor:x[%d]=%d\n",p,i,*p);
p++;
}
}
ResultadonaTela:
Endereo:0xbfc258c0|Valor:x[0]=0
Endereo:0xbfc258cc|Valor:x[3]=3
Endereo:0xbfc258d0|Valor:x[5]=5
Endereo:0xbfc258dc|Valor:x[8]=8
Endereo:0xbfc258e4|Valor:x[9]=9
14.3.2.2Decremento()
Faz com que o ponteiro aponte para a localizao do elemento
anterior.
Exemplo:
p;
(*p)++;
//ponteiroapontaparaoelementoanterior
//contedodoponteiroincrementado
14.3.3Soma(+)esubtrao()
Exemplo:p=p+9;
Faz com que o ponteiro p aponte para o nono (90) elemento do
tipo_dado_base, aps aquele que o ponteiro estava apontando no
momento.
Observao: Somente podese somar e subtrair nmeros inteiros a
ponteiros.
14.3.4Comparaodeponteiros
possvel comparar dois ponteiros atravs utilizando os
operadoresrelacionais.
Exemplo:
if(p<q)
printf("Endereodepmenordoqueq\n");
14.4Ponteirosevetores
Em C, o nome de um vetor sem ndice o endereo do primeiro
elementosdamatriz.
78
Exemplo:
#include<stdio.h>
intmain(void)
{
intx[10]={0,1,2,3,4,5,6,7,8,9};
int*p;
p=&x[0];
:
}
//igualap=x
Paraacessaroquinto(50)elementopodemosescrever:
x[4];
ou
*(p+4);
Observao: Aritmtica de ponteiros pode ser mais rpida que a

indexaodevetoresematrizes.
14.4.1Indexandoumponteiro
Exemplo:
#include<stdio.h>
intmain(void)
{
intx[5]={0,1,2,3,4}
int*p,t;
p=x;
for(t=0;t<=4;t++)
printf("%d\n",p[t]);
}
//igualap=&x[0]
14.4.2Ponteirosestrings
Comoonomedeumvetorsemndiceumponteiroqueapontapara
o primeiro elemento do vetor, quando utilizase funes que recebem
strings como parmetros, estas recebem apenas um ponteiro para a
stringenoovalorrealdastringemsi,ouseja,sempreapassagem
deparmetrodeumastringporreferncia.
Programaexemplo(45):Oprogramacomparaduasstrings.
#include<stdio.h>
intcompare(char*s1,char*s2);
intmain(void)
{
chars1[41],s2[41];
printf("String1:");
79
fgets(s1,40,stdin);
printf("String2:");
fgets(s2,40,stdin);
if(compare(s1,s2)==0)
printf("s1igualas2\n");
else
printf("s1diferentedes2\n");
}
//s1iguals2==0
intcompare(char*s1,char*s2)
{
while(*s1)
//quandoo*s1forigual'\0'terminaolao
if(*s1*s2)
return(*s1*s2);
else
{
s1++;
s2++;
}
return('\0');
}
14.4.3Obtendooendereodeumelementodeumvetor
p=&x[2];
14.4.4.Vetoresdeponteiros
Declaraodeumvetordeponteirosdeinteirosdetamanho10.
int*x[10];
Atribuio do endereo de uma varivel ao terceiro elemento da
matrizdeponteiros:
x[2]=&varivel;
Logo:Paraobterovalordavarivel,utilizase:*x[2];
14.5Ponteirosparaponteiros
Uma matriz de ponteiros igual a apontar ponteiros para
ponteiros. Um ponteiro para um ponteiro uma forma de indireo
mltipla.
Programa exemplo (46): O programa utiliza uma varivel ponteiro para
ponteiro.
#include<stdio.h>
intmain(void)
{
intx;
int*p;
int**t;
x=10;
p=&x;
t=&p;
80
printf("%d\n",**t);
}
//imprimeovalordex
14.6Inicializaodeponteiros
Apsdeclararumponteiro,eantesdehaverumaatribuiodeum
valor inicial, o ponteiro ter um endereo desconhecido (lixo), ou
seja, nunca se deve utilizar um ponteiro antes de atribuirlhe um
valor(endereo).
Podese inicializar um ponteiro para caracteres (string) da
seguinteforma:
Exemplo:
intmain(void)
{
char*p="Paola";
char*erro="Faltadememria\n";
14.7Alocaodinmicadememria
Permite alocar e liberar uma rea de memria para variveis
durante a execuo de um programa. Qualquer outro tipo de varivel,
que no seja um ponteiro, deve ser alocada estaticamente, ou seja, a
varivelnopodeocuparmaisespaodoquefoideclarado.
Exemplo:
intx[10];
//uminteiroocupa2bytes
//logo10inteirosocupam20bytesnamemriaRAMdurantetodaaexecuodoprograma
14.7.1malloc
Afunomalloc(memoryallocation)permitealocarumaporode
memriadinamicamente.
Sintaxe:void*malloc(intnmero_de_bytes);
Prototype:stdlib.h
A funo malloc reserva espao na memria RAM (aloca) a
quantidade de bytes especificada pelo parmetro da funo
(nmero_de_bytes),devolvendoumponteirodotipovoid*apontandopara
oprimeirobytealocado.
O tipo void* representa um ponteiro sem tipo que deve ser
tipadodeacordocomotipodedadobasedoponteiro.Istopodeser
feitoutilizandoseumcast.
Quando no houver memria suficiente para alocar o ponteiro, a
funomallocdevolveumponteironulo(NULL).
81
Exemplo:
#include<stdio.h>
#include<stdlib.h>
intmain(void)
{
int*p,n;
printf(Quantidadedeelementos:);
scanf(%d,&n);
p=(int*)malloc(n*sizeof(int));
if(p==NULL)
//ouif(!p)
printf("ERROFATAL:Faltadememria\n");
else
{
printf("Ok,memriaalocada\n");
printf("Endereoreservado:%p\n,p);
printf("Quantidadedeelementosalocados:%d\n,n);
printf("Quantidadedebytesalocados:%d\n,n*sizeof(int));
free(p);
//vejaitem14.7.2
}
}
ResultadodoPrograma:
Quantidadedeelementos:5
Ok,memriaalocada
Endereoreservado:0x804a008
Quantidadedeelementosalocados:5
Quantidadedebytesalocados:20
14.7.2free
A funo free (livre) permite liberar a poro de memria
alocadapelafunomalloc.
Sintaxe:voidfree(void*p);
Prototype:stdlib.h
A funo free libera a rea de memria alocada pela funo
malloc.
Programa exemplo (47): O ponteiro p aponta para uma regio da memria
com80bytesreservados(alocados),ouseja,40inteiros.
#include<stdio.h>
#include<stdlib.h>
intmain(void)
{
int*p,t;
p=(int*)malloc(40*sizeof(int));
if(!p)
82
printf("ErroFatal:Faltadememria\n");
else
{
for(t=0;t<=39;++t)
*(p+t)=t;
for(t=0;t<=39;++t)
printf("%d\n",*(p+t));
free(p);
}
}
83
15.Entradaesadaemdisco
Existem dois sistemas de arquivo definidos em C. O primeiro,
definido pelo padro ANSI e UNIX chamado sistema de arquivo
bufferizado (formatado ou de alto nvel) e o segundo, definido
apenas pelo UNIX chamado sistema de arquivos nobufferizado (no
formatadooudebaixonvel).
15.1Filadebytes(stream)
A fila de bytes um dispositivo lgico de entrada ou sada de
dados, independente do dispositivo real. Um arquivo (dispositivo
externo)deveserassociadoaumafiladebytes.
Cutiliza5filasdetextoprdefinidas,soelas:
Tabela18:Filasdetexto
Fila
stdin
stdout
stderr
stdprn
stdaux
Funodafila
Entradapadro(standardinput)
Sadapadro(standardoutput)
Erropadro(standarderror)
Sadaparaimpressora(standardprinter)
Sadaauxiliar(standardauxiliary)
15.1.1Filasdetexto
Uma fila de texto uma seqncia de caracteres organizada em
linhas.Cadalinhafinalizadaporumcaracter'\n'.
Pode ocorrercertastradues de caracteres,tal como:'\n'ser
convertida em CR (13) + LF (10). Dessa forma, pode no haver
correspondncia de 1 para 1 entre os caracteres que o computador
escreve(l)eaquelesnodispositivoexterno.
CRCarriageReturn(retornodocarrocursor)
LFLineFeed(avanodelinha)
CR+LF=<enter>
Exemplodeumarquivotexto:
ABC\n
ABCDEF\n
\n
ABCDEFGH\n
EOF
Observaes:
EOFEndOfFile(fimdoarquivo).
Todoarquivotextopossuiumnome.
84
15.1.2Filasbinrias
Uma fila binria possui correspondncia unvoca (1 para 1) com
os bytes do dispositivo externo. Portanto nenhuma traduo de
caracteresocorrer.
Um arquivo binrio pode conter tipos de dados diferentes, como
porexemplo:char,int,float,vetores,ponteiros,strings,etc....
Figura7:Representaodeumarquivo
15.2Sistemadearquivobufferizado
A ligao comum que mantm unido o sistema de entrada e sada
bufferizado um ponteiro que aponta para o arquivo. O ponteiro do
arquivoidentificaumdeterminadoarquivoemdiscoeusadopelafila
associada a ele para direcionar cada uma das funes de entrada e
sada bufferizada para o lugar em que elas operam. Um ponteiro de
arquivoumavariveldeponteirodotipoFILE*.OtipoFILEpr
definidoemstdio.h.
Exemplo:
#include<stdio.h>
intmain(void)
{
FILE*fp;
15.2.1fopen
85
A funo fopen (file open) permite abrir um arquivo ligandoo a

umafiladebytes.
Sintaxe:FILE*fopen(char*nome_arquivo,char*modo);
Prototype:stdio.h
nome_arquivo:Deveserumastringquecontenha:"drive:\path\nome_do_arquivo".
modo: uma string que contm as caractersticas desejadas (veja tabela
abaixo).
Observao:t(text:arquivotexto)eb(binary:arquivobinrio)
Tabela19:Mododeaberturadearquivos
Modo
r
w
a
rb
wb
ab
r+
w+
a+
r+b
w+b
a+b
rt
wt
at
r+t
w+t
a+t
Significado
Abreumarquivotextoparaleitura
Criaumarquivotextoparagravao
Anexaaumarquivotexto
Abreumarquivobinrioparaleitura
Criaumarquivobinrioparagravao
Anexaaumarquivobinrio
Abreumarquivotextoparaleitura/gravao
Criaumarquivotextoparaleitura/gravao
Abreoucriaumarquivotextoparaleitura/gravao
Abreumarquivobinrioparaleitura/gravao
Criaumarquivobinrioparaleitura/gravao
Abreumarquivobinrioparaleitura/gravao
Abreumarquivotextoparaleitura
Criaumarquivotextoparagravao
Anexaaumarquivotexto
Abreumarquivotextoparaleitura/gravao
Criaumarquivotextoparaleitura/gravao
Abreoucriaumarquivotextoparaleitura/gravao
Observao:SeocorrerERROnaaberturadeumarquivo,fopendevolver
umponteironulo,ouseja,se(fp==NULL)erro.
Exemplos:
#include<stdio.h>
intmain(void)
{
FILE*fp;
if((fp=fopen("teste.dat","r"))==NULL)
printf("ErroFatal:Impossvelabriroarquivo\n");
else
{
printf("Ok,arquivoaberto\n");
...
ou
#include<stdio.h>
intmain(void)
86
{
FILE*fp;
fp=fopen("teste.dat","w");
if(fp==NULL)
printf("ErroFatal:Impossvelcriaroarquivo\n);
else
{
printf("Ok,arquivocriadocomsucesso\n");
...
15.2.2putc
Afunoputcutilizadaparagravarcaracteresemumarquivo.
Sintaxe:intputc(intch,FILE*fp);
Prototype:stdio.h
chocaracterasergravado
fpoponteirodoarquivoabertopelafunofopen()
Observao: Se uma gravao for bem sucedida putc() devolver o
caractergravado,casocontrriodevolverumEOF.
EOFEndofFile(FimdeArquivo)
15.2.3getc
Afunogetcutilizadaparalercaracteresdeumarquivo.
Sintaxe:intgetc(FILE*fp);
Prototype:stdio.h
fpoponteirodoarquivoabertoporfopen()
15.2.4feof
A funo feof (file end of file) determina se o fim de arquivo
foiencontrado.Devolve0senochegouaofimdoarquivo.
Sintaxe:intfeof(FILE*fp);
Prototype:stdio.h
Programaexemplo(48):Oprogramalistanatelatodasaslinhasdeum
arquivotexto,numerandoas.
Observao: Este programa deve ser compilado e executado em um
terminaldetextodosistemaoperacionaldaseguinteforma:
$listalista.c<enter>
Funcionamento: Todas as linhas do programa fonte "lista.c" so
exibidos na tela com as linhas numeradas. Ao preencher toda a tela
87
ocorre uma pausa. A cada parada informado o nome do arquivo texto

queestsendolistadoeonmerodebyteslistados.
#include<stdio.h>
{
FILE*fp;
unsignedinti,v;
charch;
if(argc!=2)
printf("Sintaxe:LISTA<nomedoarquivo>");
else
if((fp=fopen(argv[1],"r"))==NULL)
printf("ERRO:Arquivo[%s]noEXISTE\n");
else
{
i=v=1;
printf("%d:",i);
do{
ch=getc(fp);
v++;
if(ch=='\n')
{
i++;
printf("\n%d:",i);
}
else
printf("%c",ch);
}while(!feof(fp));
printf("[%s]Byte(s):%d\n",argv[1],v);
fclose(fp);
}
}
15.2.5fclose
A funo fclose (file close) utilizada para fechar um arquivo
aberto. Antes de fechar o arquivo os dados (que ainda estavam no
buffer)sogravados.
Sintaxe:intfclose(FILE*fp);
Prototype:stdio.h
Observao:Retorna0seaoperaofoibemsucedida.
15.2.6rewind
A funo rewind estabelece o localizador de posio do arquivo
paraoinciodoarquivoespecificado.
Sintaxe:voidrewind(FILE*fp);
Prototype:stdio.h
15.2.7getweputw
88
As funes getw e putw so utilizadas para ler e gravar,

respectivamente,inteirosemumarquivo.
Funo:Leituradeinteiros(getw)
Sintaxe:intgetw(FILE*fp);
Prototype:stdio.h
Funo:Gravaodeinteiros(putw)
Sintaxe:intputw(intx,FILE*fp);
Prototype:stdio.h
15.2.8fgetsefputs
Asfunesfgetsefputssoutilizadasparaleregravar
strings.
Funo:Leituradestrings(fgets)
Sintaxe:char*fgets(char*str,intcomprimento,FILE*fp);
Prototype:stdio.h
Funo:Gravaodestrings(fputs)
Sintaxe:char*fputs(char*str,FILE*fp);
Prototype:stdio.h
Observao: A funo fgets l uma string do arquivo especificado at
queleiaouum'\n'ou(comprimento1)caracteres.
15.2.9freadefwrite
As funes fread e fwrite so utilizadas para ler e gravar
blocosdedados,normalmenteumastruct.
Funo:Leituradeblocos(fread)
Sintaxe:intfread(void*buffer,intnum_bytes,intcont,FILE*fp);
Prototype:stdio.h
Funo:Gravaodeblocos(fwrite)
Sintaxe:intfwrite(void*buffer,intnum_bytes,intcont,FILE*fp);
Prototype:stdio.h
buffer:umponteiroparaaregiodamemriaouoendereodeuma
varivelquereceberosdadoslidosdoarquivopelafunofreadou
quesergravadanoarquivopelafunofwrite.
num_bytes:Especificaaquantidadedebytesaseremlidosougravados.
cont:Determina quantosblocos(cada um comcomprimento de num_bytes)
serolidosougravados.
fp:oponteiroparaoarquivo.
15.2.10fseek
89
Afunofseekutilizadaparaajustarolocalizadordeposio
do arquivo, ou seja, permite selecionar a posio para efetuar
operaesdeleituraegravaoaleatrias.
Sintaxe:intfseek(FILE*fp,longintnum_bytes,intorigem);
Prototype:stdio.h
num_bytes: o nmero de bytes desde origem at chegar a posio
desejada.
Tabela20:Origememarquivos
Origem
Identificador
Inciodoarquivo
SEEK_SET
Posiocorrente
SEEK_CUR
Fimdoarquivo
SEEK_END
15.2.11fprintfefscanf
Asfunesfprintfefscanfsecomportamexatamentecomoprintfe
scanf,excetopelofatodequeelasoperamcomarquivosemdisco.
Funo:Gravaodedadosformatados(fprintf)
Sintaxe:intfprintf(FILE*fp,char*formato,listaargumentos);
Prototype:stdio.h
Funo:Leituradedadosformatados(fscanf)
Sintaxe:intfscanf(FILE*fp,char*formato,listaargumentos);
Prototype:stdio.h
15.2.12remove
Afunoremoveapagadodiscooarquivoespecificado.
Sintaxe:intremove(char*nome_arquivo);
Prototype:stdio.h
Exemplos:
A seguir, so listados trs programas: cria.c, lista.c,
consulta.c, os quais possuem como registro, uma palavra com no mximo
40caracteres.
Programaexemplo(49):Oprogramapermitecriarumarquivodepalavras
permitindoagravaodestaspalavras.
//cria.c
#include<stdio.h>
#include<string.h>
intmain(void)
{
FILE*fp;
charreg[40];
90
charnome_do_arquivo[14];
unsignedintn;
charch;
printf("Nomedoarquivo:");
scanf(%13s,nome_do_arquivo);
if((fp=fopen(nome_do_arquivo,"r+b"))!=NULL)
{
printf("ERRO:Arquivojexiste\n");
fclose(fp);
}
else
if((fp=fopen(nome_do_arquivo,"w+b"))==NULL)
printf("ErroFatal:Problemanodisco\n");
else
{
n=0;
do{
printf("%d:Palavra:",n);
scanf("%s",reg);
//scanfnoaceitaespaos
fwrite(reg,sizeof(reg),1,fp);
//gravaoregistro
n++;
do{
ch=getchar();
fclose(fp);
}
}
Programaexemplo(50):Oprogramapermiteabriroarquivodepalavrase
exibeosnatela.
//lista.c
#include<stdio.h>
intmain(void)
{
FILE*fp;
charreg[40];
unsignedintn;
if((fp=fopen(nome_do_arquivo,"rb"))==NULL)
printf("ERRO:ArquivonoEXISTE\n");
else
{
n=0;
fread(reg,sizeof(reg),1,fp);
while(!feof(fp))
{
printf("%d:Palavra:%s\n",n,reg);
n++;
91
fread(reg,sizeof(reg),1,fp);
}
fclose(fp);
}
}
Programa exemplo (51): O programa permite consultar o arquivo de
palavras. Para tanto solicitado, ao usurio, o nmero do registro
para ser calculado a posio deste registro no arquivo. Logo aps o
registroexibidonatela.
//consulta.c
#include<stdio.h>
#include<string.h>
intmain(void)
{
FILE*fp;
charreg[40];
unsignedintn,ok;
longintposicao;
charch;
if((fp=fopen(nome_do_arquivo,"r+b"))==NULL)
printf("ERRO:ArquivonoEXISTE\n");
else
{
do{
printf("Nmerodoregistro:");
scanf("%d",&n);
posicao=n*sizeof(reg);
fseek(fp,posicao,SEEK_SET);
ok=fread(reg,sizeof(reg),1,fp);
if(ok)
else
printf("ERRO:RegistroNOexiste\n");
do{
ch=getchar();
fclose(fp);
}
}
15.3Sistemadearquivonobufferizado
Ao contrrio do sistema de entrada e sada de alto nvel
(sistema bufferizado), o sistema de baixo nvel (sistema no
bufferizado) no utiliza ponteiros de arquivo do tipo FILE, mas sim
92
descritores de arquivos chamados handles do tipo int, ou seja, uma

varivelinteira.
15.3.1open,createclose
Afunoopenpermiteabrir/criarumarquivoemdisco.
Funo:Abreumarquivo(open)
Sintaxe:intopen(char*nomearquivo,intacesso);
Prototype:stdio.hefcntl.h
Tabela21:Tiposdeacessosemarquivos
Acesso
O_RDONLY
O_WRONLY
O_RDWR
O_CREAT
O_TRUNC
O_EXCL
O_APPEND
O_TEXT
O_BINARY
Efeito
Apenasleitura
Apenasgravao
Leituraegravao
Criaeabre
Abrecom"truncation"
Abreexclusiva
Abreparaincluirnofim
TranslaoCRparaLF
Semtranslao
Observao:Seafunoopenobtiversucesso(naaberturadoarquivo),
ser devolvido um inteiro positivo. Um valor de retorno 1 (EOF)
significaqueopennopodeabriroarquivo.(Oacessoserelacionaao
AmbienteUNIX)
Afunocreatcriaumarquivoparaoperaesdeleiturae
gravao.
Funo:Criaumarquivo(creat)
Sintaxe:intcreat(constchar*nomearquivo,intmodo);
Prototype:stdio.hefcntl.h
Tabela22:Modosdeacessosemarquivos
Modo
O_CREAT
O_TRUNC
O_APPEND
O_EXCL
O_RDONLY
O_WRONLY
O_RDWR
Efeito
Criarumarquivoseelenoexiste
Truncaroarquivoseeleexiste
Anexarnofimantesdecadagravao
Excluir.Foraacriaoseoarquivoexiste
Acessosomenteparaleitura
Acessosomenteparaescrita
Acessoparaleituraeescrita
Afunoclosefechaumarquivo.Devolve1(EOF),senofor
capazdefecharoarquivo.
Funo:Fechaumarquivo(close)
Sintaxe:intclose(intfd);
Prototype:stdio.h
15.3.2writeeread
93
A funo write grava tantos caracteres quantos forem o tamanho

do buffer apontado pelo ponteiro buf para o arquivo em disco
especificadoporfd.
Funo:Gravacaracteresnoarquivo(write)
Sintaxe:intwrite(intfd,void*buf,inttamanho);
Prototype:stdio.h
A funo read copia os dados lidos no buffer apontado pelo
ponteirobuf.
Funo:Lcaracteresdoarquivo(read)
Sintaxe:intread(intfd,void*buf,inttamanho);
Prototype:stdio.h
15.3.3unlink
Afunounlinkeliminaumarquivododisco(retorno:0sucesso
ou1erro).
Sintaxe:intunlink(constchar*nomearquivo);
Prototype:stdio.h
15.3.4lseek
Afunolseekdevolveonmerodebytes(num_bytes)seobtiver
sucesso.
Sintaxe:longintlseek(intfd,longintnum_bytes,intorigem);
Prototype:stdio.h
fd:descritordoarquivo
num_bytes:nmerodebytesdesdeaorigematanovaposio
origem:SEEK_SET(incio),SEEK_CUR(corrente),SEEK_END(fim)
15.3.5eof
Afunoeof(endoffile)devolve:(1)fimdearquivo,(0)no
fimdearquivoou(1)erro.
Sintaxe:intinteof(intfd);
Prototype:stdio.h
15.3.6tell
Afunotelldevolveaposiocorrentedodescritor.
Sintaxe:longinttell(intfd);
Prototype:stdio.h
Programaexemplo(52):Oprogramapermitecriarumarquivodepalavras
permitindoagravaodestaspalavras.
94
//criar.c
#include<stdio.h>
#include<string.h>
#include<fcntl.h>
intmain(void)
{
intfd;
charreg[40];
unsignedintn;
charch;
if((fd=open(nome_do_arquivo,O_RDONLY,"r"))==EOF)
if((fd=creat(nome_do_arquivo,O_RDWR))==EOF)
printf("ErroFatal:Problemanodisco\n");
else
{
n=0;
do{
printf("%d:Palavra:",n);
scanf("%s",reg);
write(fd,reg,sizeof(reg));
n++;
do{
ch=getchar();
close(fd);
}
else
{
printf("ERRO:ArquivojEXISTE\n");
close(fd);
}
}
Programaexemplo(53):Oprogramapermiteabriroarquivodepalavrase
exibeosnatela.
//listar.c
#include<stdio.h>
#include<fcntl.h>
intmain(void)
{
intfd;
charreg[40];
unsignedintn;
interror;
95
printf("NomedoArquivo:");
if((fd=open(nome_do_arquivo,O_RDONLY,"r"))==EOF)
printf("ERRO:ArquivoNOexiste...\n");
else
{
n=0;
do{
error=read(fd,reg,sizeof(reg));
n++;
}while(error);
//error=0fimdoarquivo
close(fd);
printf(%dpalavra(s)\n,n);
}
}
Programa exemplo (54): O programa permite alterar o arquivo de
palavras. Para tanto solicitado, ao usurio, o nmero do registro
para ser calculado a posio deste registro no arquivo. Logo aps o
registroexibidonatelaesolicitadaanovapalavra.
//alterar.c
#include<stdio.h>
#include<string.h>
#include<fcntl.h>
intmain(void)
{
intfd;
charreg[40];
unsignedintn;
longintposicao;
charch;
scanf(%s,nome_do_arquivo);
if((fd=open(nome_do_arquivo,O_RDWR,"w"))==EOF)
printf("ERRO:ArquivoNOexiste...\n");
else
{
do{
printf("Registro:");
scanf("%d",&n);
posicao=n*sizeof(reg);
lseek(fd,posicao,SEEK_SET);
if(read(fd,reg,sizeof(reg)))
{
printf("NOVAPALAVRA:");
scanf(%s,reg);
lseek(fd,posicao,SEEK_SET);
write(fd,reg,sizeof(reg));
}
else
printf("ERRO:Registronoexiste\n");
96
do{
ch=getchar();
close(fd);
}
}
15.4Listadeexerccios(arquivos)
arquivo texto. O programa deve imprimir na tela o nmero de bytes
(caracteres) e o nmero de linhas do arquivo ou ERRO: Arquivo no
existe.
Exemplo:
Nomedoarquivotexto:LISTA.C<enter>
(12345)Bytes
(44)Linhas
ou
ERRO:Arquivonoexiste
arquivotexto.Oprogramadevepermitiraousurioconsultaroarquivo
atravs da entrada via teclado do nmero da linha. O programa deve
imprimiralinhaespecificadaouERRO:Linhanoexiste.
Exemplo:
Nmerodelinha:7<enter>
7:inti,j,k;
ERRO:Linhanoexiste
ou
ERRO:Arquivonoexiste
15.4.3 EscrevaumprogramaemCquerecebeviatecladoonome de dois
arquivos texto (origem e destino). O programa deve copiar o contedo
doarquivoorigemparaoarquivodestino.
Exemplo:
Arquivoorigem:LISTA.C<enter>
Arquivodestino:LISTA.tmp<enter>
97
(20345)Bytescopiados
15.4.4 Escreva um programa em C que recebe via teclado o nome do
arquivo texto fonte e o nome do arquivo texto destino. O programa deve
converteroarquivofonteparamaisculoouminsculo(conformeescolha
dousurio)gerandooarquivotextodestino.
Exemplo:
Arquivofonte:LISTA.C<enter>
Arquivodestino:LISTA.TMP<enter>
[+]Maisculoou[]Minsculo:+<enter>
(1234)Bytesconvertidos
arquivo texto e uma palavra. O programa deve imprimir todas as linhas
quepossuemestapalavra.
Exemplo:
Nomedoarquivotexto:PALAVRA.C<enter>
Palavra:if<enter>
23:if(fp==NULL)
33:if(ch=='\n')
37:if(compara(linha,palavra))
41:if(ch!='\n')
59:if(linha[i]==palavra[0])
65:if(linha[k]!=palavra[j])
69:if(achei)
arquivotexto.Oprogramadevepermitiraousurioconsultaroarquivo
atravs da entrada via teclado do nmero inicial e nmero final. O
programa deve imprimir desde a linha inicial at a linha final ou
ERRO:Linhasnoexistem.
Exemplo:
Nmeroinicial:7<enter>
Nmerofinal:9<enter>
7:inti,j,k;
8:chartecla;
9:longintbytes=0;
ou
Nmeroinicial:70<enter>
Nmerofinal:90<enter>
ERRO:Linhasnoexistem
98
15.4.7EscrevaumprogramaemC(grava.c)querecebeviatecladoonome
de um arquivo binrio. O programa deve permitir ao usurio inserir
nomes (mximo 30 caracteres) neste arquivo via teclado. O programa
terminaquandoousuriodigitar<enter>naentradadonome.
Exemplo:
Nomedoarquivobinrio:NOMES.DAT<enter>
Nome:Beatriz<enter>
Nome:Eva<enter>
Nome:Debora<enter>
Nome:Carla<enter>
Nome:Fatima<enter>
Nome:Ana<enter>
Nome:<enter>
15.4.8 EscrevaumprogramaemC (ler.c)que recebe viateclado onome
deumarquivobinrio.Oprogramadevelereimprimirnatelatodosos
nomesarmazenadosnoarquivopeloprograma"grava.c".
Exemplo:
Nome:Beatriz
Nome:Eva
Nome:Debora
Nome:Carla
Nome:Fatima
Nome:Ana
15.4.9EscrevaumprogramaemC(sort.c)querecebeviatecladoonome
deumarquivobinrio.Oprogramadeveler,ordenaregravarnovamente
osnomesnomesmoarquivo.
Exemplo:
Ok,arquivoordenado
Observao:Utilizeoprogramaanterior(ler.c)paraverosnomes
ordenados.
15.4.10 Escreva um programa em C (salva.c) que recebe via teclado o
nomedeumarquivobinrio.Oprogramadevepermitiraousurioinserir
nome (mximo 30 caracteres), idade e sexo ([M]asculino ou [F]eminino)
nestearquivoviateclado.Oprogramaterminaquandoousuriodigitar
<enter>naentradadonome.
Exemplo:
Nomedoarquivobinrio:DADOS.DAT<enter>
99
Nome:PauloRoberto<enter>
Idade:41<enter>
Sexo[M/F]:m<enter>
Nome:RenatoLuis<enter>
Idade:38<enter>
Sexo[M/F]:m<enter>
Nome:AnaMaria<enter>
Idade:44<enter>
Sexo[M/F]:f<enter>
Nome:<enter>
15.4.11EscrevaumprogramaemC(list.c)querecebeviatecladoonome
deumarquivobinrio.Oprogramadevelereimprimirnatelatodosos
dados (nome, idade e sexo) armazenados no arquivo pelo programa
"salva.c"(vejaexemploabaixo).
Exemplo:
Nome:PauloRoberto
Idade:41
Sexo:MASCULINO
Nome:RenatoLuis
Idade:38
Sexo:MASCULINO
Nome:AnaMaria
Idade:44
Sexo:FEMININO
15.4.12 Escreva um programa em C (conta.c) que recebe via teclado o
nome de um arquivo binrio. O programa deve verificar a quantidade de
homens e a quantidade de mulheres no aquivo criado pelo programa
"salva.c".
Exemplo:
(2)Homens
(1)Mulheres
100
16.Tiposdedadosdefinidospeloprogramador
16.1Estruturas
Em C, uma estrutura (struct) uma coleo de campos que fazem
refernciaaumavarivel,ouseja,umavarivelpossuiumconjuntode
valores (que podem ser de tipos iguais ou diferentes agregados
heterogneos). Uma estrutura propicia uma maneira conveniente de
mantersejuntasinformaesrelacionadas.
structnome_da_estrutura{
tiponome_varivel;
tiponome_varivel;
...
}lista_de_variveis;
Nadefiniodeumaestruturapodeseomitironome_da_estrutura
oualista_de_variveisdestetipo,masnoambos.
structreg_cliente{
//nome_da_estrutura
charnome[30];
floatsalario;
intidade;
}cliente,fornecedor;
//lista_de_variveis
16.1.1Refernciaaoselementosdaestrutura
Parafazerrefernciaaoselementosindividuaisdeumaestrutura
devese utilizar o operador . (ponto), que as vezes chamado de
operadordeseleo.
nome_varivel_estrutura.nome_campo
Exemplo:cliente.idade=18;
16.1.2Matrizesdeestruturas
possvelcriarmatrizesdeestruturas.
Exemplo:structreg_clientecliente[100];
Criaseumarray(vetor)paraguardar100ocorrnciasde
cliente.
Acesso
ao
primeiro
elemento
da
estrutura
:
strcpy(cliente[0].nome,Paulo);
cliente[0].salario=500.00;
cliente[0].idade=41;
Acesso
ao
ltimo
elemento
da
estrutura
:
strcpy(cliente[99].nome,Renato);
101
cliente[99].salario=1500.00;
cliente[99].idade=37;
16.1.3Passandoestruturasparafunes
16.1.3.1Passandoelementosdaestrutura
Destaforma,passadoapenasumacpiadovalorparaafuno.
Chamadadafuno:funo(cliente.idade);
16.1.3.2Passandoestruturasinteiras
possvelpassarumaestrutura(struct)inteiraparaumafuno.
Observao: O tipo do argumento deve coincidir com o tipo do
parmetro.
Exemplo:
#include<stdio.h>
structTIPO{
inta,b;
charch;
};
voidfunction(structTIPOparm);
intmain(void)
{
structTIPOarg;
arg.a=1000;
arg.b=500;
arg.ch=A;
function(arg);
}
//argoargumento
voidfunction(structTIPOparm)
{
printf("%d",parm.a);
printf("%d",parm.b);
printf("%c",parm.ch);
}
//parmoparmetrotipoestrutura
16.1.4Ponteirosparaestruturas
Cpermitequeponteirosapontemparaestruturasdamesmamaneira
comopermiteponteirosparaqualqueroutrotipodevarivel.
102
Exemplo:
structreg_cliente{
charnome[30];
floatsalario;
intidade;
}cliente;
structreg_cliente*p;
Nestecasopumponteiroparaaestruturareg_cliente.
p=&cliente;
//oponteiropapontaparaavarivelcliente
Paraacessarumelementodeclienteatravsdoponteiropdeve
seescreverdasseguintesformas:
(*p).idade=21;
ou
p>idade=21;
16.2Camposdebit
Cpossuiummtodoinerentedeacessoaumnicobitemumbyte.
Estebaseadonaestrutura.Umcampodebitapenasumtipoespecial
deestruturaquedefineocomprimentoembitsquecadaelementoter.
structnome_tipo_estrutura{
tiponome_1:comprimento;
...
};
Observao:Umcampodebitdeveserdotipoint,unsignedintousignedint.
Exemplo:
structdispositivo{
unsignedativo:1;
unsignedpronto:1;
unsignederro:1;
}codigo_disp;
Estaestruturadefinetrsvariveisdeumbitcada,osoutros5
bits ficam desocupados, pois codigo_disp ocupa 8 bits, ou seja, 1
byte.
16.3Union
Em C, uma union (unio) uma localizao de memria que
utilizada por vrias variveis diferentes, que podem ser de tipos
diferentes(intouchar).
Exemplo:
103
unionu_type{
inti;
charch;
};
Nestecasoavariveliechocupamamesmalocalizaoda
memria.
16.4typedef
Cpermitequeoprogramadordefinaexplicitamentenovosnomesde
tipos de dados utilizando a palavra reservada typedef. Realmente no
se cria umanovaclassededados,mas sim, um novo nome para um tipo
existente.
typedeftipo_basenovo_nome_de_tipo;
Exemplo:typedeffloatreal;
typedefunsignedcharbyte;
realsalario;
byten_dentes;
16.5Tiposdedadosavanados
C permite que seja aplicado vrios modificadores de tipo aos
tiposdedadosbsicos.
modificador_tipotipo_bsicolista_variveis;
16.5.1Modificadoresdeacesso
16.5.1.1Omodificadorconst
Durante a execuo, o programa no poder alterar uma varivel
declarada com o modificador const, exceto dar a varivel um valor
inicial.
Exemplo:constfloatversao=3.30;
16.5.1.2Omodificadorvolatile
UtilizaseomodificadorvolatileparadizeraoCqueovalorde
uma varivel pode ser alterado sem uma especificao explcita do
programa.
Exemplo:volatileintclock;
16.5.2Especificadoresdeclassedearmazenamento
16.5.2.1Oespecificadorauto
Oespecificadorautoutilizadoparadeclararvariveislocais.
(Pordefaultasvariveislocaissoauto).
104
16.5.2.2Oespecificadorextern
Oespecificadorexterndizaocompiladorqueostiposdedadose
nomesdevariveisqueseseguemjforamdeclaradosemumoutrolugar
(porexemplo,outroprogramafonte).
16.5.2.3Oespecificadorstatic
As variveis static so variveis permanentes dentro de suas
prpriasfunes.Sodiferentesdasvariveisglobais,porquenoso
conhecidas fora de suas funes, mas mantm seus valores entre as
chamadas.
16.5.2.4.Oespecificadorregister
Se aplica apenas as variveis int ou char. O especificador
register faz com que o compilador mantenha o valor das variveis
declaradasdentrodosregistradoresdaCPU,enonamemria,ondeas
variveis normais so armazenadas normalmente. prprio para
variveisdeloop's(laos),poistornaolaomaisrpido.
Observao:Spodeserutilizadoemvariveislocais.
16.5.3Operadoresavanados
16.5.3.1Operadoresbitabit
Se referem ao teste, ajuste ou troca de bits reais por um byte
oupalavra(podemserdetiposcharouint).
Tabela23:Operadoresbitabit
Operador
&
|
^
~
>>
<<
Ao
And
Or
Orexclusivo(XOr)
Complementodeum(Not)
Deslocarparaadireita(shift)
Deslocarparaaesquerda(shift)
Deslocamento(shift):varivel>>nmerodedeslocamentos;
Exemplo:
#include<stdio.h>
intmain(void)
{
inta=128,b,c;
//a=128binrio>10000000
b=a>>1;
//b=64binrio>0100000
105
c=b<<1;
printf("a=%d\n",a);
printf("b=%d\n",b);
printf("c=%d\n",c);
}
//c=128
binrio>1000000
16.5.3.2Ooperador?
Podese utilizar o operador ? para substituir comandos if ...
elsequetenhamaseguinteformageral:
if(condio)
comando_1;
else
comando_2;
Aprincipalrestriodooperador?queoscomandosdoif...
elsedevemsercomandosimplesnopodendoseremcomandoscompostos.
Formageral:condio?comando_1:comando_2;
Exemplo:
#include<stdio.h>
intmain(void)
{
inta,b;
printf("a=");
scanf("%d",&a);
printf("b=");
scanf("%d",&b);
a>b?printf("Maior(a)>%d\n",a):printf("Maior(b)>%d\n",b);
}
16.5.3.3FormasabreviadasdeC
Ctemabreviaesespeciaisquesimplificamacodificaodeum
certotipodecomandodeatribuio.
Exemplo:
x=x+10; >podeserescritocomo> x+=10;
Esta forma abreviada funcionar com todos os operadores
aritmticosdeC.
Formanormal:
varivel=variveloperadorconstante;
x=x+7;
Formaabreviada: variveloperador=constante;
x+=7;
16.5.3.4Ooperador,
Podese utilizar a vrgula para juntar vrias expresses. O
compiladorsempreavaliaoladoesquerdodavrgulacomovoid.Assim,
106
a expresso do lado direito ficar sendo o valor de toda expresso

separadaporvrgula.
Exemplo:
x=(y=3,y+1);
Primeiramente atribudo o valor 3 a y e depois atribudo o

valor 4 a x. Os parnteses so necessrios, porque a vrgula tem
precednciamaisbaixaqueooperadordeatribuio.
107
17.Listaslineares
As listas lineares encadeadas (filas e pilhas alocadas
dinamicamente) permitem alocao indeterminada de elementos em uma
estrutura de dados. Os elementos so alocados na memria RAM
dinamicamente.
Uma lista encadeada tem por caracterstica um elo de ligao
entreumelementoeoutro.Aocontrriodeumvetor,ondeoselementos
soalocadosestaticamenteeemposiescontguasnamemriaRAM,uma
lista encadeada alocada dinamicamente, tendo como caracterstica
bsica, que os elementos so alocados em posies diferentes
(aleatrias)namemria.
As listas lineares encadeadas possuem um header (cabea) que
armazenaoprimeiroelementodalista.
Figura18:Representaodeumalistaencadeada
Doisproblemasexistememumalistaencadeada:
Primeiro: que as listas so percorridas seqencialmente,
apenasnumadireo,ouseja,doprimeiroaoltimoelemento;
b) Segundo: que a informao do nmero de elementos da lista
obtidosomenteporumavarreduracompletanalista.
a)
Pararesolverestesdoisproblemaspodeseutilizarumdescritor
daseguintemaneira:
Asvantagensdeumdescritorso:
Conhecer o nmero de elementos da lista linear sem ter que
percorrla;
Acessar o ltimo elemento facilitando a insero ou remoo no
finaldalista.
Aslistaspodemserorganizadascomo:pilhasoufilas.
Pilha: Estrutura linear organizada de forma que a entrada e a sada
dosdadosfeitanamesmaextremidade.
108
Forma de acesso: LIFO (Last Input First Output), ou seja, o ltimo

elementoaentrarnapilhaoprimeiroasairdela.
Fila: Estrutura linear organizada em forma que a entrada dos dados
feitaporumaextremidadedalistalineare,asada,feitanaoutra
extremidade.
Forma de acesso: FIFO (First Input First Output), ou seja, o primeiro
elementoaentrarnafilaoprimeiroasairdafila.
EEntradadeDados
SSadadeDados
Figura19:Representaodeumafilaeumapilha
Funcionamento
desta
pilha
:
Funcionamento
desta
fila
:
Entrada:1,2e3
Sada:3,2e1
Entrada:1,2e3
Sada:1,2e3
17.1Implementaodeumapilha
Programa exemplo (55): O programa permite inserir nmeros inteiros em
uma pilha. Quando o nmero digitado for igual zero (0), todos os
nmerosdapilhasolistados.
//pilha.c
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#defineSUCESSO
#defineFALTA_DE_MEMORIA
#definePILHA_VAZIA
1
2
3
structNODO{
intinfo;
structNODO*elo;
};
//informao
//eloparaoprximoelemento
structPILHA{
structNODO*topo;
109
};
voidcria_pilha(structPILHA*p);
intpush(structPILHA*p,intvalor);
intpop(structPILHA*p,int*info);
intconsulta_pilha(structPILHAp,int*info);
voidimprime_erro(interro);
voiddestroi_pilha(structPILHA*p);
//cria_pilha
voidcria_pilha(structPILHA*p)
{
p>topo=NULL;
}
//push
intpush(structPILHA*p,intvalor)
{
structNODO*t;
t=(structNODO*)malloc(sizeof(structNODO));
if(t==NULL)
return(FALTA_DE_MEMORIA);
else
{
t>info=valor;
t>elo=p>topo;
if(p>topo==NULL)
t>elo=NULL;
p>topo=t;
return(SUCESSO);
}
}
//pop
intpop(structPILHA*p,int*info)
{
structNODO*t;
if(p>topo==NULL)
return(PILHA_VAZIA);
else
{
t=p>topo;
*info=t>info;
p>topo=t>elo;
free(t);
return(SUCESSO);
}
}
//consulta_pilha
intconsulta_pilha(structPILHAp,int*info)
{
structNODO*t;
if(p.topo==NULL)
return(PILHA_VAZIA);
else
{
t=p.topo;
*info=t>info;
return(SUCESSO);
}
}
//imprime_erro
110
voidimprime_erro(interro)
{
switch(erro)
{
caseFALTA_DE_MEMORIA:printf("ERRO:Faltadememria,teclealgo\n");
break;
casePILHA_VAZIA:printf("ERRO:Pilhavazia,teclealgo\n");
break;
}
}
//destroi_pilha
voiddestroi_pilha(structPILHA*p)
{
structNODO*t;
t=p>topo;
if(p>topo!=NULL)
while(p>topo!=NULL)
{
t=p>topo>elo;
printf("Info:%d\n",p>topo>info);
free(p>topo);
p>topo=t;
}
printf("Ok,DadosDestruidos\n");
p>topo=NULL;
}
//main
intmain(void)
{
structPILHAp;
intvalor,erro;
charch;
cria_pilha(&p);
do{
printf("[P]ush,P[O]p,[C]onsultarou[F]im?");
do{
ch=toupper(getchar());
}while(!strchr("POCF",ch));
if(ch=='P')
{
printf("Valor:");
scanf("%d",&valor);
}
switch(ch)
{
case'P':erro=push(&p,valor);
if(erro!=SUCESSO)
imprime_erro(erro);
break;
case'O':erro=pop(&p,&valor);
if(erro!=SUCESSO)
imprime_erro(erro);
else
printf("InformaoExcluda:%d\n",valor);
break;
case'C':erro=consulta_pilha(p,&valor);
if(erro!=SUCESSO)
imprime_erro(erro);
else
printf("Valor:%d\n",valor);
break;
}
}while(ch!='F');
destroi_pilha(&p);
111
17.2Implementaodeumafila
uma fila. Quando o nmero digitado for igual zero (0), todos os
nmerosdafilasolistados.
//fila.c
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#defineSUCESSO
#defineFALTA_DE_MEMORIA
#defineFILA_VAZIA
1
2
3
structNODO{
intinfo;
//informao
structNODO*elo; //eloparaoprximoelemento
};
structFILA{
structNODO*primeiro;
inttamanho;
structNODO*ultimo;
};
voidcria_fila(structFILA*f);
intincluir_fila(structFILA*f,intvalor);
intexcluir_fila(structFILA*f);
intconsultar_fila(structFILAf,int*j);
voidimprime_erro(interro);
//cria_fila
voidcria_fila(structFILA*f)
{
f>primeiro=NULL;
f>tamanho=0;
f>ultimo=NULL;
}
//incluir_fila
intincluir_fila(structFILA*f,intvalor)
{
structNODO*t;
t=(structNODO*)malloc(sizeof(structNODO));
if(t==NULL)
return(FALTA_DE_MEMORIA);
else
{
t>info=valor;
t>elo=NULL;
if(f>ultimo!=NULL)
f>ultimo>elo=t;
f>ultimo=t;
if(f>primeiro==NULL)
f>primeiro=t;
f>tamanho=f>tamanho+1;
return(SUCESSO);
}
}
//excluir_fila
112
intexcluir_fila(structFILA*f)
{
structNODO*t;
return(FILA_VAZIA);
else
{
t=f>primeiro;
printf("ElementoExcluido:%d\n",t>info);
f>primeiro=t>elo;
f>tamanho=f>tamanho1;
free(t);
f>ultimo=NULL;
return(SUCESSO);
}
}
//consultar_fila
intconsultar_fila(structFILAf,int*j)
{
structNODO*t;
if(f.primeiro==NULL)
return(FILA_VAZIA);
else
{
t=f.primeiro;
*j=t>info;
return(SUCESSO);
}
}
//imprime_erro
voidimprime_erro(interro)
{
switch(erro)
{
caseFALTA_DE_MEMORIA:printf("\nERRO:Faltadememria,teclealgo\n");
break;
caseFILA_VAZIA:printf("\nERRO:Filavazia,teclealgo\n");
break;
}
}
//destroi_fila
voiddestroi_fila(structFILA*f)
{
structNODO*t;
if(f>tamanho>0)
while(f>primeiro!=NULL)
{
t=f>primeiro;
printf("Info:%d\n",t>info);
free(f>primeiro);
f>primeiro=t>elo;
}
printf("Ok,DadosDestruidos\n");
cria_fila(f);
}
//main
intmain(void)
{
113
structFILAf;
intvalor,erro;
charch;
cria_fila(&f);
do{
printf("[I]ncluir,[E]xcluir,[C]onsultarou[F]im?");
do{
ch=toupper(getchar());
}while(!strchr("IECF",ch));
if(ch=='I')
{
printf("Valor:");
scanf("%d",&valor);
}
switch(ch)
{
case'I':erro=incluir_fila(&f,valor);
if(erro!=SUCESSO)
imprime_erro(erro);
break;
case'E':erro=excluir_fila(&f);
if(erro!=SUCESSO)
imprime_erro(erro);
break;
case'C':erro=consultar_fila(f,&valor);
if(erro!=SUCESSO)
imprime_erro(erro);
else
printf("Valor:%d\n",valor);
break;
}
}while(ch!='F');
destroi_fila(&f);
17.3Listaduplamenteencadeada
Uma lista duplamente encadeada possui um elo para o elemento
anterioreumeloparaoelementoposterior.Possuiumavantagemsobre
alistaencadeada,poisestetipodelistapodeserpercorridaemduas
direes(paraadireitaeparaaesquerda).
umalistaduplamenteencadeada.Ainseropodeserpelaesquerdaoua
direita. A exibio dos elementos da lista pode ser feita pela
esquerdaoudireita.
//dupla.c
#include<stdio.h>
#include<stdlib.h>
#include<ctype.h>
#include<string.h>
structELEMENTO{
structELEMENTO*anterior;
intdado;
structELEMENTO*posterior;
};
structDESCRITOR{
structELEMENTO*primeiro;
114
intn;
structELEMENTO*ultimo;
};
voidinicializa_descritor(structDESCRITOR*d);
voidinsere_direita(structDESCRITOR*d,intn);
voidinsere_esquerda(structDESCRITOR*d,intn);
voidexibir_lista_direita(structDESCRITORd);
voidexibir_lista_esquerda(structDESCRITORd);
//main
intmain(void)
{
structDESCRITORd;
intn;
charop;
inicializa_descritor(&d);
do{
printf("Nmero[0Sair]:");
scanf("%d",&n);
if(n!=0)
{
printf("Inserira[E]squerdaou[D]ireita?");
do{
op=toupper(getchar());
}while(!strchr("ED",op));
switch(op)
{
case'E':insere_esquerda(&d,n);
break;
case'D':insere_direita(&d,n);
break;
}
}
}while(n!=0);
do{
printf("Listar:[E]squerda,[D]ireitaou[F]im?");
do{
op=toupper(getchar());
}while(!strchr("EDF",op));
switch(op)
{
case'E':exibir_lista_esquerda(d);
break;
case'D':exibir_lista_direita(d);
break;
}
}while(op!='F');
}
//inicializa_descritor
voidinicializa_descritor(structDESCRITOR*d)
{
d>primeiro=NULL;
d>n=0;
115
d>ultimo=NULL;
}
//insere_esquerda
voidinsere_esquerda(structDESCRITOR*d,intn)
{
structELEMENTO*p,*q;
p=(structELEMENTO*)malloc(sizeof(structELEMENTO));
if(p==NULL)
printf("ERRO:FaltadeMemria\n");
else
{
if(d>n==0)
{
p>anterior=NULL;
p>dado=n;
p>posterior=NULL;
d>primeiro=p;
d>n=1;
d>ultimo=p;
}
else
{
q=d>primeiro;
p>anterior=NULL;
p>dado=n;
p>posterior=q;
q>anterior=p;
d>primeiro=p;
d>n=d>n+1;
}
}
}
//insere_direita
voidinsere_direita(structDESCRITOR*d,intn)
{
structELEMENTO*p,*q;
p=(structELEMENTO*)malloc(sizeof(structELEMENTO));
if(p==NULL)
printf("ERRO:Faltadememria\n");
else
{
if(d>n==0)
{
p>anterior=NULL;
p>dado=n;
p>posterior=NULL;
d>primeiro=p;
d>n=1;
d>ultimo=p;
}
else
{
116
q=d>ultimo;
p>anterior=q;
p>dado=n;
p>posterior=NULL;
q>posterior=p;
d>ultimo=p;
d>n=d>n+1;
}
}
}
//exibir_lista_direita
voidexibir_lista_direita(structDESCRITORd)
{
structELEMENTO*p;
p=d.ultimo;
while(p>anterior!=NULL)
{
printf("Valor:%d\n",p>dado);
p=p>anterior;
}
}
//exibir_lista_esquerda
voidexibir_lista_esquerda(structDESCRITORd)
{
structELEMENTO*p;
p=d.primeiro;
while(p>posterior!=NULL)
{
p=p>posterior;
}
}
18.Listadeexercciosgerais
18.1EscrevaumprogramaemCqueexibeumrelgionatela.Oformato
dorelgiodeveserhh:mm:ss.
18.2 Escreva um programa em C que exibe a data na tela. O formato da
datadeveserdd:mm:aaaa.
117
19.Programasexemplosusandoncurses
19.1JogodeCaaPalavras
O jogo de caapalavras abaixo demonstra a utilizao de
bibliotecancursesespecficaparaterminalemmodotexto.
//palavras.c(KubuntuAnjuta)
//Autor:PauloRobertoGomesLuzzardi
//Data:15/06/2006
//includes
#include<string.h>
#include<ctype.h>
#include<curses.h>
#include<signal.h>
#include<stdlib.h>
#include<time.h>
//bibliotecancurses
//definicoes
#defineESC27
#defineENTER13
#defineUP259
#defineDOWN258
#defineLEFT260
#defineRIGHT261
#defineCOR_TEXTOCOLOR_GREEN
#defineCOR_PALAVRACOLOR_GREEN
#defineCOR_PALAVRASCOLOR_BLUE
#defineCOR_TELACOLOR_YELLOW
#defineCOR_XISCOLOR_RED
#defineCOR_ACERTOCOLOR_BLUE
#defineCOR_FINALCOLOR_RED
#defineCOR_RECORDECOLOR_WHITE
#defineCOR_TEMPOCOLOR_RED
#defineCOR_NOMECOLOR_YELLOW
#defineCOR_RELOGIOCOLOR_YELLOW
#defineCOR_PARABENSCOLOR_CYAN
//prototypes
voidtela(void);
voidsorteia_palavras(intn);
voidexibe_palavras(void);
voidexibe_palavras_sorteadas(void);
intprocura_palavra(char*s);
voidfinal(intmin,intseg);
voidtroca(int*x,int*y);
118
voidtempo(intc,intl);
voidrelogio(int*h,int*m,int*s);
intposicao_palavra(intpos);
voidSTRING(intc,intl,intn,char*s);
voidapaga_linha(intc,intl,intn);
voidnovo_recorde(char*s,intmin,intseg);
//prototypes
voidinicializa_janelas(void);
voidfinaliza_janelas(void);
voidclrscr(void);
voidgotoxy(intc,intl);
voidflushall(void);
intRANDOM(intinic,floatfaixa);
voidrandomize(void);
voidtextcolor(intcor);
voidtextcolorlight(intcor);
//inicializa_janelas
voidinicializa_janelas(void)
{
initscr();
//inicializaabibliotecacurses
keypad(stdscr,TRUE);
//mapeamentodoteclado
(void)nonl();
//noconverteNLemCR/NL
(void)cbreak();
//noesperapor\n
(void)echo();
//sadaemcores
if(has_colors())
{
start_color();
init_pair(1,COLOR_RED,COLOR_BLACK);
init_pair(2,COLOR_GREEN,COLOR_BLACK);
init_pair(3,COLOR_YELLOW,COLOR_BLACK);
init_pair(4,COLOR_BLUE,COLOR_BLACK);
init_pair(5,COLOR_CYAN,COLOR_BLACK);
init_pair(6,COLOR_MAGENTA,COLOR_BLACK);
init_pair(7,COLOR_WHITE,COLOR_BLACK);
attrset(COLOR_PAIR(A_BOLD));
}
}
//finaliza_janelas
voidfinaliza_janelas(void)
{
endwin();
system("clear");
}
//clrscr
voidclrscr(void)
{
clear();
refresh();
}
//gotoxy
voidgotoxy(intc,intl)
{
move(l1,c1);
refresh();
}
//flushall
voidflushall(void)
{
getchar();
}
119
//RANDOM
intRANDOM(intinic,floatfaixa)
{
intj;
j=inic+(int)((faixa+1.0)*rand()/(RAND_MAX+1.0));
return(j);
}
//randomize
voidrandomize(void)
{
srand((unsignedint)time((time_t*)NULL));
}
//textcolor
voidtextcolor(intcor)
{
attrset(COLOR_PAIR(cor));
}
//textcolorlight
voidtextcolorlight(intcor)
{
attrset(COLOR_PAIR(cor)+A_BOLD);
}
//variaveis
FILE*fp;
char*nome_arquivo="recorde.pal";
struct{
charnome[31];
intminutos;
intsegundos;
}dados,recorde;
unsignedshortletras[21][61];
#defineNPAL24
#definePSORT8
charfrutas[NPAL][10]={"abacaxi","banana","ameixa","pera","goiaba","amora","bergamota",
"morango","lima","abacate","carambola","laranja","kiwi","tangerina","figo","pitang
a",
"pessego","acerola","cereja","nectarina","pomelo","caqui","caju","marmelo"};
inttemp[NPAL],acertou[NPAL];
charsit[NPAL],palavra[10];
intclick=TRUE,linha[21];
//main
intmain(void)
{
inttecla,acertos=0,troquei;
intl=12,c=40;
intl1,c1,l2,c2,t,x,y,i,j,k,w;
inthi=0,mi=0,si=0;
intma,sa,incrementa=FALSE;
intht,mt,st;
chars[10];
inicializa_janelas();
clrscr();
randomize();
textcolor(COR_TEXTO);
120
tela();
sorteia_palavras(PSORT);
exibe_palavras();
exibe_palavras_sorteadas();
relogio(&hi,&mi,&si);
ma=0;
do{
relogio(&ht,&mt,&st);
sa=stsi;
if(sa<0)
sa=sa+60;
if(sa==58)
incrementa=TRUE;
if(sa==0&&incrementa)
{
ma++;
incrementa=FALSE;
}
textcolor(COR_TEMPO);
gotoxy(30,22);
printw("TempoGasto:%02d:%02d\n",ma,sa);
gotoxy(1,3);
printw("(%2d)Linha",l4);
gotoxy(1,4);
printw("(%2d)Coluna",c19);
gotoxy(1,5);
printw("(%2d)Acertos",acertos);
gotoxy(c,l);
tecla=getch();
gotoxy(30,22);
textcolor(COR_RELOGIO);
tempo(56,1);
if(tecla!=UP&&tecla!=DOWN&&tecla!=LEFT&&tecla!=RIGHT)
{
gotoxy(c,l);
printw("%c",letras[l][c]);
}
if(tecla==ENTER)
{
if(click)
{
l1=l;
c1=c;
textcolorlight(COR_PALAVRA);
gotoxy(c,l);
click=FALSE;
}
else
{
l2=l;
c2=c;
click=TRUE;
if(l1==l2)
{
troquei=FALSE;
if(c2<c1)
{
troca(&c1,&c2);
troquei=TRUE;
}
x=0;
for(t=c1;t<=c2;t++)
{
palavra[x]=letras[l][t];
x++;
}
121
palavra[x]=(char)NULL;
y=procura_palavra(palavra);
if(y!=1)
{
k=0;
j=strlen(frutas[y]);
for(i=0;i<j;i++)
{
s[k]=frutas[y][i];
letras[l][c1+i]=s[k];
k++;
}
s[k]=(char)NULL;
textcolorlight(COR_PALAVRA);
gotoxy(c1,l);
printw("%s",s);
w=posicao_palavra(y);
textcolor(COR_XIS);
gotoxy(2,8+w);
printw("x");
textcolor(COR_ACERTO);
gotoxy(5,8+w);
printw("%s",frutas[y]);
acertos++;
textcolor(COR_TELA);
gotoxy(2,5);
printw("%2d",acertos);
if(acertos==PSORT)
final(ma,sa);
}
else
if(!troquei)
{
letras[l1][c1]=tolower(letras[l1][c1]);
gotoxy(c1,l1);
printw("%c",letras[l1][c1]);
}
else
{
letras[l2][c2]=tolower(letras[l2][c2]);
gotoxy(c2,l2);
printw("%c",letras[l2][c2]);
}
}
}
}
switch(tecla)
{
caseUP:l;
if(l<5)
l=20;
break;
caseDOWN:l++;
if(l>20)
l=5;
break;
caseLEFT:c;
if(c<20)
c=60;
break;
caseRIGHT:c++;
if(c>60)
c=20;
break;
}
}while(tecla!=27);
finaliza_janelas();
return(1);
}
//tela
122
voidtela(void)
{
intc,l;
for(l=0;l<NPAL;l++)
temp[l]=1;
textcolor(COR_TELA);
gotoxy(33,1);
printw("CA%cAPALAVRAS",199);
gotoxy(2,22);
printw("[ESC]Abandona");
refresh();
for(l=5;l<=20;l++)
for(c=20;c<=60;c++)
letras[l][c]=RANDOM(97,25);
gotoxy(20,24);
printw(">Useassetasparaprocurarpalavras<",231);
tempo(56,1);
fp=fopen(nome_arquivo,"r+b");
if(fp!=NULL)
{
fread(&recorde,1,sizeof(recorde),fp);
textcolor(COR_RECORDE);
gotoxy(20,3);
printw("Recordista:");
gotoxy(20,4);
printw("Tempo:");
textcolor(COR_NOME);
gotoxy(32,3);
printw("%s",recorde.nome);
gotoxy(27,4);
printw("%02d:%02d",recorde.minutos,recorde.segundos);
fclose(fp);
}
}
//sorteia_palavras
voidsorteia_palavras(intn)
{
inti,j,t,x,y,z,h=0;
intc,l;
for(i=0;i<NPAL;i++)
{
sit[i]='N';
acertou[i]=TRUE;
}
for(i=0;i<=20;i++)
linha[i]=1;
i=1;
l=RANDOM(5,15);
linha[l]=l;
do{
j=RANDOM(0,NPAL1);
if(sit[j]=='N')
{
t=strlen(frutas[j]);
c=RANDOM(20,30);
y=c+t;
if(y>60)
c=ct;
x=0;
for(z=c;z<c+t;z++)
{
letras[l][z]=frutas[j][x];
x++;
}
sit[j]='S';
temp[h]=j;
h++;
123
i++;
l=RANDOM(5,15);
while(linha[l]!=1)
{
l++;
if(l>=20)
l=5;
}
linha[l]=l;
}
}while(i<=n);
}
//exibe_palavras
voidexibe_palavras(void)
{
intc,l;
for(l=5;l<=20;l++)
for(c=20;c<=60;c++)
{
gotoxy(c,l);
}
}
//exibe_palavras_sorteadas
voidexibe_palavras_sorteadas(void)
{
intt,l=8;
textcolorlight(COR_PALAVRAS);
for(t=0;t<NPAL;t++)
if(temp[t]!=1)
{
gotoxy(1,l);
printw("[]%s",frutas[temp[t]]);
l++;
}
}
//procura_palavra
intprocura_palavra(char*s)
{
intt,i,j,n;
charr[10];
n=strlen(s);
for(i=0;i<n;i++)
s[i]=toupper(s[i]);
for(t=0;t<NPAL;t++)
{
n=strlen(frutas[t]);
j=0;
for(i=0;i<n;i++)
{
r[j]=toupper(frutas[t][i]);
j++;
}
r[j]=(char)NULL;
i=(int)strcmp(r,s);
if(i==0&&acertou[t])
{
acertou[t]=FALSE;
return(t);
}
}
124
return(1);
}
//final
voidfinal(intmin,intseg)
{
chartecla;
intc,l,i;
intsegundos_recorde,segundos_atual;
fp=fopen(nome_arquivo,"r+b");
if(fp==NULL)
{
fp=fopen(nome_arquivo,"w+b");
if(fp!=NULL)
{
gotoxy(20,22);
printw("QualoseuNome:______________________________");
STRING(37,22,30,dados.nome);
dados.minutos=min;
dados.segundos=seg;
fwrite(&dados,1,sizeof(dados),fp);
novo_recorde(dados.nome,dados.minutos,dados.segundos);
fclose(fp);
}
}
else
{
segundos_recorde=recorde.segundos+recorde.minutos*60;
segundos_atual=seg+min*60;
if(segundos_atual<segundos_recorde)
{
gotoxy(20,22);
printw("QualoseuNome:______________________________");
STRING(37,22,30,dados.nome);
dados.minutos=min;
dados.segundos=seg;
fwrite(&dados,1,sizeof(dados),fp);
fclose(fp);
novo_recorde(dados.nome,dados.minutos,dados.segundos);
}
}
textcolorlight(COR_FINAL);
for(l=5;l<=20;l++)
for(c=20;c<=60;c++)
{
gotoxy(c,l);
printw(">Winner");
for(i=0;i<=900000;i++);//pausa
}
apaga_linha(20,22,50);
gotoxy(27,22);
printf("TEMPOGASTO[%02d:%02d]",min,seg);
gotoxy(24,24);
printw("Tecle[ENTER]parafinalizar");
do{
tecla=getch();
}while(tecla!=ENTER&&tecla!=ESC);
system("clear");
endwin();
exit(1);
}
//novo_recorde
voidnovo_recorde(char*s,intmin,intseg)
{
125
gotoxy(20,3);
printw("Recordista:");
gotoxy(20,4);
printw("Tempo:");
textcolorlight(COR_PARABENS);
gotoxy(30,22);
printw("NOVORECORDE,PARAB%cNS",201);
textcolor(COR_NOME);
gotoxy(32,3);
printw("%s",s);
gotoxy(27,4);
printw("%02d:%02d",min,seg);
}
//troca
voidtroca(int*x,int*y)
{
intt;
t=*x;
*x=*y;
*y=t;
}
//tempo
voidtempo(intc,intl)
{
time_tnow;
chars[30];
time(&now);
strcpy(s,ctime(&now));
gotoxy(c,l);
printw("%s",s);
}
//relogio
voidrelogio(int*h,int*m,int*s)
{
time_tnow;
charst[30],temp[5];
inti,x;
time(&now);
strcpy(st,ctime(&now));
x=0;
for(i=11;i<=12;i++)
{
temp[x]=st[i];
x++;
}
temp[x]=(char)NULL;
*h=atoi(temp);
x=0;
for(i=14;i<=15;i++)
{
temp[x]=st[i];
x++;
}
temp[x]=(char)NULL;
*m=atoi(temp);
x=0;
for(i=17;i<=18;i++)
{
temp[x]=st[i];
x++;
126
}
temp[x]=(char)NULL;
*s=atoi(temp);
}
//posicao_palavra
intposicao_palavra(intpos)
{
inti;
for(i=0;i<PSORT;i++)
if(temp[i]==pos)
return(i);
return(1);
}
//STRING
voidSTRING(intc,intl,intn,char*s)
{
chartecla;
inti=0;
do{
gotoxy(c,l);
tecla=getch();
gotoxy(c,l);
printw("");
gotoxy(c,l);
if((tecla>='A'&&tecla<='Z')||(tecla>='a'&&tecla<='z')||tecla==32)
{
gotoxy(c,l);
printw("%c",tecla);
s[i]=tecla;
i++;
c++;
}
if(tecla==127&&i>=1)
{
i;
s[i]=(char)NULL;
c;
gotoxy(c,l);
printw("");
}
}while(tecla!=ENTER&&i<n);
s[i]=(char)NULL;
}
//apaga_linha
voidapaga_linha(intc,intl,intn)
{
inti;
gotoxy(c,l);
for(i=1;i<=n;i++)
printw("");
}
19.2RelgioemLinux
O seguinte programa demonstra a utilizao da biblioteca
time.hexibindoumrelgionatela.
A biblioteca time.h possui dois tipos de dados que suportam
informaotemporal:
127
time_t: possui a informao de calendrio (data + hora) num nico

nmero que representa um instante de tempo. Este nmero representa o
totaldesegundosquepassaramdesdeaszerohorasde1deJaneirode
1970(adatazeroparaossistemasUNIX).
struct tm: usado para representar um instante de tempo no formato
divididoporclasses(dia,ms,ano,hora,data,etc).
structtm{
inttm_sec;
//segundos[0..59]
inttm_min;
//minutos[0..59]
inttm_hour;
//hours[0..23]
inttm_mday; //diadoms[1..31]
inttm_mon;
//ms(mesesdesdeJaneiro)[0..11]
inttm_year; //ano(desde1900)[0..]
inttm_wday; //diadasemana(desdeDomingo)[0..6]
inttm_yday; //diadoano(desde1Janeiro)[0..365]
inttm_isdst;
//informaosobremudanadahora
};
A funo time() obtm a informao do relgio do sistema
operacionalLinuxeretornanoformatotime_t.
Prottipodafuno:time_ttime(time_t*t);
A funo localtime() obtm a informao do relgio do sistema
operacionalLinuxnoformatostructtm.
Sintaxedafuno:structtmlocaltime(time_t*t);
//relogio.c
#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#defineESC27
intmain(void)
{
time_ttempo;
structtm*data;
inth,m,s;
chartecla;
do{
time(&tempo);
printf("Dataemsegundos:%ld\n",(long)tempo);
data=localtime(&tempo);
printf("DatadeHoje\n");
printf("Dia:%d\n",data>tm_mday);
printf("Mes:%d\n",data>tm_mon+1);
printf("Ano:%d\n",data>tm_year+1900);
printf("HorarioAtual:\n");
128
h=data>tm_hour;
m=data>tm_min;
s=data>tm_sec;
printf("Horas:%d\n",h);
printf("Minutos:%d\n",m);
printf("Segundos:%d\n",s);
printf("[ESC]Abandona[ENTER]Atualiza:");
tecla=getchar();
}while(tecla!=ESC);
}
19.3Bibliotecaconio.h+clock.c
Abaixo mostrado uma biblioteca que simula as principais
funes da biblioteca conio.h, tais como: clrscr, gotoxy, flushall,
random,randomize,delay,textcolor,textcolorlightekbhit.
ProttiposdaFunesdestabiblioteca:
voidclrscr(void);
voidflushall(void);
intrandom(intn);
voiddelay(intespera);
intkbhit(void);
//conio.h
//includes
#include<curses.h>
#include<signal.h>
#include<time.h>
#include<sys/select.h>
//cores
#defineBLACKCOLOR_BLACK
#defineREDCOLOR_RED
#defineGREENCOLOR_GREEN
#defineYELLOWCOLOR_YELLOW
#defineBLUECOLOR_BLUE
#defineMAGENTACOLOR_MAGENTA
#defineCYANCOLOR_CYAN
#defineWHITECOLOR_WRITE
//prototypes
voidinitconio(void);
voidendconio(void);
voidclrscr(void);
voidflushall(void);
intrandom(intn);
voiddelay(intespera);
intkbhit(void);
129
//initconio
voidinitconio(void)
{
initscr();
(void)nonl();
(void)cbreak();
(void)echo();
if(has_colors())
{
start_color();
}
}
//endconio
voidendconio(void)
{
endwin();
system("clear");
}
//clrscr
voidclrscr(void)
{
clear();
refresh();
}
//gotoxy
{
move(l1,c1);
refresh();
}
//flushall
voidflushall(void)
{
getchar();
}
//random
intrandom(intn)
{
intt;
t=rand()%n;
return(t);
}
//randomize
voidrandomize(void)
{
}
130
//delay
voiddelay(intespera)
{
clock_tt;
t=clock()+espera;
while(clock()<=t);
}
//textcolor
{
}
//textcolorlight
{
}
//kbhit
intkbhit(void)
{
structtimevaltv;
fd_setread_fd;
tv.tv_sec=0;
tv.tv_usec=0;
FD_ZERO(&read_fd);
FD_SET(0,&read_fd);
if(select(1,&read_fd,NULL,NULL,&tv)==1)
return(0);
if(FD_ISSET(0,&read_fd))
return(1);
return(0);
}
ProgramaPrincipal:clock.c
//clock.c
//includes
#include<stdio.h>
#include"conio.h"
#include<time.h>
//main
intmain(void)
{
time_ttempo;
structtm*data;
inth,m,s;
chartecla;
initconio(); //funoobrigatria
clrscr();
textcolor(BLUE);
do{
time(&tempo);
data=localtime(&tempo);
h=data>tm_hour;
m=data>tm_min;
s=data>tm_sec;
gotoxy(1,1);
printw("Hora:%02d:%02d:%02d",h,m,s);
131
}while(!kbhit());
endconio();
//funoobrigatria
}
19.4Bibliotecaconio.hcompleta
Abaixo mostrado uma biblioteca que simula as principais
funesdabibliotecaconio.h.
ProttiposdasFunesdestabiblioteca:
voiddoneconio(void);
voidnocursor(void);
voidcursor(void);
intwherex(void);
intwherey(void);
intputch(intc);
intgetche(void);
intkey(void);
intkbhit(void);
intcprintf(char*format,...);
intcscanf(constchar*format,...);
voidclreol(void);
voidclrscr(void);
voidgotoxy(intx,inty);
voiddelline(void);
voidgettextinfo(structtext_info*r);
voidhighvideo(void);
voidinsline(void);
voidlowvideo(void);
voidnormvideo(void);
voidtextattr(intattribute);
voidtextbackground(intcolor);
voidtextcolor(intcolor);
voidtextmode(intunused_mode);
voidwindow(intleft,inttop,intright,intbottom);
voidcputs(char*str);
char*cgets(char*str);
Biblioteca:conio.h
//conio.h
#include<stdarg.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<curses.h>
#include<pwd.h>
intdirectvideo;
charcolor_warning;
132
WINDOW*conio_scr;
structtext_info{
unsignedcharwinleft;
unsignedcharwintop;
unsignedcharwinright;
unsignedcharwinbottom;
unsignedcharattribute;
unsignedcharnormattr;
unsignedcharcurrmode;
unsignedcharscreenheight;
unsignedcharscreenwidth;
unsignedcharcurx;
unsignedcharcury;
};
enumtext_modes{LASTMODE=1,BW40=0,C40,BW80,C80,MONO=7,C4350=64};
enumCOLORS{BLACK,BLUE,GREEN,CYAN,RED,MAGENTA,BROWN,LIGHTGRAY,
DARKGRAY,LIGHTBLUE,LIGHTGREEN,LIGHTCYAN,LIGHTRED,LIGHTMAGENTA,YELLOW,WHITE};
#defineBLINK128
voiddoneconio(void);
voidnocursor(void);
voidcursor(void);
intwherex(void);
intwherey(void);
intputch(intc);
intgetche(void);
intkey(void);
intkbhit(void);
intcprintf(char*format,...);
intcscanf(constchar*format,...);
unsignedinp(unsignedport);
unsignedinpw(unsignedport);
unsignedoutp(unsignedport,unsignedvalue);
unsignedoutpw(unsignedport,unsignedvalue);
unsignedinpd(unsignedport);
unsignedoutpd(unsignedport,unsignedvalue);
voidclreol(void);
voidclrscr(void);
voidgotoxy(intx,inty);
voiddelline(void);
voidgettextinfo(structtext_info*r);
voidhighvideo(void);
voidinsline(void);
voidlowvideo(void);
voidnormvideo(void);
voidtextattr(intattribute);
voidtextbackground(intcolor);
voidtextcolor(intcolor);
voidtextmode(intunused_mode);
voidwindow(intleft,inttop,intright,intbottom);
voidcputs(char*str);
char*cgets(char*str);
staticinttxtattr,oldattr;
staticintfgc,bgc;
staticintinitialized=0;
charcolor_warning=1;
intdirectvideo;
WINDOW*conio_scr;
intcolortab(inta)
{
133
switch(a)
{
case0:returnCOLOR_BLACK;
case1:returnCOLOR_BLUE;
case2:returnCOLOR_GREEN;
case3:returnCOLOR_CYAN;
case4:returnCOLOR_RED;
case5:returnCOLOR_MAGENTA;
case6:returnCOLOR_YELLOW;
case7:returnCOLOR_WHITE;
}
}
voiddocolor(intcolor)
{
wattrset(conio_scr,0);
if((color&128)==128)
txtattr=A_BLINK;
else
txtattr=A_NORMAL;
if((color&15)>7)
txtattr|=A_STANDOUT;
else
txtattr|=A_NORMAL;
txtattr|=COLOR_PAIR((1+(color&7)+(color&112))>>1);
if(((color&127)==15)|((color&127)==7))
txtattr=COLOR_PAIR(0);
if(((color&127)==127)|((color&127)==119))
txtattr=COLOR_PAIR(8);
wattron(conio_scr,txtattr);
wattron(conio_scr,COLOR_PAIR(1+(color&7)+((color&112)>>1)));
}
staticinlineintinport(intport)
{
unsignedcharvalue;
__asm__volatile("inb%1,%0"
:"=a"(value)
:"d"((unsignedshort)port));
returnvalue;
}
staticinlineintinportd(intport)
{
unsignedintvalue;
__asm__volatile("inl%1,%0"
:"=a"(value)
returnvalue;
}
staticinlineintinportw(intport)
{
unsignedshortvalue;
__asm__volatile("inw%1,%0"
:"=a"(value)
returnvalue;
}
staticinlinevoidoutport(unsignedshortintport,unsignedcharval)
{
__asm__volatile(
"outb%0,%1\n"
:
:"a"(val),"d"(port)
);
}
staticinlinevoidoutportw(unsignedshortintport,unsignedintval)
{
__asm__volatile(
134
"outw%0,%1\n"
:
:"a"(val),"d"(port)
);
}
staticinlinevoidoutportd(unsignedshortintport,unsignedintval)
{
__asm__volatile(
"outl%0,%1\n"
:
:"a"(val),"d"(port)
);
}
voidinitconio(void)
{
intx,y;
attr_tdummy1;
shortdummy2;
initialized=1;
initscr();
start_color();
oldattr=wattr_get(stdscr,&dummy1,&dummy2,NULL);
nonl();
raw();
if(!has_colors()&(color_warning>1))
fprintf(stderr,"Ateno:Problemacomacor\n");
noecho();
conio_scr=newwin(0,0,0,0);
keypad(conio_scr,TRUE);
meta(conio_scr,TRUE);
idlok(conio_scr,TRUE);
scrollok(conio_scr,TRUE);
for(y=0;y<=7;y++)
for(x=0;x<=7;x++)
init_pair((8*y)+x+1,colortab(x),colortab(y));
txtattr=wattr_get(conio_scr,&dummy1,&dummy2,NULL);
bgc=0;
textcolor(7);
textbackground(0);
}
voiddoneconio(void)
{
endwin();
}
char*cgets(char*str)
{
charstrng[257];
unsignedchari=2;
if(initialized==0)
initconio();
echo();
strncpy(strng,str,1);
wgetnstr(conio_scr,&strng[2],(int)strng[0]);
while(strng[i]!=0)
i++;
i=i2;
strng[1]=i;
strcpy(str,strng);
noecho();
return(&str[2]);
}
voidclreol(void)
{
if(initialized==0)
initconio();
135
wclrtoeol(conio_scr);
wrefresh(conio_scr);
}
voidclrscr(void)
{
if(initialized==0)
initconio();
wclear(conio_scr);
wmove(conio_scr,0,0);
}
intcprintf(char*format,...)
{
inti;
charbuffer[BUFSIZ];
va_listargp;
if(initialized==0)
initconio();
va_start(argp,format);
vsprintf(buffer,format,argp);
va_end(argp);
i=waddstr(conio_scr,buffer);
return(i);
}
voidcputs(char*str)
{
if(initialized==0)
initconio();
waddstr(conio_scr,str);
}
intcscanf(constchar*format,...)
{
inti;
charbuffer[BUFSIZ];
va_listargp;
if(initialized==0)
initconio();
echo();
if(wgetstr(conio_scr,buffer)==ERR)
return(1);
va_start(argp,format);
i=vsscanf(buffer,format,argp);
va_end(argp);
noecho();
return(i);
}
voiddelline(void)
{
if(initialized==0)
initconio();
wdeleteln(conio_scr);
}
voidcursor(void)
{
curs_set(1);
}
voidnocursor(void)
{
curs_set(0);
}
136
intkey(void)
{
inti;
if(initialized==0)
initconio();
i=wgetch(conio_scr);
if(i==1)
i=0;
returni;
}
intgetche(void)
{
inti;
if(initialized==0)
initconio();
echo();
if(i==1)
i=0;
noecho();
return(i);
}
voidgettextinfo(structtext_info*inforec)
{
attr_tdummy1;
shortdummy2;
unsignedcharxp,yp;
unsignedcharx1,x2,y1,y2;
unsignedcharcols,lines;
unsignedchardattr,dnattr,a;
if(initialized==0)
initconio();
getyx(conio_scr,yp,xp);
getbegyx(conio_scr,y1,x1);
getmaxyx(conio_scr,y2,x2);
dattr=(bgc*16)+fgc;
a=wattr_get(conio_scr,&dummy1,&dummy2,NULL);
if(a==(a&A_BLINK))
dattr=dattr+128;
dnattr=oldattr;
inforec>winleft=x1+1;
inforec>wintop=y1+1;
if(x1==0)
x2;
if(y1==0)
y2;
inforec>winright=x1+x2+1;
inforec>winbottom=y1+y2+1;
inforec>curx=xp+1;
inforec>cury=yp+1;
inforec>screenheight=y2+1;
inforec>screenwidth=x2+1;
inforec>currmode=3;
inforec>normattr=dnattr;
inforec>attribute=dattr;
}
voidgotoxy(intx,inty)
{
if(initialized==0)
initconio();
y;
x;
wmove(conio_scr,y,x);
}
137
voidhighvideo(void)
{
if(initialized==0)
initconio();
textcolor(15);
textbackground(0);
}
voidinsline(void)
{
if(initialized==0)
initconio();
winsertln(conio_scr);
}
intkbhit(void)
{
inti;
if(initialized==0)
initconio();
nodelay(conio_scr,TRUE);
nodelay(conio_scr,FALSE);
if(i==1)
i=0;
return(i);
}
voidlowvideo(void)
{
if(initialized==0)
initconio();
textbackground(0);
textcolor(8);
}
voidnormvideo(void)
{
if(initialized==0)
initconio();
wattrset(conio_scr,oldattr);
}
intputch(intc)
{
if(initialized==0)
initconio();
if(waddch(conio_scr,c)!=ERR)
{
return(c);
}
return(0);
}
voidtextattr(intattr)
{
if(initialized==0)
initconio();
docolor(attr);
}
voidtextbackground(intcolor)
{
if(initialized==0)
initconio();
bgc=color;
color=(bgc*16)+fgc;
docolor(color);
138
}
voidtextcolor(intcolor)
{
if(initialized==0)
initconio();
fgc=color;
color=(bgc*16)+fgc;
docolor(color);
}
voidtextmode(intmode)
{
if(initialized==0)
initconio();
}
intwherex(void)
{
inty;
intx;
if(initialized==0)
initconio();
getyx(conio_scr,y,x);
x++;
return(x);
}
intwherey(void)
{
inty;
intx;
if(initialized==0)
initconio();
getyx(conio_scr,y,x);
y++;
return(y);
}
voidwindow(intleft,inttop,intright,intbottom)
{
intnlines,ncols;
if(initialized==0)
initconio();
delwin(conio_scr);
top;
left;
right;
bottom;
nlines=bottomtop;
ncols=rightleft;
if(top==0)
nlines++;
if(left==0)
ncols++;
if((nlines<1)|(ncols<1))
return;
conio_scr=newwin(nlines,ncols,top,left);
keypad(conio_scr,TRUE);
meta(conio_scr,TRUE);
idlok(conio_scr,TRUE);
scrollok(conio_scr,TRUE);
}
Programa:cores.c
//cores.c
139
#include<stdio.h>
#include"conio.h"
intmain(void)
{
intcor;
initconio(); //funoobrigatria
clrscr();
nocursor();
for(cor=1;cor<=15;cor++)
{
textcolor(cor);
gotoxy(10,10);
cprintf("UniversidadeCatlicadePelotas");
getche();
}
cursor();
doneconio(); //funoobrigatria
}
19.5JogodaForca
O jogo da forca demonstra tambm a utilizao de biblioteca
ncursesespecficaparaterminalemmodotexto.
140
141
//forca.c(KubuntuAnjuta)
//Autor:PauloRobertoGomesLuzzardi
//Data:17/06/2006
//includes
#include<string.h>
#include<curses.h>
#include<stdlib.h>
#include<time.h>
//definicoes
#defineESC27
#defineENTER13
#defineSPACE32
#defineLEFT260
#defineRIGHT261
#defineBLACKCOLOR_BLACK
#defineREDCOLOR_BLUE
#defineGREENCOLOR_GREEN
#defineBROWNCOLOR_YELLOW
#defineBLUECOLOR_BLUE
#defineMAGENTACOLOR_MAGENTA
#defineCYANCOLOR_CYAN
#defineWHITECOLOR_WHITE
#defineCOR_TEXTO
#defineCOR_TELA
#defineCOR_TEMPO
#defineCOR_RELOGIO
#defineCOR_WINNER
#defineCOR_LETRAS
#defineCOR_SELECAO
#defineCOR_TITULO
#defineCOR_STATUS
GREEN
BROWN
RED
BROWN
CYAN
BLUE
RED
MAGENTA
WHITE
//prototypes
voidtela(void);
voidfinal(intmin,intseg);
voidtroca(int*x,int*y);
voidtempo(intc,intl);
voidrelogio(int*h,int*m,int*s);
142
voidSTRING(intc,intl,intn,char*s);
voidapaga_linha(intc,intl,intn);
voidboneco(interro);
//prototypes
voidinicializa_janelas(void);
voidfinaliza_janelas(void);
voidclrscr(void);
voidflushall(void);
intRandom(intn);
//inicializa_janelas
voidinicializa_janelas(void)
{
initscr();
(void)nonl();
(void)cbreak();
(void)echo();
if(has_colors())
{
start_color();
}
}
//finaliza_janelas
voidfinaliza_janelas(void)
{
endwin();
system("clear");
}
//clrscr
voidclrscr(void)
{
clear();
refresh();
}
//gotoxy
{
move(l1,c1);
refresh();
}
//flushall
voidflushall(void)
{
getchar();
}
//Random
143
intRandom(intn)
{
intt;
t=rand()%n;
return(t);
}
//randomize
voidrandomize(void)
{
}
//textcolor
{
}
//textcolorlight
{
}
//tempo
voidtempo(intc,intl)
{
time_tnow;
chars[30];
time(&now);
strcpy(s,ctime(&now));
gotoxy(c,l);
printw("%s",s);
}
//relogio
voidrelogio(int*h,int*m,int*s)
{
time_tnow;
charst[30],temp[5];
inti,x;
time(&now);
strcpy(st,ctime(&now));
x=0;
for(i=11;i<=12;i++)
{
temp[x]=st[i];
x++;
}
temp[x]=(char)NULL;
*h=atoi(temp);
x=0;
for(i=14;i<=15;i++)
{
temp[x]=st[i];
x++;
}
temp[x]=(char)NULL;
*m=atoi(temp);
x=0;
for(i=17;i<=18;i++)
{
144
temp[x]=st[i];
x++;
}
temp[x]=(char)NULL;
*s=atoi(temp);
}
//variaveis
unsignedshortletras[21][61];
#defineNPAL30
#definePSORT8
#defineNTIPOS4
charnomes[NTIPOS][10]={"Cidades","Pases","Carros","Frutas"};
char cidades[NPAL][11] = {"pelotas", "alegrete", "uruguaiana", "livramento", "chui",
"rivera", "chuy", "piratini", "candiota", "marau", "erechin", "cachoerinha", "caxias",
"gramado", "canela", "itaqui", "cacequi", "formigueiro", "parati", "buzios", "torres",
"mostarda",
"tapes",
"agudo","candiota","chiapeta","cassino","casca","cristal","cidreira"};
char paises[NPAL][11] = {"brasil", "peru", "uruguai", "argentina", "bolivia", "chile",
"guatemala","cuba","alemanha","suecia","inglaterra","china","russia","montenegro",
"tibet", "nepal", "servia", "noruega", "portugal", "espanha", "grecia", "mongolia",
"escocia","palestina","israel","iraqui","australia","jamaica","egito","congo"};
charcarros[NPAL][11]={"mercedes","fusca","dodge","palio","omega","kombi","fiat",
"ford", "dakota", "bmw", "ka", "elba", "gol", "golf", "vectra", "sportage", "idea",
"corcel", "parati", "saveiro", "peuget", "citroen", "toyota", "nissan", "renaut",
"frontier","honda","subaru","corrola","civic"};
char frutas[NPAL][11] = {"abacaxi", "banana", "ameixa", "pera", "goiaba", "amora",
"bergamota", "morango", "lima", "abacate", "carambola", "laranja", "kiwi", "tangerina",
"figo", "pitanga", "framboesa", "acerola", "cereja", "nectarina", "pomelo", "caqui",
"caju","marmelo","uva","nectarina","damasco","manga","jaca","jabuticaba"};
//main
intmain(void)
{
intclick,sai,acertou;
inttecla,i,j,k,m,n;
intc,l;
inthi,mi,si;
intma,sa,incrementa;
intht,mt,st;
chars[10],ch;
charpalavra[10],vetor[26];
introw,col,lin,acertos,erros,total;
inicializa_janelas();
getmaxyx(stdscr,row,col); //tamanhodoterminal
do{
ch='A';
acertos=0;
total=0;
erros=0;
sai=FALSE;
incrementa=FALSE;
click=TRUE;
c=16;
l=20;
hi=mi=si=0;
clrscr();
textcolor(WHITE);
gotoxy(60,24);
printw(|row:%d|col:%d|,row,col);
randomize();
145
tela();
for(i=0;i<=25;i++)
vetor[i]='*';
relogio(&hi,&mi,&si);
ma=0;
j=Random(NPAL);
m=Random(NTIPOS);
switch(m)
{
case0:strcpy(palavra,cidades[j]);
break;
case1:strcpy(palavra,paises[j]);
break;
case2:strcpy(palavra,carros[j]);
break;
case3:strcpy(palavra,frutas[j]);
break;
}
textcolor(GREEN);
gotoxy(1,1);
printw("Tipo:");
textcolorlight(GREEN);
gotoxy(7,1);
printw("%s",nomes[m]);
n=strlen(palavra);
gotoxy(20,10);
printf("PALAVRA:");
for(i=0;i<n;i++)
printw("_");
textcolorlight(BROWN);
gotoxy(1,4);
printw("Acertos:");
gotoxy(1,5);
printw("Erros:");
do{
relogio(&ht,&mt,&st);
textcolorlight(COR_STATUS);
gotoxy(10,4);
printw("%d",acertos);
gotoxy(10,5);
printw("%d",erros);
sa=stsi;
if(sa<0)
sa=sa+60;
if(sa==58)
incrementa=TRUE;
if(sa==0&&incrementa)
{
ma++;
incrementa=FALSE;
}
gotoxy(30,22);
gotoxy(c,l);
tecla=getch();
if(tecla==ESC)
sai=TRUE;
gotoxy(30,22);
tempo(56,1);
switch(tecla)
{
caseLEFT: c=2;
ch;
if(c<16)
{
c=66;
ch='Z';
}
146
break;
caseRIGHT:c+=2;
ch++;
if(c>66)
{
c=16;
ch='A';
}
break;
caseENTER:
caseSPACE: textcolor(COR_LETRAS);
gotoxy(34,18);
printw("Caracter:[%c]",ch);
textcolorlight(GREEN);
gotoxy(c,l);
printw("%c",ch);
textcolor(COR_SELECAO);
col=29;
lin=10;
acertou=FALSE;
k=ch65;
for(i=0;i<n;i++)
{
if(toupper(palavra[i])==ch)
{
gotoxy(col,lin);
printw("%c",ch);
if(!acertou&&vetor[k]=='*')
acertos++;
total++;
vetor[k]='#';
acertou=TRUE;
}
col=col+2;
}
if(!acertou&&vetor[k]=='*')
{
erros++;
vetor[k]='#';
}
boneco(erros);
if(total==n)
{
textcolor(COR_WINNER);
gotoxy(50,10);
printw("(Winner)");
gotoxy(30,24);
sai=TRUE;
printw("JogarNovamente[S/n]?");
do{
tecla=getch();
}while(!strchr("SsNn",tecla)&&tecla!=ESC);
}
break;
}
if(erros==5)
{
textcolorlight(RED);
gotoxy(34,14);
printw("%s",palavra);
textcolor(COR_WINNER);
gotoxy(50,10);
printw("(Looser)");
gotoxy(30,24);
sai=TRUE;
printw("JogarNovamente[S/n]?");
do{
tecla=getch();
}while(!strchr("SsNn",tecla)&&tecla!=ESC);
}
}while(!sai);
}while(strchr("Ss",tecla)&&tecla!=ESC);
147
finaliza_janelas();
return(1);
}
//tela
voidtela(void)
{
textcolor(COR_TITULO);
gotoxy(33,1);
printw("JogodaForca",199);
gotoxy(2,22);
printw("[ESC]Abandona");
refresh();
textcolorlight(COR_LETRAS);
gotoxy(16,20);
printw("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
tempo(56,1);
}
//boneco
voidboneco(interro)
{
intcol=60,lin=10;
switch(erro)
{
case1:gotoxy(col,lin);
printw("O");
break;
case2:gotoxy(col,lin+1);
printw("/|");
break;
printw("/|\\");
break;
printw("/");
break;
printw("/\\");
break;
}
}
148
20.Bibliotecancurses
20.1ConceitosBsicos
No linux necessrio incluir a biblioteca curses para criar
programas que executem em terminais em modo texto. Por linha de
comandoficaassim:
$gccpalavras.copalavraslcurses<enter>
...DefiniesdeCompilaoeLink......Bibliotecas...curses
(Screenhandlingandoptimizationroutines)...Adicionar.
umabibliotecaquepermiteconstruirumainterfacetextualem
terminaisLinuxemmodotexto,paraprogramaescritosemlinguagemde
programaoC.
A biblioteca ncurses permite a manipulao de janelas em um
terminalemmodotexto.
JanelassodefinidascomoponteirosparaotipoWINDOW.
Ajanelapadrochamadastdscr.
A biblioteca disponibiliza o nmero de linhas da janela stdscr
emLINESeonmerodecolunasemCOLS.
A primeira funo a ser utilizada, obrigatoriamente a funo
initscr().
Altimafunodeveserendwin().
Paraatualizarajanelastdscrutilizaseafunorefresh.
Declaraodeumajanela:WINDOW*win;
Funo:initscr()
Uso:inicializaabibliotecancurses
Sintaxe:WINDOW*initscr(void);
Retorno:nada
Funo:endwin()
Uso:finalizaabibliotecancurses
Sintaxe:intendwin(void);
Retorno:OK(sucesso)ouERR(erro)
Funo:printw()
Uso:imprimenoterminal
Sintaxe:intprintw(char*format,...);
Retorno:OK(sucesso)
Funo:refresh()
Uso:atualizaajanela
Sintaxe:intrefresh(void);
149
#include<curses.h>
intmain(void)
{
initscr();
//inicializaabibliotecancurses
printw("Bibliotecancurses\n");
printw("Data:%02d/%02d/%02d\n",18,6,2006);
refresh();
getchar();
endwin();
}
//finalizaabibliotecancurses
Funo:getmaxyx()
Uso:verificaronmerodelinhasecolunasdoterminal
Sintaxe:voidgetmaxyx(WINDOW*win,introw,intcol);
Retorno:nada
Funo:mvprintw()
Uso:imprimenoterminal
Sintaxe:intmvprintw(intlin,intcol,char*format,...);
Retorno:OK(sucesso)
Funo:cbreak
Uso:Desabilitaocachedeteclado,fazendocomquetoquesdasteclas
fiquemdisponveisparaoprogramacursesassimquerealizados.
Sintaxe:intcbreak(void);
Funo:keypad()
Uso:Habilitaoudesabilitaaleituradeteclasespeciaisdoteclado
Sintaxe:intkeypad(WINDOW*win,boolbuffer);
Observao:buffer=TRUE>habilitaasteclasespeciais
buffer=FALSE>desabilitaasteclasespeciais
Funo:clear()
Uso:limpaajanelanoterminal
Sintaxe:intclear(void);
Retorno:OK(sucesso)
#include<curses.h>
intmain(void)
{
introw,col;
initscr();
clear();
getmaxyx(stdscr,row,col);
mvprintw(1,1,"|row:%d|col:%d|",row,col);
mvprintw(2,1,"|LINES:%d|COLS:%d|",LINES,COLS);
150
refresh();
getchar();
endwin();
}
Funo:move()
Uso:moveocursorparaaposio(lin,col)
Sintaxe:intmove(intlin,intcol);
move(10,7);
printw(JogodaForca);
refresh();
Funo:getch()
Uso:Lumcaracterenoteclado
Sintaxe:intgetch(void);
Retorno:caracterouERR(erro)
Observao: Em modo nodelay, retorna o caracter imediatamente (se
nenhumateclafoipressionada,retornaERR).Nomododelayesperaat
queumateclasejapressionada
Funo:nonl()
Uso:Desabilitaaconversodateclaenterem'\n'aoleroteclado
Sintaxe:intnonl(void);
Funo:noecho()
Uso: Desabilita o eco de teclas pressionadas para a tela (na aparece
natelaasteclasdigitadas)
Sintaxe:intnoecho(void);
Funo:nodelay()
Uso: Habilita ou desabilita o modo nodelay, em que qualquer toque de
teclaenviadoaoprogramaimediatamente(emvezdeesperarumenter)
Sintaxe:intnodelay(WINDOW*win,boolbuffer);
Observao:buffer=TRUE>habilitaomodonodelay
buffer=FALSE>desabilitaomodonodelay
20.2Funesdeinicializao
initscr():primeirafunoobrigatriaafuno.
keypad():Habilitaaleituradasteclasenter,esc,setas,F1.
Habilitar:keypad(stdscr,TRUE);
Desabilitar:keypad(stdscr,FALSE);
cbreak(): desabilita a propriedade do terminal em ficar esperando o
usuriodigitarenter.
151
curs_set():utilizadoparadefinirotipodecursor:
(0) cursorinvisvel
(1) cursorvisvel
(2) cursormuitovisvel.
echo() ou noecho(): com echo() as teclas digitadas aparecem no
terminal,casocontrrio,emnoecho()asteclasdigitadasnoaparecem
natela.
20.3Funesdeentrada
Existemtrstiposdefunesdeentradanabibliotecancurses:
getch():Lumcaracter
scanw():Lumastringformatada
getstr():Lstrings
getch():lumcaracterdoteclado
intgetch(void);
intwgetch(WINDOW*win);
intmvgetch(inty,intx);
intmvwgetch(WINDOW*win,inty,intx);
Estasfunespermitemlerumnicocaracteredoterminal.Elas
dependemdasfunes:cbreakenoecho.
cbreak(); a leiturados caracteres s comea quando atecla enter ser
pressionada
noecho(); se esta funo estiver ativa, os caracteres digitados no
apareceronatela
scanw():Lumastringformatada
intscanw(char*fmt[,arg]...);
intwscanw(WINDOW*win,char*fmt[,arg]...);
intmvscanw(inty,intx,char*fmt[,arg]...);
intmvwscanw(WINDOW*win,inty,intx,char*fmt[,arg]...);
getstr():Lstringviateclado
intgetstr(char*str);
intgetnstr(char*str,intn);
intwgetstr(WINDOW*win,char*str);
intwgetnstr(WINDOW*win,char*str,intn);
intmvgetstr(inty,intx,char*str);
intmvwgetstr(WINDOW*win,inty,intx,char*str);
intmvgetnstr(inty,intx,char*str,intn);
intmvwgetnstr(WINDOW*,inty,intx,char*str,intn);
20.4Funesdesada
152
Existemtrstiposdefunesdesadanabibliotecancurses:
addch():imprimecaracterescomatributos
printw():imprimestringsformatadas
addstr():imprimestrings
addch():Imprimeumcaracternatela
intaddch(chtypech);
intwaddch(WINDOW*win,chtypech);
intmvaddch(inty,intx,chtypech);
intmvwaddch(WINDOW*win,inty,intx,chtypech);
intechochar(chtypech);
intwechochar(WINDOW*win,chtypech);
printw():Imprimeumastringnatela
intprintw(char*fmt[,arg]...);
intwprintw(WINDOW*win,char*fmt[,arg]...);
intmvprintw(inty,intx,char*fmt[,arg]...);
intmvwprintw(WINDOW*win,inty,intx,char*fmt[,arg]...);
addstr():Imprimeumastringnatela
intaddstr(constchar*str);
intaddnstr(constchar*str,intn);
intwaddstr(WINDOW*win,constchar*str);
intwaddnstr(WINDOW*win,constchar*str,intn);
intmvaddstr(inty,intx,constchar*str);
intmvaddnstr(inty,intx,constchar*str,intn);
intmvwaddstr(WINDOW*win,inty,intx,constchar*str);
intmvwaddnstr(WINDOW*win,inty,intx,constchar*str,intn);
20.5FunodeFormataodetexto
A funo attron permite formatar um texto atravs de algumas
caractersticascomo:itlico,negritoousublinhado.
Formadeusar:
attron(A_BOLD);
attron(A_BLINK);
printw(CforLinux,byLuzzardi,2006);
attron(A_BLINK);
attroff(A_BOLD);
Outraformadeformatao:
addch('A'|A_BOLD|A_UNDERLINE);
Formatao
Efeito
A_NORMAL
Nenhumaformatao
A_STANDOUT
Melhormododeiluminao
153
Formatao
Efeito
A_UNDERLINE
Sublinhado
A_REVERSE
Fundopreto,textobranco(inversodonormal)
A_BLINK
Piscante
A_DIM
Brilhoparcial
A_BOLD
Negrito
A_PROTECT
Modoprotegido
A_INVIS
Modoinvisvel
A_ALTCHARSET
Alternaoscaracteres
A_CHARTEXT
Mscaradebitparaextrairumcaracter
154
21.OutrosComandos
21.1ComandosdoPrProcessador
Comandos que so executados antes do programa fonte ser
compilado.
Incluso
de
Arquivos
de
Header
(cabealhosdefunes):
#include<header.h>
ou
#includeheader_usurio.h
Definio
de
MacroSubstituio
:
#define<identificador><valor>
#definetrue!0
#definefalse0
ou
#defineTRUE!0
#defineFALSE0
Condies
para
Compilao
:
#if<condio>
#else
#endif
ou
#ifdef<macro>
#else
#endif
Exemplo:
#include<stdio.h>
#defineEXISTE_DEFINE100
//existeouno
#defineSELECT1//selecioneantesdecompilar
#if(SELECT==1)
#definec10
#definel10
#else
#definec20
#definel20
#endif
155
#ifdefEXISTE_DEFINE
#definex100
#else
#definex200
#endif
intmain(void)
{
printf("c=%d\n",c);
printf("l=%d\n",l);
printf("x=%d\n",x);
}
Resultado
do
Programa
quando
:
#defineEXISTE_DEFINE100
//existeouno
#defineSELECT1//selecioneantesdecompilar
c=10
l=10
x=100
Resultado
do
Programa
quando
:
//#defineEXISTE_DEFINE100
#defineSELECT2
//noexisteestalinha
c=20
l=20
x=200
21.2Hierarquiadosoperadoresaritmticos,relacionais,lgicosebita
bit
Operador
Operao
Forma de Avaliao
()
parnteses
esquerda para direita
[]
conchetes
++
incremento
direita para esquerda
--
decremento
cast
(tipo)
*
contedo do ponteiro
&
endereo de memria
unrio (-7)
complemento de um
no
multiplicao
diviso
resto inteiro da diviso
adio
subtrao
>>
deslocamento para direita
<<
deslocamento para esquerda
156
Operador
Operao
Forma de Avaliao
>
maior que
>=
maior ou igual
<=
menor ou igual
<
menor
`==
igual
!=
diferente
&
and bit a bit
ou exclusivo bit a bit
ou inclusive bit a bit
&&
e (and)
||
ou (or)
`=
atribuio
+=
atribuio (adio)
-=
atribuio (subtrao)
*=
atribuio (multiplicao)
/=
atribuio (diviso)
%=
atribuio (resto inteiro diviso)
>>=
atribuio (deslocamento direita)
<<=
atribuio (deslocamento esquerda)
&=
atribuio (and)
^=
atribuio (ou exclusivo)
|=
atribuio (ou inclusive)
21.3Declaraodeconstantestipadas
AlinguagemC,padroANSI,permitecriarconstantestipadas.
intmain(void)
{
constdoublepi=3.1416;
constintmax=7;
floatx[max];
21.4PonteiroparaPonteiro
Umponteiroparaumponteiroumaformadeduplaindireao.Um
ponteirocomum(int*p)tememseuvaloroendereodeumavarivel.
Quando definido um ponteiro para ponteiro, o primeiro ponteiro
contm o endereo do segundo, que tambm aponta para a varivel do
primeiroponteiro.
//pointer.c
#include<stdio.h>
intmain(void)
{
intn=7;
157
int*p,**q;
p=&n;
q=&p;
printf("Valorde(n)=%d\n",n);
printf("Endereode(&n)=%p\n\n",&n);
printf("Ponteiro(p)=%p\n",p);
printf("ConteudodoPonteiro(*p)=%d\n",*p);
printf("EnderecodoPonteiro(&p)=%p\n\n",&p);
printf("Ponteiro(q)=%p\n",q);
printf("ConteudodoPonteiro(*q)=%p\n",*q);
printf("ConteudodoPonteiro(**q)=%d\n",**q);
printf("EnderecodoPonteiro(&q)=%p\n\n",&q);
}
Resultado
do
Programa
:
Valorde(n)=7
Endereode(&n)=0xbfef6384
Ponteiro(p)=0xbfef6384
ConteudodoPonteiro(*p)=7
EnderecodoPonteiro(&p)=0xbfef6380
Ponteiro(q)=0xbfef6380
ConteudodoPonteiro(*q)=0xbfef6384
ConteudodoPonteiro(**q)=7
EnderecodoPonteiro(&q)=0xbfef637c
158
159
22.ProgramasescritosemC
O programa abaixo, calc.c, simula uma calculadora com quatro
operaes:
[+]Adio
[]Subtrao
[*]Multiplicao
[/]Diviso
//calc.c
#include<stdio.h>
#include<stdlib.h>
intmain(void)
{
floatx,y,resp;
charop;
interro=0;
scanf("%f",&x);
getchar();
printf("Operador[+*/]:");
op=getchar();
printf("Digiteoutrovalor:");
scanf("%f",&y);
if(op=='+')
resp=x+y;
else
if(op=='')
resp=xy;
else
if(op=='*')
resp=x*y;
else
if(op=='/')
if(y!=0)
resp=x/y;
else
{
printf("ERRO:DivisoporZero\n");
return(1);
}
else
{
printf("ERRO:OperadorInvlido\n");
return(2);
}
printf("Resposta:%.2f\n",resp);
return(0);
}
Oprogramaexemploabaixo,calculadora.c,simulaumacalculadora
com10operaes:
160
[+]Adio
[]Subtrao
[*]Multiplicao
[/]Diviso
[R]RaizQuadrada
[P]Potncia
[I]Inverso
[S]Seno
[C]Cosseno
[T]Tangente
//calculadora.c
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#definePI4*atan(1)
intmain(void)
{
floatx,y,resp,rads;
charop;
interro=0;
scanf("%f",&x);
getchar();
//apagaenterdobufferdeteclado
printf("Operadores:\n");
printf("[+]Adio\n");
printf("[]Subtrao\n");
printf("[*]Multiplicao\n");
printf("[/]Diviso\n");
printf("[R]RaizQuadrada\n");
printf("[P]Potncia\n");
printf("[I]Inverso\n");
printf("[S]Seno\n");
printf("[C]Cosseno\n");
printf("[T]Tangente\n");
printf("QualasuaOpo?");
op=getchar();
if(strchr("+*/Pp",op))
{
printf("Digiteoutrovalor:");
scanf("%f",&y);
}
if(op=='+')
resp=x+y;
else
if(op=='')
resp=xy;
else
if(op=='*')
resp=x*y;
else
if(op=='/')
161
if(y!=0)
resp=x/y;
else
erro=1;
else
if(op=='R'||op=='r')
if(x>=0)
resp=sqrt(x);
else
erro=2;
else
if(op=='P'||op=='p')
resp=pow(x,y);
else
if(op=='I'||op=='i')
if(x!=0)
resp=1/x;
else
erro=1;
else
if(op=='S'||op=='s')
{
rads=x*PI/180.0;
resp=sin(rads);
}
else
if(op=='C'||op=='c')
{
rads=x*PI/180.0;
resp=cos(rads);
}
else
if(op=='T'||op=='t')
if(x==90.0||x==270.0)
erro=3;
else
{
rads=x*PI/180.0;
resp=tan(rads);
}
else
{
printf("ERRO: Operador
Invlido\n");
return(1);
}
if(erro==0)
printf("Resposta:%.4f\n",resp);
else
if(erro==1)
printf("ERRO:DivisoporZero\n");
else
if(erro==2)
printf("ERRO:RaizNegativa\n");
else
if(erro==3)
printf("ERRO:TangenteInfinita\n");
return(0);
162
}
O programa abaixo, juliano.c, exibe o dia da semana (segunda,
tera, quarta, quinta, sexta, sbado ou domingo) de uma determinada
data.Paratanto,utilizadooClculo
do
Dia
Juliano
.
Como
calcular
: http://www.rio.rj.gov.br/planetario/cent_pesq_calc.htm
//juliano.c
//Prototypes
#include<stdio.h>
#include<stdlib.h>
//ProgramaPrincipal
intmain(void)
{
intdia,mes,ano,resto;
intA,B,C;
longintD,E,dj;
floatresp;
printf("Dia[1..31]:");
scanf("%d",&dia);
if(dia<1||dia>31)
printf("ERROFATAL:DiaInvlido\n");
else
{
printf("Mes[1..12]:");
scanf("%d",&mes);
if(mes<1||mes>31)
printf("ERROFATAL:MsInvlido\n");
else
{
printf("Ano[1583]:");
scanf("%d",&ano);
if(ano<1583)
printf("ERROFATAL:AnoInvlido\n");
else
{
if(mes<3)
{
ano=ano1;
mes=mes+12;
}
A=ano/100;
B=A/4;
C=2A+B;
resp=365.25*(ano+4716);
D=(longint)resp;
resp=30.6001*(mes+1);
E=(longint)resp;
dj=D+E+dia+C1524;
resto=dj%7;
switch(resto)
163
{
case0:printf("SegundaFeira\n");
break;
case1:printf("TeraFeira\n");
break;
case2:printf("QuartaFeira\n");
break;
case3:printf("QuintaFeira\n");
break;
case4:printf("SextaFeira\n");
break;
case5:printf("Sbado\n");
break;
case6:printf("Domingo\n");
break;
}
}
}
}
}
O programa abaixo, cpf.c, permite verificar se um determinado
CPF vlido ou invlido, calculando e exibindo os dgitos
verificadoresdoCPFdigitado.
Como
calcular
: http://www.geocities.com/CapeCanaveral/4274/cgcancpf.htm
//cpf.c
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
//ProgramaPrincipal
intmain(void)
{
charcpf[15];
inti,t,n,final;
intdigit1,digit2;
intvalor=0,fator;
printf("Cpf[99999999999]:");
scanf("%s",cpf);
n=strlen(cpf);
if(n!=11&&n!=9)
{
printf("Formato:9ou11dgitosnumricos\n");
return;
}
if(n==10)
{
n=n1;
cpf[n]=(char)NULL;
}
for(i=0;i<9;i++)
valor=valor+(cpf[i]48)*(10i);
164
fator=valor/11;
fator=fator*11;
valor=valorfator;
if(valor<2)
digit1=0;
else
digit1=11valor;
valor=0;
for(i=0;i<9;i++)
valor=valor+(cpf[i]48)*(11i);
valor=valor+digit1*2;
fator=valor/11;
fator=fator*11;
valor=valorfator;
if(valor<2)
digit2=0;
else
digit2=11valor;
final=digit1*10+digit2;
printf("DgitoVerificador:");
if(final>=10)
printf("%d\n",final);
else
printf("%02d\n",final);
if(n==11)
{
printf("CpfDigitado:");
for(i=0;i<=7;i++)
{
printf("%c",cpf[i]);
t=t+1;
if(t==3)
{
t=0;
printf(".");
}
}
printf("%c",cpf[8]);
for(i=9;i<=10;i++)
printf("%c",cpf[i]);
printf("\n");
}
if(digit1==cpf[9]48&&digit2==cpf[10]48)
printf("Status:CPFVlido\n");
else
printf("Status:CPFInvlido\n");
}
Os programas abaixo, conio.c e conio.h, mostram uma forma
alternativadeutilizaralgumasfunesdoarquivodeheaderconio.h:
clrscr,gotoxy,getche,getch,kbhit,dekay,textcoloretextbackcolor.
clrscr:limpaatelaemmodotexto.
gotoxy:posicionaocursornacoluna,linha.
getche:lemostraumcaracternatelasementer.
getch:lenomostraumcaracternatelasementer.
kbhit:verifiqueseateclaenterpresionadaouno.
165
delay:permitefazerumapausaemmilisegundos.
textcolor:alteraacordotexto.
textbackcolor:alteraacordefundo.
//conio.c
#include<stdio.h>
#include"conio.h"
#defineESC27
intmain(void)
{
inttecla;
clrscr();
do{
textcolor(BLUE);
gotoxy(10,5);
printf("Tecla:");
tecla=getche();
//troqueportecla=getch();
textbackcolor(GREEN);
gotoxy(10,7);
printf("Cdigo:%d>Caracter:%c\n",tecla,tecla);
}while(tecla!=ESC);
}
//conio.h
#include<termios.h>
#include<unistd.h>
#include<sys/time.h>
#defineBLACK0
#defineRED1
#defineGREEN2
#defineBROWN3
#defineBLUE4
#defineMAGENTA5
#defineCYAN6
#defineDARKGRAY7
#defineSUBLINHA8
#defineblack0
#definered1
#definegreen2
#definebrown3
#defineblue4
#definemagenta5
#definecyan6
#definedarkgray7
#definesublinha8
//funo:clrscr
voidclrscr(void)
166
{
printf("\x1B[2J");
}
//funo:gotoxy
{
printf("\033[%d;%df",l,c);
}
//funo:getch
intgetch(void)
{
structtermiosoldt,newt;
intch;
tcgetattr(STDIN_FILENO,&oldt);
newt=oldt;
newt.c_lflag&=~(ICANON|ECHO);
tcsetattr(STDIN_FILENO,TCSANOW,&newt);
ch=getchar();
tcsetattr(STDIN_FILENO,TCSANOW,&oldt);
return(ch);
}
//funo:getche
intgetche(void)
{
structtermiosoldt,newt;
intch;
tcgetattr(STDIN_FILENO,&oldt);
newt=oldt;
newt.c_lflag&=~(ICANON|ECHO);
tcsetattr(STDIN_FILENO,TCSANOW,&newt);
ch=getchar();
tcsetattr(STDIN_FILENO,TCSANOW,&oldt);
putchar(ch);
return(ch);
}
//funo:kbhit
intkbhit(void)
{
structtimevaltv;
fd_setread_fd;
tv.tv_sec=0;
tv.tv_usec=0;
FD_ZERO(&read_fd);
FD_SET(0,&read_fd);
if(select(1,&read_fd,NULL,NULL,&tv)==1)
return(0);
if(FD_ISSET(0,&read_fd))
167
return(1);
return(0);
}
//funo:delay
voiddelay(intespera)
{
clock_tt;
t=clock()+espera;
while(clock()<=t);
}
//funo:textcolor
{
switch(cor)
{
caseBLACK:printf("\033[30m");
break;
caseRED:printf("\033[31m");
break;
caseGREEN:printf("\033[32m");
break;
caseBROWN:printf("\033[33m");
break;
caseBLUE:printf("\033[34m");
break;
caseMAGENTA:printf("\033[35m");
break;
caseCYAN:printf("\033[36m");
break;
caseDARKGRAY:printf("\033[37m");
break;
caseSUBLINHA:printf("\033[38m");
break;
}
}
//funo:textbackcolor
voidtextbackcolor(intcor)
{
switch(cor)
{
caseBLACK:printf("\033[40m");
break;
caseRED:printf("\033[41m");
break;
caseGREEN:printf("\033[42m");
break;
caseBROWN:printf("\033[43m");
break;
caseBLUE:printf("\033[44m");
break;
168
caseMAGENTA:printf("\033[45m");
break;
caseCYAN:printf("\033[46m");
break;
caseDARKGRAY:printf("\033[47m");
break;
}
}
O programa abaixo, cores.c exibe as cores disponveis nas
funestextcoloretextbackcolordabibliotecadetexto:conio.h.
//cores.c
#include<stdio.h>
#include"conio.h"
intmain(void)
{
textcolor(BLACK);
printf("Black\n");
textcolor(RED);
printf("Red\n");
textcolor(GREEN);
printf("Green\n");
textcolor(BROWN);
printf("Brown\n");
textcolor(BLUE);
printf("Blue\n");
textcolor(MAGENTA);
printf("Magenta\n");
textcolor(CYAN);
printf("Cyan\n");
textcolor(DARKGRAY);
printf("DarkGray\n");
textcolor(SUBLINHA);
printf("Sunlinha\n");
textbackcolor(BLACK);
printf("\nBlack");
textbackcolor(RED);
printf("\nRed");
textbackcolor(GREEN);
printf("\nGreen");
textbackcolor(BROWN);
printf("\nBrown");
textbackcolor(BLUE);
printf("\nBlue");
textbackcolor(MAGENTA);
printf("\nMagenta");
textbackcolor(CYAN);
printf("\nCyan");
textbackcolor(DARKGRAY);
printf("\nDarkGray");
getchar();
}
169
170

Apostila GCC

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila GCC

Enviado por

Direitos autorais:

Formatos disponíveis

UniversidadeCatlicadePelotas

14.5 - Ponteiros para ponteiros.................................................................................................................80

19.5 Jogo da Forca..................................................................................................................................140

Um programa em C constitudo de uma ou mais funes

Observao: As palavras reservadas no podem ser utilizadas pelo

'a' 'n' '9'

Observaes: Normalmente os arquivos de header esto localizados em

Observao: Quando houver duas ou mais operaes de mesma hierarquia,

Observao: As expresses que utilizam operadores relacionais e

A linguagem de programao C permite utilizar o operador de

Programa exemplo (7): O usurio digita um nmero e o programa diz se

Programa exemplo (10): Oprogramarecebeumdgitode0 9 eimprime

condio no incio do lao, por causa disto, normalmente, a varivel

Explicao: O comando printf no faz parte do comando if devido ao

Inicializao: um comando de atribuio (ou vrios, separados por

Quando o programa encontra o comando break dentro de um lao,

Nos laos while e do {} while um comando continue faz com que o

() Alinha o resultado esquerda. Preenche o restante do campo com brancos. Se

ScanSet: Funciona como uma entrada seletiva de caracteres na funo

Observao: stdin (entrada), stdout (sada) e stderr (erro) so

10.3 Escreva um programa em C que recebe via teclado: comprimento da

10.5 Escreva um programa em C que recebe via teclado: tipo de animal

10.6 Reescreva o programa anterior recebendo via teclado uma letra

10.9 Escreva um programa em C que recebe via teclado: quantidade de

10.10 Escreva um programa em C que recebe via teclado duas notas:

Observao: O programa termina quando o usurio digitar S ou s na pergunta: Sair

10.12 Escreva um programa em C que recebe via teclado: graus (0

10.13 Escreva um programa em C que recebe via teclado: sexo

Observao: Quando um vetor declarado e inicializado (ao mesmo

vetor) grande o suficiente para conter todos os inicializadores

Observao: As funes strcpy, strcmp e strchr so discutidas na

11.10.2 Escreva um programa em C que recebe via teclado: nmero de

11.10.4 Escreva um programa em C que recebe via teclado "n" conceitos

11.10.5 Escreva um programa em C que recebe via teclado n (mximo

11.10.6 Escreva um programa em C que recebe via teclado n (mximo

12.6.2 Escreva um programa em C que recebe via teclado uma palavra

Observao: O programa deve ser encerrado quando o usurio digitar N ou n na

12.6.3 Escreva um programa em C que recebe via teclado uma palavra

12.6.5 Escreva um programa em C que recebe via teclado um nome

Observao: O programa termina quando o usurio digitar S ou s na pergunta: Sair

Observao: O programa termina quando o usurio digitar S ou s na pergunta: Sair

12.6.7 Escreva um programa em C que recebe via teclado o nome de um

12.6.8 Escreva um programa em C que recebe via teclado uma palavra

Programa exemplo (32): O programa possui uma funo que calcula o

Programa exemplo (38): O programa calcula e imprime na tela a diviso

13.7.3 Escreva em C a funo PREENCHE. A funo recebe: nmero de

13.7.4 Escreva em C a funo GERA_STRING. A funo recebe via

13.7.5 Escreva em C a funo VERIFICA_QUADRANTE. A funo recebe um

13.7.6 Escreva a funo: final_da_placa. A funo recebe uma placa de

13.7.13 Escreva em C a funo VERIFICA. A funo recebe um nmero

Observao: Aritmtica de ponteiros pode ser mais rpida que a

A funo fopen (file open) permite abrir um arquivo ligandoo a

ocorre uma pausa. A cada parada informado o nome do arquivo texto

As funes getw e putw so utilizadas para ler e gravar,

descritores de arquivos chamados handles do tipo int, ou seja, uma

A funo write grava tantos caracteres quantos forem o tamanho

a expresso do lado direito ficar sendo o valor de toda expresso

Primeiramente atribudo o valor 3 a y e depois atribudo o

Forma de acesso: LIFO (Last Input First Output), ou seja, o ltimo

time_t: possui a informao de calendrio (data + hora) num nico

esquerda para direita

esquerda para direita