linguagem de programacao c

Centro Universitrio de Maring - CESUMAR

Cursos de AUTOMAO INDUSTRIAL e

ENGENHARIA DE CONTROLE E AUTOMAO

Disciplina de Informtica para Automao

Prof. EE. Carlos Henrique Z. Pantaleo

2005

Informtica para Automao Linguagem de Programao

Prof. Carlos Pantaleo

Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao

2

SUMRIO 1 Programao em C...........................................................................................................................5 2 Conceitos Bsicos da Programao C.............................................................................................7

2.1 Histrico de C......................................................................................................................7 2.2 Criando um Programa Executvel.......................................................................................8 2.3 A Estrutura Bsica de um Programa em C..........................................................................9 2.4 Variveis............................................................................................................................11 2.5 Tipos de Dados...................................................................................................................12 2.6 Constantes..........................................................................................................................14 2.7 Ponteiros.............................................................................................................................16 2.8 Exerccios...........................................................................................................................18

3 Entrada/Sada Console...................................................................................................................19

3.1 Printf()........................................................................................................................19 3.2 Cprintf().........................................................................23 3.3 Scanf()....................................................................................................................23 3.4 Getch(), Getche() e Getchar()....................................................................................24 3.5 Putch() ou Putchar()...........................................................................................................25 3.6 Exerccios...........................................................................................................................25

4 Operadores .....................................................................................................................................27

4.1 Operadores Aritmticos.....................................................................................................27 4.2 Operadores Relacionais......................................................................................................28 4.3 Operadores lgicos binrios...............................................................................................29 4.4 Operadores de Ponteiros....................................................................................................30 4.5 Operadores Incrementais e Decrementais..........................................................................31 4.6 Operadores de Atribuio..................................................................................................33 4.7 O Operador Lgico Ternrio..............................................................................................34 4.8 Precedncia........................................................................................................................35 4.9 Exerccios...........................................................................................................................35

5 Laos.................................................................................................................................................37

5.1 O Lao For.........................................................................................................................37 5.2 O Lao While.....................................................................................................................39 5.3 O Lao Do-While...............................................................................................................40 5.4 Break e Continue........................................................................................................41 5.5 Goto....................................................................................................................................42 5.6 Exerccios...........................................................................................................................42




3

6 Comandos para Tomada de Deciso.............................................................................................44

6.1 If.....................................................................................................................44 6.2 If-Else.........................................................................................................................45 6.3 Switch.........................................................................................................................46 6.4 Exerccios...................................................................................................................49

7 Funes ............................................................................................................................................50

7.1 Sintaxe................................................................................................................................50 7.2 Exemplos............................................................................................................................51 7.3 Prototipagem......................................................................................................................54 7.4 Classes de Armazenamento...............................................................................................55

7.4.1 Auto.....................................................................................................55 7.4.2 Extern......................................................................................................55 7.4.3 Static....................................................................................................................56 7.4.4 Variveis Estticas Externas...............................................................................57 7.4.5 Register................................................................................................................58

7.5 Exerccios...........................................................................................................................58

8 Diretivas do Pr-Processador.........................................................................................................60

8.1 Diretiva #define..................................................................................................................60 8.2 Macros................................................................................................................................61 8.3 Diretiva #undef..................................................................................................................63 8.4 Diretiva #include................................................................................................................63 8.5 Compilao Condicional....................................................................................................65 8.6 Operador defined................................................................................................................66 8.7 Diretiva #error....................................................................................................................66 8.8 Diretiva #pragma...............................................................................................................67 8.9 Exerccios...........................................................................................................................67

9 Matrizes...........................................................................................................................................68

9.1 Sintaxe de Matrizes............................................................................................................69 9.2 Inicializando Matrizes........................................................................................................70 9.3 Matrizes como Argumentos de Funes............................................................................73 9.4 Chamada Por Valor e Chamada Por Referncia................................................................75 9.5 Strings .......................................................................................................................78

9.5.1 Strings Constantes...........................................................................................79 9.5.2 String Variveis...................................................................................................79 9.5.3 Funes para Manipulao de Strings.................................................................81

9.6 Exerccios...........................................................................................................................83




4

10 Tipos Especiais de Dados.............................................................................................................84

10.1 Typedef............................................................................................................................84 10.2 Enumerados (Enum)........................................................................................................84 10.3 Estruturas (Struct)............................................................................................................86 10.4 Unies..............................................................................................................................91 10.5 Bitfields............................................................................................................................93 10.6 Exerccios.........................................................................................................................94

11 Ponteiros e a Alocao Dinmica de Memria...........................................................................95

11.1 Declarao de Ponteiros e o Acesso de Dados com Ponteiros.........................................95 11.2 Operaes com Ponteiros.................................................................................................96 11.3 Funes & Ponteiros........................................................................................................99 11.4 Ponteiros & Matrizes.....................................................................................................101 11.5 Ponteiros & Strings........................................................................................................103 11.6 Ponteiros para Ponteiros.................................................................................................105 11.7 Argumentos da Linha de Comando...............................................................................109 11.8 Ponteiros para Estruturas...............................................................................................110 11.9 Alocao Dinmica de Memria....................................................................................112

11.9.1 Malloc()...............................................................................................114 11.9.2 Calloc()................................................................................................115 11.9.3 Free()...............................................................................................................116

11.10 Exerccios.....................................................................................................................116 12 Manipulao de Arquivos em C................................................................................................118

12.1 Tipos de Arquivos..........................................................................................................118 12.2 Declarao, abertura e fechamento................................................................................118 12.3 Leitura e escrita de caracteres........................................................................................120 12.4 Fim de Arquivo (EOF)...................................................................................................120 12.5 Leitura e escrita de strings.............................................................................................121 12.6 Arquivos Padres..........................................................................................................122 12.7 Gravando um Arquivo de Forma Formatada.................................................................123 12.8 Leitura e escrita de valores binrios...............................................................................124 12.9 Exerccios.......................................................................................................................125




5

1 Programao em C

Atualmente, empregam-se cada vez mais sistemas computacionais na automatizao de

processos industriais. Os sistemas computacionais empregados variam desde um simples circuito

lgico digital, passando por uma circuito composto por um microprocessador ou um CLP, at

sistemas complexos envolvendo um ou mais microcomputadores ou at estaes de trabalho. Um

engenheiro que atua nesta rea deve conhecer os sistemas computacionais disponveis e ser capaz de

selecionar o melhor equipamento para uma dada aplicao. Alm disto, este profissional deve

conseguir instalar este sistema, configur-lo e acima de tudo program-lo para que este execute a

tarefa de automatizao atendendo os requisitos industrias do sistema, como imunidade a falhas ou

comportamento determinstico com restries temporais (sistemas tempo-real). Neste contexto, a

programao destes sistemas se faz de suma importncia. Basicamente, a inteligncia dos sistemas

automatizados implementada atravs de programas computacionais, comandando os componentes

de hardware para executar a tarefa com o comportamento desejado.

Figura 1 - Comparao entre os diversos sistemas computacionais para aplicaes industriais.

Nas ltimas dcadas, o desenvolvimento em hardware permitiu que cada vez mais os

processos industrias sejam automatizados e interligados atravs de sistemas computacionais.

Entretanto, a evoluo em software no se deu em tamanha velocidade como a de hardware. Desta




6

forma, um dos grandes paradigmas tecnolgicos hoje o desenvolvimento de programas para a

realizao de tarefas complexas e que exigem um alto grau de inteligncia.

A maneira de se comunicar com um computador chama-se programa e a nica linguagem que

o computador entende chama-se linguagem de mquina. Portanto todos os programas que se

comunicam com a mquina devem estar em linguagem de mquina.

Para permitir uma maior flexibilidade e portabilidade no desenvolvimento de software, foram

implementados nos anos 50 os primeiros programas para a traduo de linguagens semelhantes

humana (linguagens de "alto nvel") em linguagem de mquina. A forma como os programas so

traduzidos para a linguagem de mquina classifica-se em duas categorias:

Interpretadores: Um interpretador l a primeira instruo do programa, faz uma

consistncia de sua sintaxe e, se no houver erro converte-a para a linguagem de mquina para

finalmente execut-la. Segue, ento, para a prxima instruo, repetindo o processo at que a

ltima instruo seja executada ou a consistncia aponte algum erro. So muito bons para a funo

