Linguagem de Programacao C
Transcript of 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
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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.
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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.
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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.
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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;
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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:
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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:
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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 = # /* 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 */
}
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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.
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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 = # *ptr = *ptr + y;
}
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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.
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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:
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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:
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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%.
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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:
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
24
#include void main() {
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
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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:
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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.
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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.
#include void main() {
int ftemp = 0; int ctemp = 0; printf("Digite temperatura em graus Fahrenheit: "); scanf("%d", &ftemp);
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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);
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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.
#include void main() {
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);
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
30
k = i ^ j; /* k = i XOR j */ printf("\n\t i ^ j => %x (00000011)", k); k = i
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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.
#include void main() {
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.
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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.
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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:
#include void main() {
int total = 0; int cont = 10; printf("Total=%d\n", total); total += 1; printf("Total=%d\n", total);
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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.
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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.
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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.
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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:
#include void main() {
int conta; for(conta = 0; conta < 10; conta += 3)
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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.
#include void main() {
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.
#include void main() {
int i,j,k; printf("\n"); for(k=0; k
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
39
printf("\n");
for(i=1; i
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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:
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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.
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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.
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
45
#include #include void main() {
char ch; printf("Digite uma letra de 'a' a 'z':"); ch = getche(); if(ch >= 'a') /* Dois comandos if aninhados */
if(ch
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
46
Exemplo:
#include void main() {
int x, y; for(y=1; y
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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.
#include #include void main() {
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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.
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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;
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
52
printf("\x7"); /* Beep 1 */ for(k=1; k 1) return i*Fatorial(i-1);
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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;
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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;
}
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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:
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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() {
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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.
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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.
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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);
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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;
-
Informtica para Automao Linguagem de Programao
Prof. Carlos Pantaleo
Curso de Tecnologia de Automao Industrial e Engenharia de Controle e Automao
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