de depurao ("debugging") de programas, mas so mais lentos. Ex.: BASIC Interpretado, Java.

Compiladores: Traduzem o programa inteiro em linguagem de mquina antes de

serem executados. Se no houver erros, o compilador gera um programa em disco com o sufixo

.OBJ com as instrues j traduzidas. Este programa no pode ser executado at que sejam

agregadas a ele rotinas em linguagem de mquina que lhe permitiro a sua execuo. Este trabalho

feito por um programa chamado linkeditor que, alm de juntar as rotinas necessrias ao

programa .OBJ, cria um produto final em disco com sufixo .EXE que pode ser executado

diretamente do sistema operacional.

Compiladores bem otimizados produzem cdigo de mquina quase to eficiente quanto

aquele gerado por um programador que trabalhe direto em Assembly. Oferecem em geral menos

facilidades de depurao que interpretadores, mas os programas so mais rpidos (na ordem de 100

vezes ou mais). Ex.: BASIC Compilado, FORTRAN, PASCAL, MDULA - 2, C, C++. Alm da

velocidade, outras vantagens podem ser mencionadas:

desnecessria a presena do interpretador ou do compilador para executar o programa j

compilado e linkeditado;

programas .EXE no podem ser alterados, o que protege o cdigo-fonte.




7

Desta forma, os compiladores requerem o uso adicional de um editor de ligaes ("Linker"),

que combina mdulos-objetos ("Traduzidos") separados entre si e converte os mdulos assim

"linkados" no formato carregvel pelo sistema operacional (programa .EXE).

2 Conceitos Bsicos da Programao C

2.1 Histrico de C

O compilador "C" vem se tornando o mais difundido em ambiente industrial. A linguagem

"C" se originou das linguagens BCPL e B desenvolvidas em 1970. A primeira verso de "C" foi

implementada para o sistema operacional UNIX pela Bell Laboratories, especificamente por Dennis

M. Ritchie e Ken Thompson no incio da dcada de 70, e rodava em um DEC PDP11 (Digital

Equipment Corporation). A linguagem C foi utilizada para portar o UNIX para outros

computadores. A linguagem "C" possui uma caracterstica dual:

considerada linguagem estruturada de alto-nvel;

Assembly de alto-nvel, que permite escrever programas muito prximos

linguagem de mquina, sendo usada para desenvolver muitas aplicaes como compiladores,

interpretadores, processadores de texto e mesmo sistemas operacionais. Ex: UNIX, MSDOS, TPW.

A linguagem de programao C tornou-se rapidamente uma das mais importantes e

populares, principalmente por ser muito poderosa, porttil, pela padronizao dos compiladores

existentes (atravs da norma ANSI C) e flexvel. Os programas em C tendem a ser bastante

compactos e de execuo rpida.

A linguagem C baseada em um ncleo pequeno de funes e estruturas bsicas, desta

forma, todo programa desenvolvido a partir deste ncleo bsico. Isto implica na grande

portabilidade de C, haja vista que basta a implementao deste ncleo bsico para um dado

processador e automaticamente j estar disponvel um compilador C para este processador. Por

esta razo, existem compiladores C para a grande parte dos sistemas computacionais atualmente

disponveis. Devido tambm a este pequeno ncleo, um programador C capaz de desenvolver




8

programas to eficientes, pequenos e velozes quanto os programas desenvolvidos em Assembly. Por

isso, diz-se que C uma linguagem de alto nvel, porm, prxima da linguagem de mquina.

2.2 Criando um Programa Executvel

Primeiro, escreva o seu programa (arquivo em modo ASCII), com o auxlio de um programa

denominado de compilador, e grave o programa em disco dando a ele um nome como sufixo .C. O

programa gerado chamado de cdigo fonte. Na seqncia, compile o fonte seguindo as instrues

do seu compilador, o que criar um programa com o sufixo .OBJ em disco. O programa gerado

chamado de objeto. Por fim, basta linkeditar o objeto seguindo as instrues do seu linkeditor o que

criar um programa com sufixo .EXE em disco. O programa gerado chamado de executvel. A

Figura 2 apresenta o processo de gerao de um programa em C.

Figura 2 - Ilustrao do processo de criao de um programa em C.




9

2.3 A Estrutura Bsica de um Programa em C

A forma geral de um programa em "C" a seguinte:

; main() {

; /* comentrios */ ;

}

Vamos comear por um programa bem simples em C. Voc pode escrever este programa

em um arquivo ASCII e salv-lo com um nome terminando em .C. O programa serve para

escrever na tela a frase Bom Dia!!!!.

/* Programa : Bom Dia! */ #include void main() {

printf(Bom Dia!!!!); }

Na primeira linha, os smbolos /* e */ servem para delimitar um comentrio do programa.

muito importante que os programas sejam comentados de forma organizada. Isto permite que outras

pessoas possam facilmente entender o cdigo fonte. Os comentrios no so interpretados pelo

compilador, servindo apenas para a documentao e esclarecimento do programador. Depois,

segue-se com uma diretiva para o pr-processador #include .

Isto advm do fato de C ter um ncleo pequeno de funes bsicas. Ao escrever esta linha

de cdigo, o pr-processador ir acrescentar ao programa todas as funcionalidades definidas na




10

biblioteca stdio e ir link-la posteriormente ao programa. Desta forma, voc poder usufruir

todos os servios disponveis nesta biblioteca.

Por fim, temos a funo main(). Esta funo indica ao compilador em que instruo deve

ser comeada a execuo do programa. Portanto, esta funo deve ser nica, aparecendo somente

uma vez em cada programa. O programa termina quando for encerrada a execuo da funo

main(). No caso deste programa exemplo, ela no recebe nenhum parmetro e tambm no retorna

parmetro nenhum. Isto fica explcito atravs da palavra-chave void escrita na frente do programa.

Se em vez de void tivssemos escrito int, isto significaria que a funo main() deveria retornar um

valor do tipo inteiro ao final de sua execuo. Como este o valor retornado pela funo main(),

este tambm ser o valor retornado pelo programa aps a sua execuo. As funes e as suas

caractersticas sero apresentadas em detalhes nos prximos captulos.

Todo o corpo de uma funo em C inicializado e finalizado atravs das chaves { e }. Estas

chaves definem o bloco de instrues a serem executados por esta funo. A primeira instruo

dada dentro do programa printf (Bom Dia!!!!);. Printf uma funo definida em stdio.h

para escrever dados na janela console. Todas as instrues de programa tm que ser declaradas

dentro de alguma funo (na main() ou outra qualquer). Todas as instrues devem estar dentro das

chaves que iniciam e terminam a funo e so executadas na ordem em que as escrevemos. As

instrues C so sempre encerradas por um ponto-e-vrgula ( ; ). O ponto-e-vrgula parte da

instruo e no um simples separador. Esta instruo uma chamada funo printf(), os

parnteses nos certificam disso e o ponto-e-vrgula indica que esta uma instruo. Nota-se que a

funo chamada escrevendo-se o nome desta e colocando-se os parmetros desta dentro dos

parnteses. A final de cada instruo, faz-se necessrio o acrscimo de um ponto-vrgula ;.

As variveis em C podem estar dentro de uma funo ou no incio do arquivo fonte.

Variveis declaradas no incio do arquivo fonte so consideradas globais, isto , so visveis

(acessveis) para todas as funes do programa. Variveis declaradas dentro de uma funo so

consideradas locais, isto , visveis somente pela funo onde so declaradas.

"C" distingue nomes de variveis e funes em maisculas de nomes em minsculas. Voc

pode colocar espaos, caracteres de tabulao e pular linhas vontade em seu programa, pois o

compilador ignora estes caracteres. Em C no h um estilo obrigatrio. Entretanto, procure manter

os programas to organizados quanto for possvel, pois isto melhora muito a legibilidade do

programa, facilitando o seu entendimento e manuteno.




11

2.4 Variveis

As variveis so o aspecto fundamental de qualquer linguagem de computador. Uma

varivel em C um espao de memria reservado para armazenar um certo tipo de dado e tendo um

nome para referenciar o seu contedo. O espao de memria de uma varivel pode ser

compartilhado por diferentes valores segundo certas circunstncias. Em outras palavras, uma

varivel um espao de memria que pode conter, a cada tempo, valores diferentes.

/* Programa : Exemplo de variveis! */ #include void main() {

int num; /* declaracao */ num = 2; /*atribui um valor*/ printf(Este o nmero dois: %d, num); /*acessa a varivel*/

}

A primeira instruo (int num) um exemplo de declarao de varivel, isto , apresenta um tipo, int, e um nome, num. A segunda instruo (num = 2) atribui um valor varivel e este valor ser acessado atravs de seu nome. Usamos o operador de atribuio (=) para este fim. A

terceira instruo chama a funo printf() mandando o nome da varivel como argumento. Esta l o

valor da varivel e substitui na posio indicada por %d, compondo assim a frase apresentada na

tela. O emprego da funo printf() ser apresentado em detalhe, posteriormente.

Em C todas as variveis devem ser declaradas. Se voc tiver mais de uma varivel do

mesmo tipo, poder declar-las de uma nica vez separando seus nomes por vrgulas. Exemplo:

int aviao, foguete, helicoptero;




12

2.5 Tipos de Dados

O tipo de uma varivel informa a quantidade de memria, em bytes, que esta ir ocupar e a

forma como o seu contedo ser armazenado. Em C existem apenas 5 tipos bsicos de variveis,

que so:

Com exceo de void, os tipos de dados bsicos podem estar acompanhados por

modificadores na declarao de variveis. Os modificadores de tipos oferecidos em C so:

Tipos de Dados Resultantes:




13

Observao: As declaraes que aparecem na tabela acima entre parnteses (), indicam que

estas declaraes so optativas. Por exemplo short unsigned int indica a mesma preciso que

unsigned int. O tipo int tem sempre o tamanho da palavra da mquina, isto , em computadores

de 16 bits ele ter 16 bits de tamanho.

Emprega-se o complemento de dois dos nmeros positivos para o clculo e representao

dos nmeros negativos. A escolha de nomes significativos para suas variveis pode ajud-lo a

entender o que o programa faz e prevenir erros. Uma varivel no pode ter o mesmo nome de uma

palavra-chave de C. Em C, letras minsculas e maisculas so diferentes.

Exemplo de um programa que emprega as variveis apresentadas.

void main() {

float y; /*varivel Real no inicializada*/ int i; /*varivel Inteira no inicializada*/ double x = 3.24; /*var. Double inicializada com 3.24 */ char c = 'a'; /*varivel Char inicializada com a */ i = 100; /*varivel i recebe o valor 100 */ y = (float) i; /*converte tipos */

}

Preste ateno na operao y= (float) i;. Esta operao muita empregada para converso

de tipos de variveis diferentes. Suponha que voc tenha uma varivel x de tipo A e queira




14

convert-la para o tipo B e armazen-la em y deste tipo. Voc pode executar esta operao atravs

do operador: y = ((B) x);

Ateno: Cuidado ao converter variveis com preciso grande para variveis com preciso

pequena, ou seja, variveis que utilizam um nmero diferente de bits para representar dados. Voc

pode perder informaes importantes por causa desta converso. Por exemplo, se voc converter

um float num int, voc perder todos os dgitos depois da vrgula (preciso).

void main() {

float y = 3.1415; int x = 0; x = (int) y; /* Equivalente : x = 3 */

}

2.6 Constantes

Um constante tem valor fixo e inaltervel. No primeiro programa exemplo, mostramos o

uso de uma cadeia de caracteres constante juntamente com a funo printf(): printf(Bom Dia!!!!);

H duas maneiras de declarar constantes em C:

a) usando a diretiva #define do pr-processador: #define < nome da constante > < valor >

Esta diretiva faz com que toda apario do nome da constante no cdigo seja substituda

antes da compilao pelo valor atribudo. No reservado espao de memria no momento da

declarao define. A diretiva deve ser colocada no inicio do arquivo e tem valor global (isto , tem

valor sobre todo o cdigo). Exemplo:




15

#define size 400 #define true 1 #define false 0 /* no se utiliza ";" nem "=" */

b) utilizando a palavra-chave "const": const < tipo > < nome > = < valor >;

Esta forma reserva espao de memria para uma varivel do tipo declarado. Uma constante

assim declarada s pode aparecer do lado direito de qualquer equao (isto equivale a dizer que no

pode ser atribudo um novo valor quela varivel durante a execuo do programa). Exemplo:

const char letra = 'a'; const int size = 400; const double gravidade = 9.81;

/* Programa: Exemplo do uso de Constantes */ #define Size 4 void main() { const char c = c;

const int num = 10; int val = Size;

}

Em C uma constante caractere escrita entre aspas simples, uma constante cadeia de

caracteres entre aspa duplas e constantes numricas com o nmero propriamente dito. Exemplos de

constantes:

a) caractere: a

b) cadeia de caracteres: Bom Dia !!!!

c) nmero: -3.141523




16

2.7 Ponteiros

Uma das mais poderosas caractersticas oferecidas pela linguagem C o uso de ponteiros.

Um ponteiro proporciona um modo de acesso a variveis sem referenci-las diretamente. O

mecanismo usado para isto o endereo da varivel. De fato, o endereo age como intermedirio

entre a varivel e o programa que a acessa.

Basicamente, um ponteiro uma representao simblica de um endereo. Portanto, utiliza-

se o endereo de memria de uma varivel para acess-la. Um ponteiro tem como contedo um

endereo de memria. Este endereo a localizao de uma outra varivel de memria. Dizemos

que uma varivel aponta para uma outra quando a primeira contm o endereo da segunda.

A declarao de ponteiros tem um sentindo diferente da de uma varivel simples. A

instruo: int *px;

declara que *px um dado do tipo int e que px um ponteiro, isto , px contm o endereo de uma

varivel do tipo int.

Para cada nome de varivel (neste caso px), a declarao motiva o compilador a reservar dois

bytes de memria onde os endereos sero armazenados. Alm disto, o compilador deve estar

ciente do tipo de varivel armazenada naquele endereo; neste caso inteiro. O endereo de uma

varivel pode ser passado um ponteiro atravs do operador &, como apresentado abaixo:

void main() {

int num, valor; /* declara as variveis como inteiras */ int *ptr; /* declara um ponteiro para um inteiro */ ptr = 0; /* inicializa o ponteiro com o endereco 0 */ ptr = &num; /* atribui ao ptr o endereo da varivel num*/ num = 10; /* atribui varivel inteira o valor 10 */ valor = *ptr; /* acessa o contedo apontado por ptr e */ /* atribui a valor */

}




17

Neste programa, primeiro declaram-se duas variveis inteiras. Em seguida, declara-se um

ponteiro para uma varivel do tipo inteira. Este ponteiro tem o seu contedo inicializado com 0.

Este um procedimento normal na manipulao de ponteiros, muito empregado para evitar o

aparecimento de erros. Pois, enquanto o endereo de um ponteiro for nulo, isto indicar que este

endereo contm um valor invlido e, portanto, o contedo representado por este endereo no deve

ser acessado.

Na seqncia, emprega-se o operador & para obter o endereo da varivel num e armazenar

este endereo em ptr. Logo aps, atribumos a varivel inteira num o valor 10. Como ptr

contm o endereo de num, logo ptr poder j acessar o valor 10 armazenado na varivel num.

Isto feito na ltima linha, onde o contedo apontado por ptr acessado e copiado para a varivel

valor. Outro exemplo da manipulao de ponteiros:

void main() {

int i, j, *ptr; /* declara as variveis */ i = 1; /* i recebe o valor 1 */ j = 2; /* j recebe o valor 2 */ ptr = &i; /* ptr recebe o valor do endereo de i */ *ptr = *ptr + j; /* equivale a: i = i + j */

}

Nosso objetivo neste momento no apresentar todas as potencialidades dos ponteiros.

Estamos aqui apresentando os ponteiros primeiramente como um tipo de dado especial. O

importante aqui entender o contedo de um ponteiro e como este pode ser empregado.

Posteriormente, apresentaremos as funcionalidades dos ponteiros medida que formos evoluindo no

aprendizado de C.




18

2.8 Exerccios

2.1 Crie o seu programa Hello, World! ou Ol, Mame!;

2.2 Crie um programa que contenha todos os tipos de variveis possveis e as combinaes

dos modificadores possveis. Inicialize estas variveis com valores tpicos. Use o mtodo para a

converso de tipos para converter:

a) A varivel do tipo char em todos os outros tipos de variveis.

b) A varivel do tipo double em todos os outros tipos de variveis. Discuta o que

acontece com a preciso das variveis.

2.3 Crie um programa que exemplifique a utilizao de ponteiros. Que contenha pelo menos

a declarao de um ponteiro, sua inicializao com zero, a obteno do endereo de uma varivel

com o operador & e o acesso ao dado representado pelo ponteiro.

2.4 Utilize as diretivas #define para criar constantes e empregue estas constantes para

inicializar as variveis do programa acima.

2.5 Analise o seguinte programa e aponte onde est o erro.

#define Default_Y 2 void main() {

const int num = 10; int y = Default_Y; const int *ptr = 0; ptr = &num; *ptr = *ptr + y;

}




19

3 Entrada/Sada Console

As rotinas de entrada/sada do console se encontram nas bibliotecas "stdio.h" e "conio.h" e,

por isso, estas bibliotecas devem ser includas nos programas aplicativos atravs da diretiva

include: #include #include

Algumas das funes de entrada e sada para a console mais utilizadas so apresentadas a

seguir:

3.1 Printf()

A funo printf() uma das funes de E/S (entrada e sada) que podem ser usadas em C.

Ela no faz parte da definio de C mas todos os sistemas tm uma verso de printf() implementada.

Ela permite a sada formatada na tela. J vimos duas aplicaes diferentes da funo printf():

printf(Bom Dia!!!!); printf(Este o nmero dois: %d, num);

A funo printf() pode ter um ou vrios argumentos. No primeiro exemplo ns colocamos

um nico argumento: Bom Dia !!!!. Entretanto, no segundo colocamos dois: Este o nmero

dois: %d que est esquerda e o valor 2 direita da vrgula que separa os argumentos. Sintaxe de

printf(): printf(string-formatao, < lista de parmetros >);

A string de formatao pode conter caracteres que sero exibidos na tela e cdigos de

formatao que indicam o formato em que os argumentos devem ser impressos. No nosso segundo

exemplo, o cdigo de formatao %d solicita a printf() para imprimir o segundo argumento em

formato decimal na posio da string onde aparece o %d. Cada argumento deve ser separado por

uma vrgula.




20

Alm do cdigo de formatao decimal (%d), printf() aceita vrios outros. O prximo

exemplo mostra o uso do cdigo %s para imprimir uma cadeia de caracteres:

#include int main(int argc, char* argv[]) { printf(%s esta a %d milhoes de milhas \n do sol., Venus, 67); }

A sada ser:

Venus est a 67 milhoes de milhas

do sol.

Aqui, alm do cdigo de formatao, a expresso de controle de printf() contm um conjunto

de caracteres estranho: \n. O \n um cdigo especial que informa a printf() que o restante da

impresso deve ser feito em uma nova linha. A combinao de caracteres \n representa, na

verdade, um nico caractere em C, chamado de nova-linha (equivalente ao pressionamento da tecla

Enter em um editor de texto).

Os caracteres que no podem ser obtidos diretamente do teclado para dentro do programa

(como a mudana de linha) so escritos em C, como a combinao do sinal \ (barra invertida) com

outros caracteres. Por exemplo, \n representa a mudana de linha.

A string de formatao define a forma como os parmetros sero apresentados e tem os

seguintes campos:

"%[Flags] [largura] [.preciso] [FNlh] < tipo > [\Escape Sequence]"

onde:




21

largura = nmero mximo de caracteres a mostrar;

preciso = nmero de casas aps a vrgula a mostrar

F = em ponteiros, apresentar como "Far" => base : offset (xxxx : xxxx)

N = em ponteiros, apresentar como "Near" => offset

h = apresentar como "short"

l = apresentar como "long"

A seguir so mostrados alguns exemplos da formatao apresentada acima:




22

#include int main(int argc, char* argv[ ]) {

float x; double y = -203.4572345; int a, b; a = b = 12; x = 3.141523; printf("Bom dia"); printf("\n\t Bom dia\n"); /*pula linha aps escrever bom dia*/ printf("O valor de x %7.3f\n", x); printf("Os valores de i, j e y so: %d %d %lf \n", a, b, y);

}

Obs: Caso voc queira imprimir na tela os caracteres especiais \ ou %, voc deve escrev-

los na funo printf() de forma duplicada, o que indicar ao compilador que este no se trata de um

parmetro da funo printf() mas sim que deseja-se imprimir realmente este caractere. O exemplo

abaixo apresenta este caso:

#include void main() {

int reajuste = 10; printf(O reajuste foi de %d%%. \n, reajuste);

}

a sada ser:

O reajuste foi de 10%.




23

3.2 Cprintf()

Basicamente cprintf() igual a printf(), mas usa as coordenadas atuais do cursor e da janela

que forem ajustados anteriormente, bem como ajustes de cr de caracteres. Utilize esta funo para

escrever na tela em posies pr-definidas.

3.3 Scanf()

A funo scanf() outra das funes de E/S implementadas em todos os compiladores C.

Ela o complemento de printf() e nos permite ler dados formatados da entrada padro (teclado). A

funo scanf() suporta a entrada via teclado. Um espao em branco ou um CR/LF (tecla Enter)

definem o fim da leitura. Observe que isto torna inconveniente o uso de scanf() para ler strings

compostas de vrias palavras (por exemplo, o nome completo de uma pessoa).

Para realizar este tipo de tarefa, veremos outra funo mais adequada na parte referente

strings. Sua sintaxe similar de printf(), isto , uma expresso de controle seguida por uma lista

de argumentos separados por vrgula.

Sintaxe: scanf(string de definio das variveis, );

A string de definio pode conter cdigos de formatao, precedidos por um sinal % ou ainda

o caractere * colocado aps o % que avisa funo que deve ser lido um valor do tipo indicado pela

especificao, mas no deve ser atribudo a nenhuma varivel (no deve ter parmetros na lista de

argumentos para estas especificaes).

A lista de argumentos deve consistir nos endereo das variveis. O endereo das variveis

pode ser obtido atravs do operador & apresentado na seco sobre ponteiros. Exemplo:




24


float x; printf ("Entre com o valor de x : "); scanf ("%f",&x); /*l o valor do tipo float e armazena em x*/

}

Esta funo funciona como o inverso da funo printf(), ou seja, voc define as variveis que

deveram ser lidas da mesma forma que definia estas com printf(). Desta forma, os parmetros de

scanf() so em geral os mesmos que os parmetros de printf(), no exemplo acima observa-se esta

questo.

O cdigo de formatao de scanf() igual ao cdigo de formatao de printf(). Por isso,

veja as tabelas de formatao de printf() para conhecer os parmetros de scanf(). Outro exemplo de

scanf():

#include main() {

float anos, dias; printf(Digite a sua idade em anos: ); scanf(%f, &anos); dias = anos*365; printf(Sua idade em dias e %.0f.\n, dias);

}

3.4 Getch(), Getche() e Getchar()

Em algumas situaes, a funo scanf() no se adapta perfeitamente pois voc precisa

pressionar [enter] depois da sua entrada para que scanf() termine a leitura. Neste caso, melhor

usar getch(), getche() ou getchar(). A funo getchar() aguarda a digitao de um caractere e

quando o usurio apertar a tecla [enter], esta funo adquire o caractere e retorna com o seu




25

resultado. Getchar() imprime na tela o caractere digitado. A funo getch() l um nico caractere

do teclado sem eco-lo na tela, ou seja, sem imprimir o seu valor na tela. A funo getche() tem a

mesma operao bsica, mas com eco. Ambas funes no requerem que o usurio digite [enter]

para finalizar a sua execuo. Veja exemplo abaixo, junto funo putch().

3.5 Putch() ou Putchar()

A funo putch() apresenta um nico caractere na tela, recebendo-o como parmetro. A

funo putchar() executa a mesma operao, com caracteres. Exemplo:

#include #include void main() {

char c1, c2; c1 = getch(); /* l caractere c1 mas no mostra na tela */ c2 = getche(); /* l caractere c2, escrevendo-o na tela */ printf("\nO primeiro valor digitado foi: "); putch(c1); /* escreve valor de c1 na tela */ printf("\nO segundo valor digitado foi: "); putchar(c2);

}

3.6 Exerccios

3.1 Escreva um programa que contenha uma nica instruo e imprima na tela:




26

3.2 Escreva um programa que imprima na tela:

3.3 Escreva um programa que pea os dados da conta bancria de um cliente e,

posteriormente, escreva na tela os dados do cliente tambm de forma organizada.

3.4 Escreva um programa que exemplifique todos os tipos de formataes fornecidas para o

printf().

3.5 Escreva um programa que pea ao usurio para entrar com um valor real (float), converta este

valor para uma varivel do tipo char e depois imprima o seu valor na tela em formato decimal e em

formato caractere.

3.6 Faa um programa que pea ao usurio para entrar com um caractere, converta este

nmero para um valor inteiro e apresente na tela o valor deste nmero em formato float e o endereo

da varivel que o contm. Utilize ponteiros para armazenar e acessar este valor.




27

4 Operadores

4.1 Operadores Aritmticos

C uma linguagem rica em operadores, em torno de 40. Alguns so mais usados que

outros, como o caso dos operadores aritmticos que executam operaes aritmticas. C oferece 6

operadores aritmticos binrios (operam sobre dois operandos) e um operador aritmtico unrio

(opera sobre um operando). So eles:

Binrios:

= Atribuio

+ Soma

- Subtrao

* Multiplicao

/ Diviso

% Mdulo (devolve o resto da diviso inteira)

Unrio:

- Menos unrio (indica a troca do sinal algbrico do valor)

O operador = j conhecido dos exemplos apresentados anteriormente. Em C, o sinal de

igual no tem a interpretao dada em matemtica. Representa a atribuio da expresso direita

ao nome da varivel esquerda. J os operadores + - / * representam as operaes aritmticas

bsicas de soma, subtrao, diviso e multiplicao. A seguir est um programa que usa vrios

operadores aritmticos e converte temperatura Fahrenheit em seus correspondentes graus Celsius.


int ftemp = 0; int ctemp = 0; printf("Digite temperatura em graus Fahrenheit: "); scanf("%d", &ftemp);




28

ctemp = (ftemp - 32)*5/9; printf("Temperatura em graus Celsius e %d", ctemp);

}

O operador mdulo (%) aceita somente operandos inteiros. Resulta o resto da diviso do

inteiro sua esquerda pelo inteiro sua direita. Por exemplo, 17%5 tem o valor 2 pois quando

dividimos 17 por 5 teremos resto 2.

4.2 Operadores Relacionais

Os operadores relacionais so usados para fazer comparaes. Em C no existe um tipo de

varivel chamada booleana, isto , que assuma um valor verdadeiro ou falso. O valor zero (0)

considerado falso e qualquer valor diferente de 0 considerado verdadeiro e representado pelo

inteiro 1. Os operadores relacionais comparam dois operandos e retornam 0 se o resultado for falso

e 1 se o resultado for verdadeiro. Os operadores relacionais disponveis em C so:

O programa a seguir mostra expresses booleanas como argumento da funo printf():

#include void main() { int verdade, falso; verdade = (15 < 20); falso = (15 == 20);




29

printf("Verdadeiro= %d, falso= %d\n", verdade, falso); }

Note que o operador relacional igual a representado por dois sinais de iguais. Um erro

comum o de usar um nico sinal de igual como operador relacional. O compilador no o avisar

que este um erro, por qu? Na verdade, como toda expresso C tem um valor verdadeiro ou falso,

este no um erro de programa e sim um erro lgico do programador.

4.3 Operadores lgicos binrios

Estes operadores so empregados para comparar os bits contidos em duas variveis, por isso,

so denominados operadores lgicos binrios. Ou seja, estes operadores fazem uma comparao

lgica entre cada bit dos operandos envolvidos. Os operadores binrios disponveis so:

A seguir temos um exemplo da aplicao destes operadores.


int i, j, k; i = 1; j = 2; printf("\ti = %x (00000001)\n\tj = %x (00000010)", i, j); k = i & j; /* k = i AND j */ printf("\n\t i & j => %x (00000000)", k);




30

k = i ^ j; /* k = i XOR j */ printf("\n\t i ^ j => %x (00000011)", k); k = i




31

4.5 Operadores Incrementais e Decrementais

Uma das razes para que os programas em C sejam pequenos em geral que C tem vrios

operadores que podem comprimir comandos de programas. Neste aspecto, destacam-se os

seguintes operadores:

O operador de incremento (++) incrementa de um seu operando. Este operador trabalha de

dois modos. O primeiro modo chamado pr-fixado e o operador aparece antes do nome da

varivel. O segundo o modo ps-fixado em que o operador aparece seguindo o nome da varivel.

Em ambos os casos, a varivel incrementada. Porm quando ++n usado numa instruo, n

incrementada antes de seu valor ser usado, e quando n++ estiver numa instruo, n incrementado

depois de seu valor ser usado. O programa abaixo mostra um exemplo destes operadores,

ressaltando esta questo.


int n, m, x, y; n = m = 5; x = ++n; y = m++; printf("O valor de n=%d, x=++n=%d, m=%d e y=m++=%d;",n,x,m,y);

}

Vamos analisar duas expresses seguintes.




32

a) k = 3*n++;

Aqui, primeiro n multiplicado por 3, depois o resultado atribudo a k e, finalmente, n

incrementado de 1.

b) k = 3*++n;

Primeiro n incrementado em 1, depois n multiplicado por 3 e, por fim, o resultado

atribudo a k.

Dica: Para evitar problemas, faa uso de parnteses para guiar a execuo do programa

evitando que o compilador no compreenda a ordem correta de executar a operao. Abaixo, temos

um outro exemplo dos operadores incrementais apresentado vrias aplicaes destes operadores:

void main() {

int i = 10; int *ptr = 0; i = i + 1; /* incrementa i */ i++; /* incrementa i */ i = i - 1; /* decrementa i */ i--; /* decrementa i */ ptr = &i; /* recebe o endereco de i */ (*ptr)++; /* incrementa valor de i */ ptr++; /* incrementa em 2 Bytes (1 inteiro */

/* ocupa 2 Bytes) o valor do endereo */ /* apontado pelo ponteiro ptr */

}

Ateno para a ltima instruo ptr++. Esta instruo ir altera o endereo armazenado em

ptr. Se o valor deste ponteiro for acessado, o dado representado por este ponteiro no tem mais

nenhuma relao com a varivel i, podendo conter qualquer dado. Por isso, tome cuidado ao

manipular ponteiros para no acessar variveis com uso desconhecido. Isto poder fazer com que o

seu programa gere erros fatais para o sistema operacional.




33

4.6 Operadores de Atribuio

O operador bsico de atribuio (=) pode ser combinado com outros operadores para gerar

instrues em forma compacta. Cada um destes operadores usado com um nome de varivel sua

esquerda e uma expresso sua direita. A operao consiste em atribuir um novo valor varivel

que depender do operador e da expresso direita. Se x uma varivel, exp uma expresso e op

um operador, ento:

x op= exp; equivale a x = (x)op(exp);

Exemplo:


int total = 0; int cont = 10; printf("Total=%d\n", total); total += 1; printf("Total=%d\n", total);




34

total ^= 2; printf("Total=%d\n", total); total 0) ? x : -x;

A expresso

printf( %d uma varivel %s !, x, ((x%2)?Impar:Par);

imprime mpar se x for um nmero mpar, caso contrrio imprimir par.




35

4.8 Precedncia

O operador ! o de maior precedncia, a mesma que a do operador unrio. A tabela

seguinte mostra as precedncias dos operadores:

4.9 Exerccios:

4.1 Qual o resultado da seguinte expresso:

int a = 1, b = 2, c = 3;

int result = ++a/a&&!b&&c||b--||-a+4*c>!!b;

4.2 Escreva uma expresso lgica que resulte 1 se o ano for bissexto e 0 se o ano no for

bissexto. Um ano bissexto se for divisvel por 4, mas no por 100. Um ano tambm bissexto se

for divisvel por 400.

4.3 Faa um programa que solicite ao usurio o ano e imprima Ano Bissexto ou Ano No-

Bissexto conforme o valor da expresso do exerccio anterior. Utilize o operador condicional.




36

4.4 Num cercado, h vrios patos e coelhos. Escreva um programa que solicite ao usurio o

total de cabeas e o total de ps e determine quantos patos e quantos coelhos encontram-se nesse

cercado.

4.5 Uma firma contrata um encanador a 20.000,00 por dia. Crie um programa que solicite o

nmero de dias trabalhados pelo encanador e imprima a quantia lquida que dever ser paga,

sabendo-se que so descontados 8% para imposto de renda.

4.6 Faa um programa que solicite um caractere do teclado por meio da funo getch(); se for

uma letra minscula imprima-a em maisculo, caso contrrio imprima o prprio caractere. Use uma

expresso condicional.

4.7 Faa um programa que solicite ao usurio uma seqncia binria com 16 bits.

Transforme esta seqncia de 0 e 1 em um nmero inteiro. Depois manipule este nmero inteiro

para verificar se os bits 0, 3, 7, 14 esto habilitados (valor igual a 1). Pea a usurio se ele deseja

modificar algum bit especfico da palavra. Se ele quiser, modifique o bit desejado para o valor por

ele fornecido.




37

5 Laos

Em C existem 3 estruturas principais de laos: o lao for, o lao while e o lao do-while.

5.1 O Lao For

O lao for engloba 3 expresses numa nica, e til principalmente quando queremos repetir

algo um nmero fixo de vezes. Sintaxe:

for(inicializao; teste; incremento)

instruo;

Os parnteses, que seguem a palavra chave for, contm trs expresses separadas por ponto-

e- vrgulas, chamadas respectivamente de : expresso de inicializao, expresso de teste e

expresso de incremento. As 3 expresses podem ser compostas por quaisquer instrues vlidas

em C.

Inicializao: executada uma nica vez na inicializao do lao. Serve para iniciar

variveis.

Teste: esta a expresso que controla o lao. Esta testada quando o lao inciado

ou reiniciado. Sempre que o seu resultado for verdadeiro, a instrues do lao sero executadas.

Quando a expresso se tornar falsa, o lao terminado.

Incremento: Define a maneira como a varivel de controle do lao ser alterada cada

vez que o lao repetido (conta++). Esta instruo executada, toda vez, imediatamente aps a

execuo do corpo do lao. Exemplo:


int conta; for(conta = 0; conta < 10; conta += 3)




38

printf("conta=%d\n", conta);

}

Qualquer uma das expresses de um lao for pode conter vrias instrues separadas por

vrgulas. A vrgula na verdade um operador C que significa faa isto e isto. Um par de

expresses separadas por vrgula avaliado da esquerda para a direita.


int x, y; for( x=0, y=0; x+y < 100; x = x+1, y++) printf("%d\n", x+y);

}

Podemos usar chamadas a funes em qualquer uma das expresses do lao. Qualquer uma

das trs partes de um lao for pode ser omitida, embora os pontos-e-vrgulas devam permanecer. Se

a expresso de inicializao ou a de incremento forem omitidas, elas sero simplesmente

desconsideradas. Se a condio de teste no est presente considerada permanentemente

verdadeira.

O corpo do lao pode ser composto por vrias instrues, desde que estas estejam delimitadas

por chaves { }. O corpo do lao pode ser vazio, entretanto o ponto-e-vrgula deve permanecer para

indicar uma instruo vazia. Quando um lao est dentro de outro lao, dizemos que o lao interior

est aninhado. Para mostrar esta estrutura preparamos um programa que imprime tabuada.


int i,j,k; printf("\n"); for(k=0; k




39

printf("\n");

for(i=1; i




40

int conta = 0; while(conta < 10) {

printf("conta=%d\n", conta); conta++;

} }

Quando se conhece a priori o nmero de loops que o lao deve fazer, recomenda-se o uso do

lao for. Caso o nmero de iteraes dependa das instrues executadas, ento se recomenda o uso

do lao while. Os laos while podem ser aninhados como o lao for. C permite que no interior do

corpo de um lao while, voc possa utilizar um outro lao while.

5.3 O Lao Do-While

O lao Do-While cria um ciclo repetido at que a expresso de teste seja falsa (zero). Este

lao bastante similar ao lao while. A diferena que no lao do-while o teste de condio

avaliado depois do lao ser executado. Assim, o lao do-while sempre executado pelo menos uma

vez. Sintaxe:

do {

instruo; } while(expresso de teste);

Embora as chaves no sejam necessrias quando apenas uma instruo est presente no corpo

do laop do-while, elas so geralmente usadas para aumentar a legibilidade. Exemplo usando os

laos while e do-while:




41

#include #include #include /* requerida para rand() */ void main() {

char ch, c; int tentativas; do {

ch = rand()%26 + 'a'; tentativas = 1; printf("\nDigite uma letra de 'a' a 'z':\n"); while((c=getch())!= ch) {

printf("%c e incorreto. Tente novamente. \n\n",c); tentativas++;

} printf("\n%c e correto",c); printf("\nvoce acertou em %d tentativas", tentativas); printf("\nQuer jogar novamente? (s\\n): ");

}while(getche()=='s'); }

5.4 Break e Continue

O comando break pode ser usado no corpo de qualquer estrutura do lao C. Causa a sada

imediata do lao e o controle passa para o prximo estgio do programa. Se o comando break

estiver em estruturas de laos aninhados, afetar somente o lao que o contm e os laos internos a

este. J o comando continue fora a prxima interao do lao e pula o cdigo que estiver abaixo.

Nos while e do-while um comando continue faz com que o controle do programa v diretamente

para o teste condicional e depois continue o processo do lao. No caso do lao for, o computador




42

primeiro executa o incremento do lao e, depois, o teste condicional, e finalmente faz com que o lao

continue.

5.5 Goto

O comando goto faz com que o programa pule para a instruo logo aps o label passado

como parmetro. Este comando desnecessrio e desaconselhado. Foi implementado somente

para manter a compatibilidade com outros compiladores. A instruo goto tem duas partes: a

palavra goto e um nome. O nome segue as convees de nomes de variveis C. Por exemplo:

goto parte1;

Para que esta instruo opere, deve haver um rtulo (label) em outra parte do programa. Um

rtulo um nome seguindo por dois pontos.

parte1:

printf(Anlise dos Resultados.\n);

A instruo goto causa o desvio do controle do programa para a instruo seguinte ao rtulo

com o nome indicado. Os dois pontos so usados para separar o nome da instruo.

5.6 Exerccios

5.1 Escreva um programa que imprima os caracteres da tabela ASCII de cdigos de 0 a 255.

O programa deve imprimir cada caractere, seu cdigo decimal e hexadecimal. Monte uma tabela

usando os parmetros de formatao de printf().

5.2 Escreva um programa, utilizando um lao while, que leia caracteres do teclado.

Enquanto o usurio no pressionar a tecla ESC de cdigo 27, os caracteres lidos no so ecoados no




43

vdeo. Se o caractere lido for uma letra minscula, o programa a imprime em maisculo e, se for

qualquer outro caractere, ele mesmo impresso.

5.3 Elabore um programa que solicite um nmero inteiro ao usurio e crie um novo nmero

inteiro com os dgitos em ordem inversa. Por exemplo, o nmero 3567 deve ser escrito 7653.

5.4 Escreva um programa que desenhe uma moldura na tela do micro, desenhando um sol

com as tuas iniciais no meio da tela e escrevendo Feliz Natal e o seu nome embaixo.




44

6 Comandos para Tomada de Deciso

Uma das tarefas fundamentais de qualquer programa decidir o que deve ser executado a

seguir. Os comandos de deciso permitem determinar qual a ao a ser tomada com base no

resultado de uma expresso condicional. Isto significa que podemos selecionar entre aes

alternativas dependendo de critrios desenvolvidos no decorrer da execuo do programa.

C oferece 3 principais estruturas de deciso: if, if-else, switch. Estas estruturas so o tema

deste captulo.

6.1 If

O comando if usado para testar uma condio e caso esta condio seja verdadeira, o

programa ir executar uma instruo ou um conjunto delas. Este um dos comandos bsicos para

qualquer linguagem de programao. Sintaxe:

if(expresso de teste)

instruo;

Como C no possui variveis booleanas, o teste sobre a condio opera como os operadores

condicionais, ou seja, se o valor for igual a zero (0) a condio ser falsa e se o valor for diferente de

zero, a condio ser verdadeira. Como os laos, o comando if pode ser usado para uma nica

instruo ou para um conjunto delas. Caso se utilize para um conjunto de instrues, este conjunto

deve ser delimitado por chaves { e }.

Um comando if pode estar dentro de outro comando if. Dizemos ento que o if interno est

aninhado. O programa abaixo mostra exemplos do uso e da sintaxe dos comandos if. O primeiro if

mostra a forma aninhada do comando if, o segundo apresenta a sintaxe bsica e o ltimo um

exemplo onde o comando if executa um bloco de instrues.




45


char ch; printf("Digite uma letra de 'a' a 'z':"); ch = getche(); if(ch >= 'a') /* Dois comandos if aninhados */

if(ch




46

Exemplo:


int x, y; for(y=1; y




47

switch(varivel ou constante) {

case constante1: instruo; instruo; break;

case constante2: instruo; instruo; break;

case constante3: instruo: instruo: break;

default: instruo; instruo;

}

Voc no poder usar uma varivel nem uma expresso lgica como rtulo de um caso.

Pode haver nenhuma, uma ou mais instrues seguindo cada caso. Estas instrues no necessitam

estar entre chaves. O corpo de um switch deve estar entre chaves.

Se o rtulo de um caso for igual ao valor da expresso do switch, a execuo comea nele.

Se nenhum caso for satisfeito e existir um caso default, a execuo comear nele. Um caso default

opcional. No pode haver casos com rtulos iguais. A seguir apresentamos um exemplo que

calcula o dia da semana a partir de uma data. O ano deve ser maior ou igual a 1600, pois nesta data

houve uma redefinio do calendrio.





48

int D, M, A, i; long int F = 0; do {

do {

printf("\nDigite uma data na forma dd/mm/aaaa: "); scanf("%d/%d/%d", &D, &M, &A);

} while(A




49

break;

case 4: printf("\nQuinta-Feira"); break;

case 5: printf("\nSexta-Feira"); break;

case 6: printf("\nSabado"); break;

} }while(getche()!=27); /*Tecla ESC nao for pressionada*/

}

6.4 Exerccios

6.1 Crie um programa que desenhe na tela um tabuleiro de xadrez.

6.2 Crie um programa que desenhe na tela o seu quadro de horrios deste semestre.

6.3 Escreva um programa que solicite ao usurio trs nmeros inteiros a, b, e c onda a

maior que 1. Seu programa deve somar todos os inteiros entre b e c que sejam divisveis por a.

6.4 A sequncia de Fiboncci a seguinte: 1, 1, 2, 3, 5, 8, 13, 21,... Os dois primeiros termos

so iguais a 1. Cada termo seguinte igual `a soma dos dois anteriores. Escreva um programa que

solicite ao usurio o nmero do termo e calcule o valor do termo. Por exemplo: se o nmero

fornecido pelo usurio for igual a 7, o programa dever imprimir 13.

6.5 Implemente um jogo da velha, onde o programa desenha na tela um tabuleiro e voc pede

a dois usurios (A e B) na respectiva ordem, que jogada eles querem realizar e depois atualiza o

desenho. O programa deve perceber quando o jogo acabou e anunciar o vencedor.




50

7 Funes

As funes servem para agrupar um conjunto de instrues de acordo com a tarefa que elas

desempenham. Uma vez implementada corretamente esta tarefa, voc no precisa mais se

preocupar em implementar esta tarefa, basta usar a sua funo. Por exemplo, quando usamos

printf() para imprimir informaes na tela, no nos preocupamos como o programa realiza esta

tarefa, pois a funo j fornecia este servio de forma adequada.

As funes quando bem empregadas, facilitam bastante a organizao modular do programa,

permitem a reutilizao de partes do programa e facilitam a sua manuteno. Uma funo uma

unidade de cdigo de programa autnoma desenhada para cumprir uma tarefa particular.

Provavelmente a principal razo da existncia de funes impedir que o programador tenha que

escrever o mesmo cdigo repetidas vezes.

7.1 Sintaxe

A estrutura de uma funo C bastante semelhante da funo main(). A nica diferena

que main() possui um nome especial pois a funo main() a primeira a ser chamada quando o

programa executado. Sintaxe:

( , ) {

; ; return ;

}

O tipo de retorno define o tipo de dado o qual a funo retornar com o resultado de sua

execuo. Nome indica qual o nome da funo. Em seguida temos a lista de argumentos da

funo inseridos entre os parnteses aps o nome da funo e separados por vrgulas. Os

argumentos so declarados no cabealho da funo com o tipo parmetro e em seguida o nome do




51

parmetro. Uma funo pode ter tantos argumentos quanto voc queira definir. Quando uma

funo no necessita de parmetros, o nome desta deve ser seguido por parnteses ( ) sem nenhum

parmetro no seu interior. A lista de instrues a serem executadas pela funo vem aps a lista de

parmetros e deve ser delimitada por chaves { e }. As instrues utilizam os parmetros para

executarem a tarefa.

Dentro do bloco de instrues da funo, primeiramente declara-se e inicializa-se as variveis

locais e posteriormente temos os comandos da funo (instrues). O comando return encerra a

funo e retorna ao ponto do programa onde esta foi chamada. No entanto, return no precisa ser o

ltimo comando da funo. Infelizmente, uma funo em C s pode retornar um resultado e este

repassado atravs de return. Algumas linguagens como Matlab permitem que uma funo retorne

mais do que uma nica varivel contendo o resultado.

Funes com tipo de retorno void, no utilizam o comando return pois estas no retornam

nenhum tipo de dado. O comando return utilizado quando queremos finalizar esta funo antes

de executar todas as instrues. Neste caso, ele aparece sem nenhum parmetro a sua direita,

somente o ponto-e-vrgula. Quando uma funo no tem um tipo de retorno definido, o compilador

C considera que o tipo de retorno adotado void.

Do mesmo modo que chamamos uma funo de biblioteca C (printf(), getche(), ...)

chamamos nossas prprias funes. Os parnteses que seguem o nome so necessrios para que o

compilador possa diferenciar a chamada a uma funo de uma varivel que voc esqueceu de

declarar. Visto que a chamada de uma funo constitui uma instruo de programa, deve ser

encerrada por ponto-e-vrgula. Entretanto, na definio de uma funo, o ponto-e-vrgula no pode

ser usado.

7.2 Exemplos

Abaixo apresentamos um exemplo do emprego das funes:

#include doisbeep() {

int k;




52

printf("\x7"); /* Beep 1 */ for(k=1; k 1) return i*Fatorial(i-1);




53

else return 1;

}

Cada chamada recursiva da funo fatorial coloca mais uma varivel i do tipo long int na

pilha (stack). , portanto, necessrio ter cuidado com funes recursivas, pois estas podem causar

um estouro da pilha. Exemplo de funo para calcular a rea da esfera:

#include float area(float r); /* declaracao do prototipo da funcao */ float potencia(float num, int pot); void main() {

float raio = 0; printf("Digite o raio da esfera: "); scanf("%f", &raio); printf("A area da esfera e' %.2f", area(raio));

} /* funo area () - retorna a area da funcao */ float area(float r) /* definicao da funcao */ {

return (4*3.14159*potencia(r,2)); /* retorna float */ } /* funcao que eleva a uma potencia positiva um parametro dado */ float potencia(float num, int pot) {

float result = 0; /* declaracao de var. local */ int i = 0; if(pot < 0)

return 0; /* Indica que houve erro */ if(pot == 0)

return 1; result = num;




54

for(i = 1; i < pot; i++) result *= num; return result;

}

7.3 Prototipagem

Toda funo que for utilizada em main() e que for declarada aps main(), tem que ser

prototipada. O prottipo consiste de uma verso simplificada do cabealho da funo, na forma:

();

Se main() for declarado por ltimo, nenhuma prototipagem necessria. Prottipos so

tambm utilizados para escrever programas compostos de vrios mdulos, como veremos mais

frente. Feita a declarao do prottipo da funo, esta poder ser chamada ou definida em qualquer

parte do seu programa, por isso que o prottipo de uma funo tem um papel importante para a

organizao e flexibilidade do seu cdigo fonte. O programa anterior e o exemplo abaixo

apresentam a forma de se criar o prottipo de uma funo.

double Raiz(double); /* prottipo */ main() {

double x,y; x = 4.0; y = Raiz(x);

} double Raiz(double valor) {

/* ; */ return valor;

}




55

7.4 Classes de Armazenamento

Todas as variveis e funes em C tm dois atributos: um tipo e uma classe de

armazenamento. Os tipos ns j conhecemos. As 4 classes de armazenamento sero vistas a

seguir:

auto, extern, static e register.

7.4.1 Auto

As variveis que temos visto em todos os nossos exemplos esto confinadas nas funes que

as usam; isto , so visveis ou acessveis somente s funes onde esto declaradas. Tais variveis

so chamadas locais ou automticas, pois so criadas quando a funo chamada e destruda

quando a funo termina a sua execuo.

As variveis declaradas dentro de uma funo so automticas por default. Variveis

automticas so as mais comuns dentre as 4 classes. A classe de variveis automticas pode ser

explicitada usando-se a palavra auto. As duas declaraes abaixo so equivalentes:

auto int n; int n;

7.4.2 Extern

Todas as funes C e todas as variveis declaradas fora de qualquer funo tm a classe de

armazenamento extern. Variveis com este atributo sero conhecidas por todas as funes

declaradas depois dela. A declarao de variveis externas feita da mesma maneira como

declaramos variveis dentro do bloco de uma funo.

Uma varivel definida fora de qualquer funo dita extern. A palavra extern indica que a

funo usar mais uma varivel externa. Este tipo de declarao, entretanto, no obrigatrio se a

definio original ocorre no mesmo arquivo fonte. A seguir temos um exemplo:




56

#include int teclanum; /* Declaracao de variaveis extern */ void parimpar(void); /* Declaracao de funcoes */ void main() {

extern teclanum; printf("Digite teclanum: "); scanf("%d", &teclanum); parimpar();

} /* parimpar() - checa se teclanum e' par ou impar */ void parimpar(void) {

extern teclanum; if(teclanum % 2)

printf("teclanum e' impar. \n"); else

printf("teclanum e' par. \n"); }

7.4.3 Static

Variveis static de um lado se assemelham s automticas, pois so conhecidas somente as

funes que as declaram e de outro lado se assemelham s externas pois mantm seus valores

mesmo quando a funo termina. Declaraes static tm dois usos importantes e distintos. O mais

elementar permitir a variveis locais reterem seus valores mesmo aps o trmino da execuo do

bloco onde esto declaradas. Exemplo:

#include void soma(); void main() {




57

soma(); soma(); soma();

} /* soma() - usa variavel static */ void soma() {

static int i = 0; i++; printf("i = %d\n", i);

}

Observe que i no inicializada a cada chamada de soma(). Portanto, a sada ser:

i = 0 i = 1 i = 2

7.4.4 Variveis Estticas Externas

O segundo e mais poderoso uso de static associado a declaraes externas. Junto a

construes externas, permite um mecanismo de privacidade muito importante programao

modular.

A diferena entre variveis externas e externas estticas que variveis externas podem ser

usadas por qualquer funo abaixo de (a partir das) suas declaraes, enquanto que variveis

externas estticas somente podem ser usadas pelas funes de mesmo arquivo-fonte e abaixo de suas

declaraes. Isto , voc pode definir uma varivel static em um arquivo fonte onde esto todas as

funes que necessitam acesso a esta varivel. Os demais arquivos fontes no tero acesso a ela.




58

7.4.5 Register

A classe de armazenamento register indica que a varivel associada deve ser guardada

fisicamente numa memria de acesso muito mais rpida chamada registrador. Um registrador da

mquina um espao de memria junto ao microprocessador onde se podem armazenar variveis do

tipo inteiro ou char. Opera como uma varivel do tipo auto, mas possui um tempo de acesso muito

mais rpido, isto , o programa torna-se mais rpido usando register. Variveis que usualmente

utilizam este tipo so as variveis de laos e argumentos de funes, justamente, para que possamos

aumentar a velocidade do programa.

Como os computadores possuem um nmero limitado de registradores (2 para o IBM-PC), o

seu programa tambm s poder utilizar um nmero limitado de variveis register. Mas isto no

nos impede de declarar quantas variveis register quisermos. Se os registradores estiverem

ocupados o computador simplesmente ignora a palavra register das nossas declaraes.

register int i; for(i = 0; i< 10; i++) printf(Nmero: %d, i);

7.5 Exerccios

7.1 Um nmero primo qualquer inteiro positivo divisvel apenas por si prprio e por 1.

Escreva uma funo que receba um inteiro positivo e, se este nmero for primo, retorne 1, caso

contrrio retorne 0. Faa um programa que imprima na tela os n primeiros nmeros primos, onde

n ser fornecido pelo usurio.

7.2 Crie um programa para gerar nmeros aleatrios, utilizando variveis static para

armazenar o valor da semente.




59

7.3 Crie um programa para calcular o fatorial de um nmero, para tal implemente uma funo

recursiva.

7.4 Escreva um programa que solicite ao usurio um ano e imprima o calendrio desse ano.

Utilize os programas desenvolvidos nos exerccios 4.2 e 4.3. Organize o programa de forma

adequada atravs de funes.

7.5 Escreva uma funo recursiva de nome soma() que receba um nmero inteiro positivo n

como argumento e retorne a soma dos n primeiros nmeros inteiros. Por exemplo, se a funo

recebe n = 5, deve retornar 15, pois:

15 = 1 + 2 + 3 + 4 + 5




60

8 Diretivas do Pr-Processador

O pr-processador C um programa que examina o cdigo fonte em C e executa certas

modificaes no cdigo, baseado em instrues chamadas diretivas. O pr-processador faz parte do

compilador e pode ser considerado uma linguagem dentro da linguagem C. Ele executado

automaticamente antes da compilao. Diretivas do pr-processador seriam instrues desta

linguagem. As instrues desta linguagem so executadas antes do programa ser compilado e tm a

tarefa de alterar os cdigos-fonte, na sua forma de texto.

Instrues para o pr-processador devem fazer parte do texto que criamos, mas no faro

parte do programa que compilamos, pois so retiradas do texto compilador antes da compilao.

Diretivas do pr-processador so instrues para o compilador propriamente dito. Mais

precisamente, elas operam diretamente no compilador antes do processo de compilao ser iniciado.

Linhas normais de programa so instrues para o microprocessador; diretivas do pr-processador

so instrues para o compilador.

Todas as diretivas do pr-processador so iniciadas com o smbolo (#). As diretivas podem

ser colocadas em qualquer parte do programa, mas costume serem colocadas no incio do

programa, antes de main(), ou antes do comeo de uma funo particular.

8.1 Diretiva #define

A diretiva #define pode ser usada para definir constantes simblicas com nomes apropriados.

Como por exemplo, podemos criar uma constante para conter o valor de pi:

#define PI 3.14159

e depois utilizar o valor desta constante no programa:

area_esfera = (4*raio*raio*PI);




61

Quando o compilador encontra #define, ele substitui cada ocorrncia de PI no programa por

3.14159. O primeiro termo aps a diretiva #define (PI), que ser procurada, chamada

identificador. O segundo termo (3.14159), que ser substituda, chamada texto. Um ou mais

espaos separam o identificador do texto.

Note que s podemos escrever um comando deste por linha. Observe tambm que no h

ponto-e-vrgula aps qualquer diretiva do pr-processador. A diretiva #define pode ser usada no s

para definir constantes, como mostra o exemplo seguinte:

#include #define ERRO printf("\n Erro.\n") void main() {

int i; printf("\nDigite um numero entre 0 a 100: "); scanf("%d", &i); if(i100)

ERRO; }

8.2 Macros

A diretiva #define tem a habilidade de usar argumentos. Uma diretiva #define com

argumentos chamada de macro e bastante semelhante a uma funo. Eis um exemplo que ilustra

como macro definida e utilizada:

#include #define PRN(n) printf("%.2f\n",n); void main() {

float num1 = 27.25; float num2;




62

num2 = 1.0/3.0; PRN(num1); PRN(num2);

}

Quando voc usar a diretiva #define nunca deve haver espao em branco no identificador.

Por exemplo, a instruo:

#define PRN (n) printf(%.2f\n,n)

no trabalhar corretamente, porque o espao entre PR e (n) interpretado como o fim do

identificador. Para definir um texto muito grande devemos delimitar a linha anterior com uma

barra invertida \ e prosseguir com a definio em outra linha.

Toda ocorrncia de PRN(n) em seu programa substituda por printf(%.2f\n,n). O n na

definio da macro substitudo pelo nome usado na chamada a macro em seu programa; portanto,

PRN(num1)ser substitudo por printf(%.2f\n,num1). Assim, n age realmente com um

argumento

linguagem de programacao c

Documents