1Fundamentos da Linguagem C

Neste capitulo serão vistos os fundamentos da linguagem C. O conceito de linguagem de programação, linguagens de alto e baixo nível, linguagens genéricas e especificas. Será visto um pouco do histórico da criação da linguagem e a descrição das características mais importantes da linguagem C. Finalmente, será visto o aspecto geral de um código fonte escrito em C.

1.1 - Linguagens de Programação
Um programa de computador é um conjunto instruções que representam um algoritmo para a resolução de algum problema. Estas instruções são escritas através de um conjunto de códigos (símbolos e palavras). Este conjunto de códigos possui regras de estruturação lógica e sintática própria. Dizemos que este conjunto de símbolos e regras formam uma linguagem de programação. 1.1.1 - Exemplos de códigos. Existem muitas linguagens de programação. Podemos escrever um algoritmo para resolução de um problema por intermédio de qualquer linguagem. A seguir mostramos alguns exemplos de trechos de códigos escritos em algumas linguagens de programação.

Exemplo: trecho de um algoritmo escrito em Pseudo-linguagem que recebe um número num e escreve a tabuada de 1 a 10 para este valor: leia (num); para n de 1 até 10 passo 1 faça tab ← num * n; imprime tab; fim-para Exemplo: trecho do mesmo programa escrito em linguagem C: scanf(&num); for(n = 1; n <= 10; n++) { tab = num * n; printf(”\n %d”, tab); } Exemplo: trecho do mesmo programa escrito em linguagem Basic: 10 input num 20 for n = 1 to 10 step 1 30 let tab = num * n 40 print chr$ (tab) 50 next n

1.1.2 - Linguagens de baixo e alto nível.
Podemos dividir, genericamente, as linguagens de programação em dois grandes grupos: as linguagens de baixo nível e as de alto nível: • Linguagens de baixo nível: São linguagens voltadas para a máquina, isto é, são escritas usando as instruções do microprocessador do computador. São genericamente chamadas de linguagens Assembly. Vantagens: Programas são executados com maior velocidade de processamento. Os programas ocupam menos espaço na memória. Desvantagens: Em geral, programas em Assembly tem pouca portabilidade, isto é, um código gerado para um tipo de processador não serve para outro. Códigos Assembly não são estruturados, tornando a programação mais difícil. • Linguagens de alto nível: São linguagens voltadas para o ser humano. Em geral utilizam sintaxe estruturada tornando seu código mais legível. Necessitam de compiladores ou interpretadores para gerar instruções do microprocessador. Interpretadores fazem a interpretação de cada instrução do programa fonte executando-a dentro de um ambiente de programação, Basic e AutoLISP por exemplo. Compiladores fazem a tradução de todas as instruções do programa fonte gerando um programa executável. Estes programas executáveis (*.exe) podem ser executados fora dos ambientes de 1

programação, C e Pascal por exemplo. As linguagens de alto nível podem se distinguir quanto a sua aplicação em genéricas como C, Pascal e Basic ou específicas como Fortran (cálculo matemático), GPSS (simulação), LISP (inteligência artificial) ou CLIPPER (banco de dados). Vantagens: Por serem compiladas ou interpretadas, tem maior portabilidade podendo ser executados em varias plataformas com pouquíssimas modificações. Em geral, a programação torna-se mais fácil por causa do maior ou menor grau de estruturação de suas linguagens. Desvantagens: Em geral, as rotinas geradas (em linguagem de maquina) são mais genéricas e portanto mais complexas e por isso são mais lentas e ocupam mais memória.

1.2 - Linguagem C
A linguagem C é uma linguagem de alto nível, genérica. Foi desenvolvida por programadores para programadores tendo como meta características de flexibilidade e portabilidade. O C é uma linguagem que nasceu juntamente com o advento da teoria de linguagem estruturada e do computador pessoal. Assim tornou-se rapidamente uma linguagem “popular” entre os programadores. O C foi usado para desenvolver o sistema operacional UNIX, e hoje esta sendo usada para desenvolver novas linguagens, entre elas a linguagem C++ e Java.

1.2.1 - Características do C
Entre as principais características do C, podemos citar: • O C é uma linguagem de alto nível com uma sintaxe bastante estruturada e flexível tornando sua programação bastante simplificada. • Programas em C são compilados, gerando programas executáveis. • O C compartilha recursos tanto de alto quanto de baixo nível, pois permite acesso e programação direta do microprocessador. Com isto, rotinas cuja dependência do tempo é crítica, podem ser facilmente implementadas usando instruções em Assembly. Por esta razão o C é a linguagem preferida dos programadores de aplicativos. • O C é uma linguagem estruturalmente simples e de grande portabilidade. O compilador C gera códigos mais enxutos e velozes do que muitas outras linguagens. • Embora estruturalmente simples (poucas funções intrínsecas) o C não perde funcionalidade pois permite a inclusão de uma farta quantidade de rotinas do usuário. Os fabricantes de compiladores fornecem uma ampla variedade de rotinas pré-compiladas em bibliotecas.

1.2.2 - Histórico
1970: Denis Ritchie desenha uma linguagem a partir do BCPL nos laboratórios da Bell Telephones, Inc. Chama a linguagem de B. 1978: Brian Kerningham junta-se a Ritchie para aprimorar a linguagem. A nova versão chama-se C. Pelas suas características de portabilidade e estruturação já se torna popular entre os programadores. ~1980: A linguagem é padronizada pelo American National Standard Institute: surge o ANSI C. ~1990: A Borland International Co, fabricante de compiladores profissionais escolhe o C e o Pascal como linguagens de trabalho para o seu Integrated Development Enviroment (Ambiente Integrado de Desenvolvimento): surge o Turbo C. ~1992: O C se torna ponto de concordância entre teóricos do desenvolvimento da teoria de Object Oriented Programming (programação orientada a objetos): surge o C++.

1.3 - Estrutura de um programa em C
Um programa em C é constituído de: • um cabeçalho contendo as diretivas de compilador onde se definem o valor de constantes simbólicas, declaração de variáveis, inclusão de bibliotecas, declaração de rotinas, etc. • um bloco de instruções principal e outros blocos de rotinas. • documentação do programa: comentários. Programa Exemplo: O arquivo e0101.cpp contém um programa para calcular a raiz quadrada de um número real positivo:
/* *******************************************************************

2

Programa: e0101.cpp Proposito: Calcula a raiz quadrada de um numero real positivo maior que 1.0 com precisao PREC (0.00001). ******************************************************************* */ #define MAX 100 // numero máximo de iterações #define PREC 0.000001 // precisão da raiz void main(){ // inicia programa principal... float num // numero do qual se quer saber a raiz quadrada float raiz; // aproximação para raiz de num float inf, sup; // intervalo que contem a raiz procurada do { printf("\n\nDigite um numero real positivo: "); scanf("%f",&num; } while(num <= 1.0); // aceita somente positivo maior que 1.0! inf = 0.0; // inicializa intervalo inicial de busca sup = num; i = 0; // inicializa contador do // faca... { i = i + 1; // incrementa contador raiz = 0.5 * (inf + sup); // faz estimativa de raiz if(raiz*raiz > num) // se chute foi alto... { sup = raiz; // baixa limite superior } else // ...senão... { inf = raiz; // sobe limite inferior } } while( (sup-inf) > PREC && i < MAX); // enquanto intervalo grande raiz = 0.5 * (inf + sup); // estima a raiz printf("Raiz: %f +- %f",raizPREC); // imprime o valor da raiz } // fim do programa

1.3.1 - Conjunto de caracteres
Um programa fonte em C é um texto não formatado escrito em um editor de textos usando um o conjunto padrão de caracteres ASCII. A seguir estão os caracteres utilizados em C: • Caracteres válidos: a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 1 2 3 4 5 6 7 8 9 0 + - * / \ = | & ! ? # % ( ) { } [ ] _ ‘ “ . , : < > • Caracteres não válidos: @ $ ¨ á é õ ç Os caracteres acima são válidos apenas em strings. Veja seção 2.1.4.

1.3.2 - Comentários
Em C, comentários podem ser escritos em qualquer lugar do texto para facilitar a interpretação do algoritmo. Para que o comentário seja identificado como tal, ele deve ter um /* antes e um */ depois. Observe que no exemplo e0101.cpp todo o cabeçalho esta dentro de um comentário. • Exemplo: /* esta é uma linha de comentário em C */ O C++ permite que comentários sejam escritos de outra forma: colocando um // em uma linha, o compilador entenderá que tudo que estiver a direita do símbolo é um comentário. Observe no programa exemplo e0101.cpp as linhas de comentários colocadas a direita dos comandos. • Exemplo: // este é um comentário valido apenas em C++

3

entrada e sadia de informações via portas serial e paralela serão vistas em capítulos posteriores. A diretiva #include diz ao compilador para incluir na compilação do programa outros arquivos. float (real de simples precisão) e outras que serão vistas no capitulo 2. 1. reais.Diretivas de Compilação Em C. inf e sup são declaradas como variáveis reais. Estas estruturas serão vistas em detalhes nos capítulos 4 e 5. A diretiva #define diz ao compilador quais são as constantes simbólicas usadas no programa. sadia gráfica. fim-enquanto Linguagem C while (condição) { bloco 1. bloco n.3 . scanf é uma função de leitura de teclado.3. Geralmente estes arquivos contem bibliotecas de funções ou rotinas do usuário. Veremos no capitulo 3 algumas funções de entrada e sadia de informações via teclado e tela.3. senão bloco 2. raiz. } • Estrutura de Repetição: Permite executar repetidamente um bloco de instruções ate que uma condição de controle seja satisfeita. } 2Constantes e Variáveis Neste capitulo veremos como os dados constantes e variáveis são manipulados pela linguagem C.4 .Declaração de variáveis Em C. Quais são as regras de atribuição de nomes a variáveis e quais são os tipos de dados que O C pode manipular. 1. O que são constantes inteiras. No exemplo e0101. caracteres e strings. Outras funções de leitura e escrita em arquivos. Veremos sobre esta diretiva no capitulo 2.cpp num. No exemplo acima printf é uma função de escrita na tela. Estes comandos são genericamente chamados de diretivas de compilação. pseudo-linguagem se condição então bloco 1. pseudo-linguagem enquanto (condição) faça bloco 1. bloco n. como na maioria das linguagens. Voltaremos a trabalhas esta diretiva com mais detalhe no capítulo 5. Estes comandos informam ao compilador do C basicamente quais são as constantes simbólicas usadas no programa e quais bibliotecas devem ser anexadas ao programa executável. Estas variáveis podem ser de vários tipos: int (inteiro). enquanto i é declarada como uma variável inteira. existem comandos que são processados durante a compilação do programa. 1. as variáveis devem ser declaradas no inicio do programa.3. funções de manipulação de mouse. Estas operações são chamadas de operações de entrada e sadia. } else { bloco 2.Entrada e saída de dados Em C existem varias maneiras de fazer a leitura e escrita de informações. 4 . Duas estruturas das estruturas básicas (decisão e repetição) são muito semelhantes as estruturas usadas nas Pseudo-linguagem algorítmicas: • Estrutura de Decisão: Permite direcionar o fluxo lógico para dois blocos distintos de instruções conforme uma condição de controle. fim-se Linguagem C if (condição) { bloco 1.5 .3. Veremos também como são declaradas as variáveis e as constantes simbólicas usadas em um programa.Estruturas de Controle A linguagem C permite uma ampla variedade de estruturas de controle de fluxo de processamento.1.6 .

Neste caso. 8.4e1 . Uma constante hexadecimal deve começar por 0x. Números inteiros podem ser escritos no formato decimal (base 10). caracteres e strings. c. • Exemplo: Abaixo estão representados algumas constantes caracteres. d. 1. 5. Um número ponto flutuante deve ter um ponto decimal que não pode ser substituído por uma vírgula. D. 4. e). (ponto) 1. 8. 010. b.2 (vírgula) 045 (primeiro dígito é 0: não é constante decimal) 212-22-33 (caracter ilegal: -) Uma constante inteira hexadecimal é formada por uma seqüência de dígitos decimais: 0. de ponto flutuante.e2 10. Se a constante tiver dois ou mais dígitos. 2. F (ou a.3 . 00 -03 045 02633 07575 -0101 • Exemplo: Algumas constantes inteiras octais inválidas. 3.1 .6e18 -. 5 .1.1 .Constantes O C possui quatro tipos básicos de constantes: inteiras.23e-9 -1. 7.Constantes de ponto flutuante Números reais (não inteiros) são representados em base 10. O número 1. • Exemplo: A seguir são mostrados algumas constantes inteiras hexadecimais válidas. pode ser 0 mas o compilador considerará esta constante como octal e não decimal. o primeiro não pode ser 0. 0x0 0x3 0x4f5a 0x2FFE OxABCD 0xAaFf • Exemplo: Algumas constantes inteiras hexadecimais inválidas. C. Neste caso o x10 é substituído por e ou E.853E+67 A forma de representação de um número real em C é bastante flexível. 0 3 -45 26338 -7575 1010 • Exemplo: Algumas constantes inteiras decimais inválidas. 5. E. De uma forma geral. • Exemplo: O número 314 pode ser representado por qualquer uma das seguintes formas: 314. 3.314E+3 314e0 2.1.Constantes caracteres Uma constante caracter é uma letra ou símbolo colocado entre aspas simples.Constantes inteiras Uma constante inteira é um número de valor inteiro. 6. 1. 9. por números com um ponto decimal e (opcionalmente) um expoente. hexadecimal (base 16) ou octal (base 8).e (vírgula) 0x ff (espaço) FFEE (não começa com 0x: não é constante hexadecimal) 0Xfg34 (caracter ilegal: g) Uma constante inteira octal é formada por uma seqüência de dígitos octais: 0. 6. (ponto) 0x1.2. 9.234 125. 3. • Exemplo: A seguir são mostradas alguns valores de constantes inteiras decimais válidas. 0x3. 1. 4. Um número de ponto flutuante pode ser escrito em notação científica.14e2 +3. 1. os dígitos hexadecimais podem ser minúsculos ou maiúsculos. Uma constante inteira decimal é formada por uma seqüência de dígitos decimais: 0. 7. 4. 7.65 . Constantes inteiras e de ponto flutuante representam números de um modo geral. A.14e+2 31.2 (vírgula) 0 4 (espaço) 45 (primeiro digito não é 0: não é constante octal) 01784 (caracter ilegal: 8) 2. 6.23e4 representa 1. 5.93 1. 0. (ponto) 01. constantes inteiras são seqüências de dígitos que representam números inteiros. 3. Na verdade. B. 2. Caracteres e strings representam letras e agrupamentos de letras (palavras).2 . 2. • Exemplo: Números de ponto flutuante válidos.1. A constante octal deve ter o primeiro digito 0 para que o compilador a identifique como tal • Exemplo: A seguir são mostrados algumas constantes octais válidas. 2.23 x 104 ou 12300.

pao&leite.’a’ ’b’ ’X’ ’&’ ’{’ ’ ’ Embora sejam visualizados como letras e símbolos as constantes caracteres são armazenadas internamente pelo computador como um número inteiro entre 0 e 255.4 . Por exemplo raiz e MAX são nomes de variáveis utilizadas no programa e0101. A .9). VetorPontosMovimentoRobo.cpp.1 . 2.. • Exemplo: os nomes abaixo não são válidos: 3dia. Abaixo segue uma lista das principais sequencias de escape usadas no C. ã. ”Oba!” ”Caxias do Sul” ”A resposta é: ” ”João Carlos da Silveira” 'a' ”isto é uma string” 2. Embora as instruções do C usem apenas os caracteres do conjunto padrão ASCII.z . TAM_MAX. Veja apêndice B. tem valor 65.Z) ou um underscore ( _ ). 6 . iteração. nota_1. ü. underscores ou dígitos (0 . Max são nomes diferentes para o compilador. Os valores numéricos dos caracteres estão padronizados em uma tabela chamada de American Standard Code for Information Interchange Table ou simplesmente tabela ASCII.2 -Identificadores Identificadores são os nomes das variáveis e funções usadas no programa. • Exemplo: os nomes abaixo são válidos: abc.Constantes strings Uma constante string consiste de um conjunto de caracteres colocados entre aspas duplas. Não pode conter outros caracteres. Esta propriedade é chamada de case sensibility. y24. Em C. O caracter ’A’ por exemplo. ç. max. Esta representação chama-se seqüência de escape representada por uma barra invertida (\) e um caracter. letras maiúsculas são diferentes de letras minúsculas: Por exemplo: MAX.2.Regras de sintaxe Os identificadores devem seguir as seguintes regras de construção: • Os identificadores devem começar por uma letra (a . . • Exemplo: Abaixo seguem algumas constantes strings válidas.. as constantes caracter e string podem conter caracteres do conjunto estendido ASCII: é. • Em C. os identificadores podem ter até 32 caracteres.1. • O resto do identificador deve conter apenas letras. Certos códigos de controle da tabela ASCII (como o line feed) ou caracteres especiais (como ') possuem representação especial no C. Seqüências de escape são interpretadas como caracteres simples. Controle/Caracter Sequencia de escape nulo (null) \0 campainha (bell) \a retrocesso (backspace) \b tabulacao horizontal \t nova linha (new line) \n tabulacao vertical \v alimentacao de folha (form feed) \f retorno de carro (carriage return) \r aspas (") \" apostrofo (') \' interrogacao (?) \? barra invertida (\) \\ Valor ASCII 00 07 08 09 10 11 12 13 34 39 63 92 2. vetor1.

4e38 1. sol. É possível declarar mais de uma variável ao mesmo tempo. fa. float nota_1. Se houver mais de uma variável. re. como na maioria das linguagens. old. controle de laço real (precisão de 7 dígitos) científico (precisão de 15 dígitos) 2.). declarações. seus nomes são separados por vírgulas. Esta divisão se deve basicamente ao número de bytes reservados para cada dado.2 . Tipo char int float double Tamanho 1 byte 2 bytes 4 bytes 8 bytes Intervalo -128 a 127 -32768 a 32767 3.2.Declaração de variáveis Para que se possa usar uma variável em um programa. mi.nota_2. A declaração de variáveis simplesmente informa ao processador quais são os nomes utilizados para armazenar dados variáveis e quais são os tipos usados.Tipos de dados Em C. Deste modo o processador pode alocar (reservar) o espaço necessário na memória para a manipulação destas variáveis. 2. caracter.z. real. Onde tipo é o tipo de dado e variavel_1 é o nome da variável a ser declarada. basta separá-las por vírgulas (. etc.3. y e z foram declaradas variáveis inteiras. int x. Os tipos char e int são inteiros e os tipos float e double são de ponto flutuante. • Exemplo: Declaração das variáveis: int i.] . estruturas. • Sintaxe: A sintaxe para declaração de variáveis é a seguinte: tipo variavel_1 [.Tipos básicos Abaixo segue uma lista dos tipos básicos de dados permitidos em C.3 .). double num. São chamadas as palavras reservadas e são de uso restrito da linguagem C (comandos. No exemplo acima.2. .2 .media. i.7e-308 a 1. char letra. si. new Do conjunto acima.4e-38 a 3. 2. do e new são palavras reservadas. la. x.7e308 Uso número muito pequeno e caracter ASCII contador.Palavras reservadas Existem certos nomes que não podem ser usados como identificadores. é necessário fazer uma declaração de variável antes. os dados são divididos tipos: inteiro. Do mesmo modo letra foi declarada como variável caracter podendo receber 7 . variavel_2. Cada tipo de dado possui um intervalo de valores permitidos. etc.3. Assim elas podem armazenar valores inteiros de -32768 até 32767..1 .. O conjunto de palavras reservadas usadas em C é o seguinte: asm auto break case cdecl char class const continue _cs default delete do double _ds else enum _es extern _export far _fastcall float for friend goto huge if inline int interrupt _loadds long near new operator pascal private protected public register return _saveregs _seg short signed sizeof _ss static struct switch template this typedef union unsigned virtual void volatile while • Exemplo: Não é possível declarar estes conjunto de variáveis: do.y.

É possível fazer a declaração de variáveis fora de uma rotina. var_2 = valor_2. Por enquanto. O uso de variáveis globais é explicado nos capítulos seguintes. • Exemplo: No exemplo seguinte a variável nome foi declarada como conjunto caracter e em seguida recebe uma constante string.147. Chamamos este procedimento de inicialização de uma variável. 8 .483. 2.647 0 a 4. • Exemplo: Inicialização de variáveis: int i = 0.5 .535 -2.Strings Uma string é um conjunto ordenado de caracteres que pode ser armazenado sob forma de um vetor ou um ponteiro. É possível.14 * raio * raio. Neste caso diz-se que se fez a declaração de variáveis globais.] . dentro de uma rotina. o processador coloca o resultado da conta (19.Tipos modificados Além dos tipos de dados citados acima existem outros tipos de dados ditos modificados. as variáveis área e raio foram declaradas como variáveis locais tipo float. Por conseqüência o intervalo de validade do número fica aumentado significativamente. var_1 é o nome da variável a ser inicializada e valor_1 é o valor inicial da variável. Depois.Inicialização de variáveis.4 . um para cada variável. usado somente em inteiros.295 3.4e-4932 a 1. Em conseqüência disto o intervalo do número fica dobrado.5. nos basta saber como declarar e armazenar um conjunto caracter em uma variável.1e4932 2. Por exemplo.5. float num = 13. em geral. • Sintaxe: A sintaxe para a inicialização de variáveis é: tipo var_1 = valor_1 [. o processador coloca no endereço alocado para raio o valor 2. neste caso a rotina main().625) no endereço de área. O modificador unsigned. Assim o processador faz a alocação de dois espaços (endereços) de 4 bytes cada para armazenar as informações. j = 100. a rotina principal main(). .294.648 a 2. Estas estruturas de dados serão vistas em detalhe nos capitulo 7 e 8. em C.483.valores de -128 até 127 ou caracteres do conjunto padrão ASCII. • Sintaxe: Para declararmos uma variável para receber um conjunto caracter devemos escrever: char* var.. Na terceira linha. char* nome. Onde tipo é o tipo de dado. Deste modo se diz que está se fazendo uma declaração de variáveis locais. No exemplo acima.3 . Tipo Tamanho (bytes) Intervalo unsigned char unsigned int long int unsigned long int long double 1 2 4 4 10 0 a 255 0 a 65.5. permite que um bit usado para guardar o sinal do número seja usado para guardar o valor do número.967. área = 3. 2. declarar uma variável e já armazenar nela um valor inicial. porém somente permite o uso de números positivos. nome = "João Carlos de Oliveira Andrade". Variáveis locais podem ser referenciadas apenas dentro da rotina dentro da qual foi declarada. nota_2 e media foram declaradas como ponto flutuante tipo float e num como ponto flutuante tipo double.3. area.147.. A declaração de variáveis é feita.3. • Exemplo: Observe o uso da declaração de variáveis no trecho de programa abaixo: void main() { float raio. Quando se faz a declaração de uma variável está se determinando que tipo de dado ela vai receber.3. Tipicamente o modificador long aumenta o número de bytes usados para o registro do número. na quarta linha. Em C existem dois modificadores: o modificador long e o modificador unsigned. As variáveis nota_1. } // declaração de variáveis raio = 2.

• Sintaxe: A sintaxe da instrução de conversão de tipo é: (tipo) variável onde tipo é o nome do tipo ao qual queremos converter o dado armazenado em variável. Do mesmo modo num foi declarada como variável float com valor inicial de 13.Constantes Simbólicas Muitas vezes identificamos uma constante numérica por um símbolo: Pi = 3. Podemos definir um nome simbólico para esta constante. 9 ..4 .5. No exemplo acima. 2. num = (int)valor % 2. Isto significa que todas as ocorrências do texto PI será trocado por 3. • Exemplo: a seguir definimos algumas constantes simbólicas. Este procedimento é chamado de conversão de tipo ou casting (moldagem.3. No exemplo acima a variável valor e os dados nela armazenados continuam sendo do tipo float após a conversão. #define PI 3. No exemplo acima. que seu conteúdo seja apresentado como float. o compilador vai interpretar esta instrução como se fosse escrita assim: área = 3. • Exemplo: observe a conversão de tipo feita no exemplo abaixo: int num.14159 #define ON 1 #define OFF 0 #define ENDERECO 0x378 void main(){ .. queremos que o dado seja apresentado em um tipo diferente do qual a variável foi inicialmente declarada. float valor = 13.1 uma explicação mais detalhada do uso da conversão de tipos. 2.6 . Também a variável titulo foi declarada como um conjunto caracter e recebeu como conteúdo inicial a string " Programa Teste ". definimos PI como 3. i e j foram declaradas variáveis tipo int. É importante salientar que a conversão de tipo é feita com o dado armazenado em uma variável mas a variável continua tendo o seu tipo original. • Sintaxe: A sintaxe da instrução de definição de uma constante simbólica é: #define nome valor Onde #define é uma diretiva de compilação que diz ao compilador para trocar as ocorrências do texto nome por valor. podemos definir uma constante simbólica que represente valor. Veremos na seção 3. A instrução #define deve ser escrita antes da instrução de declaração da rotina principal. momentaneamente. Observe que não há . O valor inicial de i é 0 e o de j é 100. no final da instrução pois trata-se de um comando para o compilador e não para o processador. Assim se escrevemos uma instrução: área = PI * raio * raio.0.14159.14159. Logo em seguida o conteúdo de valor é convertido para o tipo int para realizar a operação módulo (%) com o inteiro 2. 2. Aqui a conversão é necessária pois a operação módulo somente pode ser feita com inteiros.0.4. isto é.char* titulo = " Programa Teste ".1 . isto é. em inglês). Poderíamos escrever estas instruções assim: float pi = 3.Constantes definidas pelo programador O programador pode definir constantes simbólicas em qualquer programa.Conversão de tipo (Casting) Algumas vezes queremos.14159. No exemplo acima a variável valor foi declarada inicialmente como sendo do tipo float recebendo o valor inicial 13. momentaneamente. Por exemplo: declaramos uma variável como int e queremos.14159 por exemplo.14159 * raio * raio. modificar o tipo de dado representado por uma variável.

.h math.57079. π /2. procure mais detalhes na bibliografia recomendada. Estas constantes em geral definam alguns valores matemáticos (π .0. } área = M_PI * raio * raio.h limits. Esta instrução deve ser escrita antes do programa principal..h (mathematical functions). podemos perfeitamente definir nomes simbólicos usando letras minúsculas. #include <math.h conio. constantes e funções matemáticas estão guardadas na biblioteca math.. A seguir segue uma tabela contendo algumas (existem muitas outras) constantes simbólicas pré-definidas no compilador Turbo C++ da Borland.. relacionais.Constantes pré-definidas Em alguns compiladores C.h math.). 3Operadores. 1.2 . As operações a serem realizadas com os dados podem ser determinadas por operadores ou funções. Segundo. lógicos e condicionais.h> void main() { float area. podemos usá-la para definir macro instruções. Para que se possa usar a constante simbólica em um programa é preciso incluir a biblioteca na compilação do programa.h conio. Isto não é necessário. • Sintaxe: A sintaxe de inclusão de bibliotecas é a seguinte: #include <nome_bib> onde nome_bib é o nome da biblioteca que se deseja incluir..41421. Não veremos o uso de macros neste texto.h math. • Exemplo: O programa abaixo usa a constante predefinida M_PI para calcular a área de um disco circular... limites de tipos etc.h conio. e. 1. esta instrução é executada mais lentamente pois o processador precisa acessar a memória para verificar qual é o valor de pi. é um arquivo précompilado chamado arquivo header (cabeçalho. Uma biblioteca. Os operadores podem ser de atribuição. constantes e funções de manipulação teclado e monitor estão guardadas na biblioteca conio. Em cada biblioteca estão agrupadas constantes e funções semelhantes (veja seção 3.7. porém este tipo de instrução tem duas desvantagens: Primeiro. 0. Por exemplo.78539.h limits.h math. em C.31830. de atribuição aritmética..h conio.h Constante M_PI M_PI_2 M_PI_4 M_1_PI M_SQRT2 BLACK BLUE GREEN CYAN RED MAGENTA INT_MAX INT_MIN Valor 3. raio = 5. aritméticos. O uso da diretiva #define não se restringe apenas ao apresentado acima. Observe também que no exemplo definimos os nomes simbólicos com letras maiúsculas. 10 .4.. etc. porém faz parte do jargão dos programadores C usar letras maiúsculas para definir constantes simbólicas.h (console input and output).. incrementais.14159. 0. Expressões e Funções Um programa tem como característica fundamental a capacidade de processar dados.h conio. Processar dados significa realizar operações com estes dados.2).h conio. reserva 4 bytes de memória desnecessariamente.área = pi * área * área. 2. em inglês). Biblioteca math. algumas constantes simbólicas já estão pré-definidas. 0 1 2 3 4 5 32767 -32768 Significado π π /2 π /4 1/π √2 valor da cor (preto) valor da cor (azul) valor da cor (verde) valor da cor (cyan) valor da cor (vermelho) valor da cor (magenta) limite superior do tipo int limite inferior do tipo int Cada uma das constantes acima esta definida em uma biblioteca.

i = 5. Pode-se dizer que as conversões potencialmente perigosas (onde há possibilidade de perda de informação) são: char ← int ← float ← double 11 . 3. o valor da expressão ou operador da direita será convertido para o tipo do identificador da esquerda. Observe que o símbolo de atribuição = não tem o mesmo significado que o usual da matemática que representa a igualdade de valores. onde identificador é o nome de uma variável e expressão é uma expressão válida (ou outro identificador). b + 1 = a. i = r. Também não se pode confundir o operador de atribuição = com o operador relacional de igualdade == que será visto na seção 3.5. não pode ser uma constante ou expressão. em C.Conversão de tipo. Uma expressão é um arranjo de operadores e operandos. A cada expressão válida é atribuído um valor numérico.1 . representa a atribuição do valor calculado em expressão a variável identificador.1 . O identificador sqrt() é uma função que representa a operação de extrair a raiz quadrada de um número. i = j. Consiste de atribuir valor de uma expressão a uma variável. Exemplo: Algumas atribuições com conversão de tipo: int i.Operador de Atribuição A operação de atribuição é a operação mais simples do C. * a * c. Ao final da terceira instrução.0. r = i .1. Este símbolo.0. isto é. Se os dois operandos de uma atribuição não são do mesmo tipo. float r. Observe-se também que o operando esquerdo deve ser um identificador de variável. Sintaxe: A sintaxe da operação de atribuição é a seguinte: identificador = expressão. A expressão sqrt(9.Exemplo: o símbolo + é um operador que representa a operação aritmética de adição. Exemplo: Algumas atribuições com conversão de tipo e perda de informação: int i. // constante! // expressão! 3. Exemplo: 4 + 6 é uma expressão cujo valor é 10. // truncamento! Após a execução deste trecho de programa o valor da variável i será 654 pois seu valor foi truncado durante a conversão. Em pseudo-linguagem o operador de atribuição é representado como ←. Exemplo: A seguir são mostradas algumas atribuições válidas: a = 1.0 A variável i foi inicializada com o valor 5. float r = 654.1.0) tem valor 3. r recebe o valor 5. delta = b * b . Nestas conversões podem ocorrer alterações dos valores convertidos se o operando da esquerda for de um tipo que utilize menor numero de bytes que o operando da direita. // valor de i: 5 // valor de r: 5.321.4. Exemplo: A seguir são mostradas algumas atribuições inválidas: 1 = a.

A esta operação dá-se o nome de atribuição múltipla. // atribuições invalidas // 12 = i. max = min = 0.2 . i = 7. 3. Esta característica do C se contrapõe a algumas linguagens em que isto não é possível (Fortran. 3. assuma que i seja uma variável do tipo int.0. Observe que na atribuição múltipla as operações ocorrem da direita para a esquerda. são os identificadores de variáveis e expressão é uma expressão válida. // constante // f + d = d + f. Estas linguagens possuem tipos “duros” (hard types). Programa Exemplo: O arquivo e0301. double max. Exemplo: Observe a instrução de atribuição múltipla abaixo: as variáveis inteiras i. Exemplo: Observe as expressões abaixo. float f. Execute o programa passo-a-passo e observe o valor das variáveis.cpp traz um programa para visualizar alguns aspectos relacionados com o operador de atribuição.Limites do intervalo do tipo de dado. /************************************ Programa: e0301. min. Se a uma variável for atribuído um valor que esteja fora dos seus limites então este valor será alterado. Sintaxe: A sintaxe da atribuição múltipla é seguinte: var_1 = [var_2 = .g.3 . k. f = 10. Deve-se tomar cuidado com as conversões de tipo e limites de intervalo para atribuições de tipos diferentes. d = 4. É possível atribuir um valor a muitas variáveis em uma única instrução.j. É importante observar que em C. por exemplo).32464869714159..0: int i. ] expressão. Assim este detalhe pode gerar um erro de programação (bug) que passe desapercebido ao programador inexperiente.0.Atribuição múltipla.h. i = 4999 + 1.k. j. i = j = k = 1...1. int i. double d. j e k são todas inicializadas com o valor 1. É possível dizer que a linguagem C possui tipos “macios” (soft types) pois a operação com variáveis de tipos diferentes é perfeitamente possível.. var_2. . E as variáveis de dupla precisão max e min são inicializadas com o valor 0. Ultima Revisão: 22/07/97 ***********************************/ void main() { // declaração de variáveis char c. // Atribuições validas c = 'A'. inicialmente o valor de expressão é atribuído a var_2 e depois o valor de var_2 é atribuído a var_1.1. Isto pode acarretar resultados inesperados para o programador desatento. i = 4999. Também é importante observar que os tipos em C tem intervalos bem definidos e os resultados das operações devem respeitar estes intervalos.cpp Propósito: Operadores de atribuição. // expresso 12 . isto é. a ultrapassagem do limite de um tipo não é interpretado como erro.Observe que o compilador C ao encontrar esta operação não gera nenhum aviso de atenção para o programador. ao contrário de outras linguagens. onde var_1. i = 5000 + 30000. // o valor de i é 4999 // o valor de i é 5000 // o valor de i é -30536 O valor de 35000 ultrapassou o limite superior do tipo int (32767).

5461836294756. -.8.5 13 .999999. Veja a seção 3. f = g = h = 6. porém.1 . Os operadores +. Existe.2 .09571648723667.2. subtração.4 + 2. / podem operar números de todos os tipos (inteiros ou reais) porém o operador % somente aceita operandos inteiros. multiplicação e divisão. f = d. alguns detalhes são específicos da linguagem.Operadores Aritméticos Existem cinco operadores aritméticos em C. // Atribuição múltipla com perda de informação i = f = d = 3. i = i + 1000. // Conversão de tipo com perda de informação d = 74. uma função de biblioteca (pow()) que realiza esta operação. i = i + 1000. e devem ser observados. Embora as operações do C sejam semelhantes as operações aritméticas usuais da matemática. // valor ASCII de 'A' e' 65 f = i. //Truncamento! // Estouro dos limites de um tipo i = 30000. i = f. Exemplo: Algumas expressões aritméticas: 1+2 a-4. // Atribuição múltipla sem perda de informação d = f = i = 20.// Conversão de tipo sem perda de informação i = c.1 Valor 8. * multiplicação / divisão % módulo (resto da divisão inteira) Sintaxe: A sintaxe de uma expressão aritmética é: operando operador operando onde operador é um dos caracteres mostrados acima e operando é uma constante ou um identificador de variável. Existe ainda um operador (%) chamado operador de módulo cujo significado é o resto da divisão inteira. 3. i = 2. i = i + 1000. } 3.Restrições de operandos Os operandos dos operadores aritméticos devem ser constantes numéricas ou identificadores de variáveis numéricas. um operador específico para a operação de potenciação (ab). como existe em outras linguagens. Cada operador aritméticos está relacionado ao uma operação aritmética elementar: adição. subtração. d = f.7 adiante. Os símbolos dos operadores aritméticos são: Operador Operação + adição. *.0 b*c valor_1/taxa num%2 Não existe em C. Exemplo: Expressões válidas Expressão 6. // Passou do limite! // Atribuição múltipla i = j = k = 4.

5 3.2.000000 .5 3 Operandos float / float float / int int / float int / int Resultado float float float int Observe que no exemplo acima o valor da última expressão é 3 e não 3. alguns compiladores podem ter outras regras de conversão. O truncamento da divisão inteira é feito de modo a obter o menor valor absoluto.0. Se os operando forem de tipos diferentes então haverá uma conversão de tipo tal que o tipo que ocupa menos espaço de memória será convertido para o tipo que ocupa mais espaço de memória e o resultado será deste tipo. o programa será abortado e a mensagem divide error será exibida. num_f.0 * 2.000000000000000 Conversão int → float float → double int → double Observe que estas conversões podem gerar resultados surpreendentes para o programador desatento.4 % 3 Valor invalido! Podemos contornar o problema do operador inteiro da operação modulo usando o artifício da conversão de tipo (casting) mostrada na seção 2.000000000000000 6.0000000000000 2 * 3. den_i e den_f são inicializadas como: int num_i = 7 . Expressão 6.7 . Se alguma operação de divisão por zero for realizada o correra um erro de execução do programa (run-time error). 3.3. // inválido! // válido! Observe que usamos a conversão de tipo para que o dado armazenado em valor fosse transformado no tipo int assim a operação módulo pode ser efetuada. Isto ocorre porque como os dois operandos são tipo int o resultado e convertido para o tipo int e ocorre o truncamento. den_f = 2.Conversão de tipo.5 3. num = (int)valor % 2. float num_f = 7. num = valor % 2. Exemplo: Observe as expressões abaixo: Expressão Valor Conversão ’A’ + 1 ’B’ 65 + 1 → 66 ’A’ + ’B’ ’â’ 65 + 66 → 131 ’A’ + 32 ’a’ 65 + 32 → 97 14 .2.0. Em C caracteres são armazenados na memória como números inteiros e por isso operações aritméticas são permitidas com tipos char. Em geral: char → int → float → double Esta é uma regra geral. Expressão num_f / den_f num_f / den_i num_i / den_f num_i / den_i Valor 3. Exemplo: Observe as expressões abaixo.5.0 5. O resultado de uma operação aritmética depende dos tipos dos operandos.000000000000000 Valor 8. Se os operandos são do mesmo tipo o resultado será do mesmo tipo. Exemplo: A expressão abaixo é inválida pois o primeiro operando não é um numero inteiro.0.2 .0 7.2 2. Assuma que as variáveis num_i.0 2 1 Uma restrição ao operador de divisão (/) é que o denominador deve ser diferente de zero. Exemplo: Observe as conversões de tipo abaixo: Expressão 6 + 2. float valor = 13.0 6 / 3 47 % 2 5 4.4: Exemplo: Observe o trecho de programa abaixo: int num. Os valores usados são os correspondentes da tabela ASCII. den_i = 2 .

o seu valor e a ordem das operações efetuadas: Expressão 1 + 2 . na verdade. nas expressões abaixo.3) 0 (24 . Entre operadores de mesma precedência as operações são efetuadas da esquerda para a direita. f2. float f1.cpp Propósito: Operadores Aritméticos Ultima Revisão: 18/05/2000 ************************************* */ void main() { char c1. = 53. i2. Os parênteses são. = 4. f3.2.2 * 6) / 4 + 1 -1 6 / ((2 + 11) % 3) * 4 24 Ordem .Precedência de operadores. // operandos resultado // float / float float f3 = f1 / f2.1.0. Exemplo: Observe. = 4. Programa Exemplo: O arquivo e0302.3) * 5 105 (4 . Exemplo: Observe. = 3.3 24 . Veja a tabela 3. = 17.2 * 6 / 4 + 1 6 / 2 + 11 % 3 * 4 Valor 0 9 2 11 Ordem + * * / . // O operador % só aceita inteiros! f1 = f1 / 0. 15 .1.2. c2. // i1 i2 f1 f2 // Observe que f1 continua sendo float // somente o valor foi convertido. // Expressão invalida // i1 = f1 % 2. operadores de mais alta precedência e são executados primeiro. int i1.3 * 5 4 .+ / % * + A ordem de precedência dos operadores pode ser quebrada usando-se parênteses: ( ). Parênteses internos são executados primeiro que parênteses externos. porém. divisão (/) e módulo (%) tem precedência sobre os operadores de adição (+) e subtração (-). o seu valor e a ordem das operações efetuadas: Expressão Valor 1 + (2 .5 / f1.8 * 2.4 . Quando mais de um operador se encontram em uma expressão aritmética as operações são efetuadas uma de cada vez respeitando algumas regras de precedência: Estas regras de precedência são as mesmas da matemática elementar. // O divisor é zero! // Casting i1 = (int)f1 % 2. Os operadores de multiplicação (*). /*************************************** Programa: e0302.* * . Os valores. Execute o programa passo-a-passo e observe o valor das variáveis.+ .3.0.cpp traz um programa para visualizar alguns aspectos relacionados com os operadores aritméticos. são diferentes pois a ordem de execução das operações foi modificada pelo uso dos parênteses. Conversão de tipo = 17. nas expressões abaixo.0. = i1 % 3. // i1 i2 f1 f2 Expressões validas = 10 + 50 ./ + + % / * Observe que os operadores e os operandos deste exemplo são os mesmos do exemplo anterior.

/* ******************************************************************* Programa: e0303.cpp Propósito: Operadores de atribuição aritmética Ultima Revisão: 18/05/2000 ******************************************************************* */ void main() { char c.Operadores de Atribuição Aritmética Muitas vezes queremos alterar o valor de uma variável realizando alguma operação aritmética com ela.val.5 * 7 % 2.6.0 / 2.j. // float / int i1 / f2. exp. exp. int i. exp. // int / int (float)i1 / (float)i2.s.0. = 40 / 2 / 2 / 2. Como por exemplo: i = i + 1 ou val = val * 2. num = num * (1 + k). // int / float i1 / i2.0 .cpp traz um programa para visualizar alguns aspectos relacionados com os operadores de atribuição aritmética. // valor ASCII = 'M'. Programa Exemplo: O arquivo e0303. float float int Resultado truncado! // Resultado correto! Operando caracter = 65. Os símbolos usado são (+=. Precedência de operadores: Verifique o resultado = 3 . i = 0. 16 . num *= 1 + k.f3 f3 f3 f3 // c1 c2 c1 c2 // i1 i2 f1 } = = = = f1 / i2. exp. exp. Execute o programa passo-a-passo e observe o valor das variáveis. Exemplo: Observe as atribuições aritméticas abaixo e suas instruções equivalentes: Atribuição aritmética i += 1. = c1 + 1. troco /= 10. exp. /= . Sintaxe: A sintaxe da atribuição aritmética é a seguinte: var var var var var += -= *= /= %= exp. = c2 + 32. j = j . exp. foi desenvolvido na linguagem C uma instruções otimizadas com o uso de operadores ditos operadores de atribuição aritmética. exp. float r. j = 100. troco = troco / 10.0 + 2. 3. resto %= 2. onde var é o identificador da variável e exp é uma expressão válida. *=.0 * 3. Estas instruções são equivalentes as seguintes: var var var var var = = = = = var var var var var + * / % exp. Embora seja perfeitamente possível escrever estas instruções. resto = resto % 2. j -= val. O operador de atribuição aritmética tem precedência menor que os outros operadores até aqui discutidos. %=).3 . = 4. Instrução equivalente i = i + 1. Deste modo as instruções acima podem ser rescritas como: i += 1 e val *= 2. respectivamente. -=.

cpp traz um programa para visualizar alguns aspectos relacionados com os operadores incrementais. É importante que se conheça exatamente o efeito sutil da colocação do operador.cpp Proposito: Operadores incrementais Ultima Revisão: 22/07/97 ******************************************************************* */ void main(){ int i = 0. // s = s / (r . // Operadores aritméticos c += 2. Veja a tabela 3.9 s /= r . sendo superados apenas pelos parênteses que tem precedência ainda maior. char c = 'Z'. // Incremento 17 .47. Existem. j = 10. Caso o operador seja colocado à direita da variável.1. Nos dois casos o valor da variável será incrementado (ou decrementado) de uma unidade. b. o valor da variável será incrementado (ou decrementado) antes que a variável seja usada em alguma outra operação. Exemplo: Observe o fragmento de código abaixo e note o valor que as variáveis recebem após a execução da instrução: int a = b = c = a. i++. que serão vistos adiante. Uma instrução de decremento subtrai uma unidade do conteúdo de uma variável. em C. Execute o programa passo-a-passo e observe o valor das variáveis. Os operadores incrementais tem a mais alta precedência entre todos.1.0. // c = c + 2 i -= 4. // j = j % 7 r *= 7.r = -3. i = 3. // i = i . Porém se o operador for colocado á esquerda da variável. float f = -5. s = 546. operadores específicos para realizar as operações de incremento (++) e decremento (--). Sintaxe: A sintaxe dos operadores incrementais é a seguinte: instrução ++ var var ++ -. valor // a: // a: // a: // a: das ? 3 3 3 variáveis b: ? c: b: ? c: b: 5 c: b: 5 c: ? ? ? 4 i: i: i: i: 3 4 5 4 Os operadores incrementais são bastante usados para o controle de laços de repetição. Uma instrução de incremento adiciona uma unidade ao conteúdo de uma variável.1.764. pois isto pode enganar o programador inexperiente. --i. c.Operadores Incrementais Em programação existem instruções muito comuns chamadas de incremento e decremento.var var -equivalente var = var + var = var + var = var var = var 1 1 1 1 onde var é o nome da variável da qual se quer incrementar ou decrementar um unidade.4 j %= 7.5) } 3.5. /* ******************************************************************* Programa: e0304. c = 'A'.4 . o valor da variável será incrementado (ou decrementado) depois que a variável for usada em alguma outra operação. Observe que existe duas sintaxes possíveis para os operadores: pode-se colocar o operador à esquerda ou á direita da variável. // r = r * 7. Programa Exemplo: O arquivo e0304.9. Eles são genericamente chamados de operadores incrementais. ++i.

2.Operadores Relacionais e Lógicos A chave para a flexibilidade de um algoritmo é a tomada de decisões através da avaliação de condições de controle.do{ i++. Esta conversão de tipo é feita de acordo com a regra mostrada na seção 3... uma expressão lógica avaliada falsa recebe o valor 0. j--. Se os operandos forem de tipos diferentes haverá uma conversão de tipo antes da avaliação da expressão. respectivamente. j = ++i. 3. Uma expressão lógica é construída com operadores relacionais e lógicos. Expressão i == 7 r != s i > r 6 >= i i < j s <= 5. j = 4 % --i.. // incrementa e depois atribui // Precedência: i = j++ * 3. } 3.5 . As variáveis r e s são float com valores 7. portanto o resultado de uma expressão lógica é um valor numérico: uma expressão avaliada verdadeira recebe o valor 1.5. e' diferente de: i = 0. Ao contrário de outras linguagens. respectivamente.3 e 1. }while(i < 10). Admita que i e j são variáveis int cujos valores são 5 e -3. // Posição do operador: // Observe que. // atribui e depois incrementa // .. em C não existem tipos lógicos. Uma condições de controle é uma expressão lógica que é avaliadas como verdadeira ou falsa.1 . f++.2.9 Valor 0 1 0 1 0 1 18 . Exemplo: Observe as expressões lógicas abaixo e verifique o resultado de sua avaliação. São seis os Significado maior que menor que maior ou igual a (não menor que) menor ou igual a (não maior que) igual a não igual a (diferente de) Sintaxe: A sintaxe das expressões lógicas é: expressão_1 operador expressão_2 onde expressão_1 e expressão_2 são duas expressões numéricas quaisquer. e operador é um dos operadores relacionais. j = i++. i = 0. c--.7.Operadores relacionais Operadores relacionais verificam a relação de magnitude e operadores relacionais em C: Operador > < >= <= == != igualdade entre dois valores.

O resultado da operação lógica || será 0 somente se os dois operandos forem 0. caso contrário o resultado é 0. OR e NOT.m m == n <= m > m Valor 1 1 0 0 Ordem de Operação + == * > != .0 0. O resultado da operação lógica ! será 0 se o operandos for 1. >= e <=). b e c são variáveis tipo int com valores 0. Exemplo: Observe as expressões lógicas abaixo e verifique o resultado de sua avaliação. Para estes operadores todo valor numérico diferente de 0 é considerado 1. Veja a tabela 3. O operador ! tem a mesma precedência que os operadores incrementais.&& && || 19 . Estes. Observe que os operadores lógicos atuam sobre expressões de quaisquer valores. Sintaxe: A sintaxe de uso dos operadores lógicos: expr_1 && expr_2 expr_1 || expr_2 !expr onde expr_1 .2 Valor lógico 0 1 1 1 1 onde expr_1 . || e !. Exemplo: Observe as expressões lógicas abaixo e verifique o resultado de sua avaliação. expr_2 e expr são expressões quaisquer. respectivamente. 1 e 2. caso contrário o resultado é 1.b !b && c || a Valor 0 1 1 0 Ordem de Operação > ! ! < || + .4 -5. respectivamente. Estes dois têm precedência menor que os operadores relacionais.5.Operadores lógicos São três os operadores lógicos de C: &&. Operadores relacionais de mesma precedência são avaliados da esquerda para a direita. Estes operadores tem a mesma significação dos operadores lógicos Booleanos AND. Expressão a && b c > b || a < c a + b && !c . O resultado da operação lógica && será 1 somente se os dois operandos forem 1. Veja a tabela 3. tem precedência menor que os operadores aritméticos. Expressão m + n == 5 m != 2 * n > m 6 >= n < 3 .Os operadores relacionais de igualdade (== e !=) tem precedência menor que os de magnitude (>.1.1.>= < <= > != 3. por sua vez. <.2 . e 1 se o operando for 0. Exemplo: A seguir é mostrado o valor lógico de uma expressão qualquer: Expressão 0 1 1. Admita que a. Abaixo mostra-se o resultado das possíveis combinações entre os operandos para cada operador lógico: Operador &&: op1 && op2 op1 1 1 0 0 op1 1 1 0 0 op 1 0 op2 1 0 1 0 op2 1 0 1 0 Res 0 1 Res 1 0 0 0 Res 1 1 1 0 Operador ||: op1 || op2 Operador !: !op O operador && tem precedência sobre o operador ||. expr_2 e expr são expressões quaisquer. Admita que m e n são variáveis tipo int com valores 4 e 1.

então a expressão condicional assumirá o valor de expressão_1. valor_logico = (i-5 > j*3).cpp Propósito: Operadores Relacionais e Lógicos Ultima Revisão: 18/05/2000 ******************************************************************* */ void main() { char c.j.s. d = 'a'. Uma expressão condicional pode ter dois valores diferentes dependendo de uma condição de controle.d. float r. valor_logico = (r != s).6 != 4. Uma expressão condicional é equivalente a uma estrutura de decisão simples: se condição então expressao_1 senão expressao_2 20 . Execute o programa passo-a-passo e observe o valor das variáveis.0. do { r /= 2.3.Operador Condicional O operador condicional (?:) é usado em expressões condicionais. // Operadores Lógicos valor_logico = r==s && c<d. int valor_logico. Sintaxe: A sintaxe de uma expressão condicional é: condição ? expressão_1 : expressão_2 onde expressão_1 e expressão_2 são duas expressões quaisquer. /* ******************************************************************* Programa: e0305. valor_logico = (c == 'w'). } while( r > 1e-8 && i++ < 50). // obs: 'A' = 65 'a' = 97 valor_logico = (4 >= j). valor_logico = i>45 || r!=s.1.8). Caso contrario assumirá o valor de expressão_2. } 3. valor_logico = !(c != d).3). // Quando termina a repetição abaixo? i = 0. isto é. valor_logico = (2. Se o valor de condição for 1.0.6 . // Operadores Relacionais i = 5. c = 'A'. r = 2. valor_logico = (i > 3). e condição é uma expressão lógica que será avaliada primeiro. verdadeiro.: 'w' = 119 // Tipos diferentes valor_logico = (r <= i).Programa Exemplo: O arquivo e0305.cpp traz um programa para visualizar alguns aspectos relacionados com os operadores lógicos e relacionais. r = 1. // Obs. j = 6. s = 6. valor_logico = (c < d). // Tipos iguais valor_logico = (i == j). int i. valor_logico = (j == 2.

}else{ s = 88.1. Por exemplo.. j e k são variáveis tipo int com valores 1. as processa e retorna outra informação.. .9. Sintaxe: A sintaxe de declaração de uma função é: tipo_ret nome(tipo_1.cpp Propósito: Operadores Condicionais Ultima Revisão: 18/05/2000 ******************************************************************* */ void main(){ int i. Veja a tabela 3. Existem dois tipos de funções: funções de biblioteca e funções de usuário.s. // A seguinte atribuição.4.max1... r = (i==j) ? 34. } // pode-se escrever. respectivamente. Funções de usuário são funções escritas pelo programador. max2 = (i > j) ? i : j. precedendo.1 .7. isto é. já estão escritas em código de máquina.. // é equivalente a.. funções de usuário serão vistas no capítulo ?. // Aplicação simples // Para não escrever. if(i > j) { max1 = i.4... if(i==j){ s = 34. Estas informações estão contidas no manual do usuário do compilador ou em sua documentação on-line. }. calcule seu logaritmo decimal e retorne o valor obtido.9 : 88.7 .j. Nesta seção trataremos somente das funções de biblioteca. podemos ter uma função que receba um valor numérico. } 3. Expressão i ? j : k j > i ? ++k : --k k == i && k != j ? i + j : i . 3. aos operadores de atribuição.. } else { max1 = j. Programa Exemplo: O arquivo e0306.O uso de funções Antes de usar uma função é preciso saber como a função esta declarada. Funções de biblioteca são funções escritas pelos fabricantes do compilador e já estão pré-compiladas. isto é.max2.fim se Exemplo: Observe as expressões condicionais abaixo e verifique o resultado de sua avaliação.Funções de biblioteca Uma função é um sub-programa (também chamado de rotina).cpp traz um programa para visualizar alguns aspectos relacionados com o operador condicional. quais são os parâmetros que a função recebe e quais são os para metros que a função retorna.) 21 .j i > k ? i : k Valor 2 4 -1 3 O operador condicional tem baixa precedência. Admita que i. /* ******************************************************************* Programa: e0306.. Esta função recebe informações. Execute o programa passo-a-passo e observe o valor das variáveis. tipo_2. 2 e 3. apenas. float r.

em radianos. em inglês) que significa que aquele parâmetro é inexistente.h locale.h sys\stat. Biblioteca math.h conio.h errno.h float.onde nome é o nome da função.h generic.h assert.h fstream.h complex. double fabs(double d).h malloc. ceil() arredonda para cima.h stdlib.h dirent.h é declarada como: int getch(void). double double double double double double sin(double arco).h math.h limits. .h é declarada como: double cos(double).h time.h share. Exemplo: A função cos() da biblioteca math. porém o leitor que desejar tornar-se "fluente" na linguagem C pode (e deve) estudá-las com profundidade.h ctype.3.0 Borland: Ao longo do texto veremos o uso de muitas funções cobrindo uma boa parte destas bibliotecas. } // // // // // // // inclusão de biblioteca inicio do programa principal hipotenusa cateto oposto angulo: π /4 calculo: uso da função cos() fim do programa As funções tem alta precedência. double alfa = M_PI_4. floor() arredonda para baixo. Para podermos usar um função de biblioteca devemos incluir a biblioteca na compilação do programa.h signal.h Vejamos algumas funções disponíveis nas bibliotecas C. double ceil(double num).h string.0. co = h * cos(alfa).h stdarg.h int abs(int i).7. tipo_1.2 .h dos.h bios.h iostream.h strstrea. tan(double arco).2) == 3. Ex. Funções de arredondamento para inteiro. floor(3. Exemplo: A função getch() da biblioteca conio.h io.h stream. A tabela 3. tipo_2.h> void main() { double h = 5. Esta inclusão é feita com o uso da diretiva #include colocada antes do programa principal. existe ainda o tipo void (vazio.h stdiostr.0.1 mostra as precedências de todos os operadores estudados neste capítulo.h setjmp.h sys\timeb..h stddef. asin(double arco). respectivamente. sendo mais baixa apenas que os parênteses. Funções trigonométricas do ângulo arco.h values. como visto na seção 2.h bcd.As bibliotecas disponíveis e algumas funções interessantes A seguir segue uma lista de todas as bibliotecas disponíveis no compilador Turbo C++ 3.h graphics.h dir. Ex.0. cos(double arco). double floor(double num).2) == 4.. 22 .4. Calcula o valor absoluto do inteiro i e do real d. Exemplo: Assim podemos usar a função no seguinte trecho de programa: #include <math. Além dos tipos usuais vistos na seção 2.2.h iomanip.h sys\types. acos(double arco). atan(double arco). double co.h fcntl.h stdio. ambos são do tipo double.h process. Isto significa que a função não tem parâmetros de entrada e tem um parâmetro int de saída. 3. Isto significa que a função tem um parâmetro de entrada e um parâmetro de saída. são os tipos (e quantidade) de parâmetros de entrada da função e tipo_ret é o tipo de dado de retorno da função.h mem. alloc. ceil(3.

log10() é logaritmo decimal (base 10). Biblioteca stdlib. Gera um número inteiro aleatório entre 0 e num . nome2) while (strcmp(nome. #include <conio..1. 0 se o valor de s1 for igual ao valor de s2. “fim”) != 0) Programa Exemplo: O arquivo e0307. s2). double sqrt(double num).2.cpp Proposito: Funções de Biblioteca Ultima Revisão: 20/05/2000 ******************************************************************* */ // Exercício: O programa abaixo foi escrito usando varias funções // disponíveis do C.h int random(int num). int tam.h> #include <string. 1 se o valor de s1 for maior que o valor de s2. na ajuda on-line.. strcpy(s1. Ex: igual = strcmp(nome1.. double pow(double base.6.0. float num.h> #include <stdio.h> #include <stdlib. Raiz quadrada: sqrt(9. // inicia laço repetitivo.double log(double num). /* ******************************************************************* Programa: e0307. strcmp(s1. double log10(double num). Retorna um número inteiro de acordo com o número de caracteres de s.h> #include <dos. float val. int cont. Biblioteca string.cpp traz um programa para visualizar alguns aspectos relacionados com funções de biblioteca.0) = 3. Ex: tamanho = strlen(nome). Copia o conteúdo da variável s2 para a variável s1. Retorna um número inteiro de acordo a comparação entre o conteúdo de s1 e s2 da seguinte forma: -1 se o valor de s1 for menor que o valor de s2. Execute o programa passo-a-passo e observe o valor das variáveis.25..5.h strlen(s). Ex: strcpy(nomemaior. s2). 23 . Funções logarítmicas: log() é logaritmo natural (base e).h> #include <ctype. int col. nome).6) = 3. do{ // inclusão das bibliotecas "* // // // // // // * * P r o g r a m a E x e m p l o tecla pressionada pelo usuário tamanho do titulo coluna inicial de impressão do titulo flag de continuação do laço numero aleatório valor calculado * * *".h> void main() { char* titulo = char tecla. Procure.h> #include <math. Potenciação: pow(3. double exp). informações sobre as // funções usadas.

. nosound(). por 100 ms.num).num. val = log(num). getch(). // mensagem // fim do programa 24 .. cont = (tecla == 'S') ? 1 : 0.. printf("\n sqrt( %f ) = %f".. tam = strlen(titulo).val).. tecla = toupper(tecla).0.1). getch(). } // limpa tela // emite um som de 300 Hz. // *********** // 4 Continua? // *********** printf("\n Continua ? "). val = floor(num). getch()..val). // gera numero printf("\n\n Numero: %f". // pausa // ******************** // 3 Faz algumas contas // ******************** val = sin(num).. tecla = getch(). // pausa val = sqrt(num). // . e para.num.. printf("\n ln( %f ) = %f". }while(cont). val = ceil(num).. printf("\n Volte Sempre!"). // // // // // limpa a tela calcula o tamanho do titulo. delay(100). calcula a coluna de inicio posiciona o cursor imprime o titulo // ****************** // 2 Numero aleatório // ****************** randomize().tam / 2. sound(440). // imprime escolha getch(). // inicia gerador aleatório num = (float)random(1000) / 100. fim do laço de repetição // ******* // 5 Sadia // ******* clrscr(). getch(). // .num. // seno // imprime // pausa // arredonda para cima // imprime // pausa // arredonda para baixo // imprime // pausa // logaritmo natural // imprime // raiz quadrada // imprime // pausa // // // // imprime mensagem recebe caracter do teclado transforma em maiúsculo se for 'S' continua // . printf("\n ceil( %f ) = %f".val)..val). col = 40 . printf(titulo).num. getch(). printf("\n sin( %f ) = %f".// ********************* // 1 Titulo Centralizado // ********************* clrscr().num.val). printf("\n floor( %f ) = %f". gotoxy(col.

Mostraremos. drives de disco. lógico aritmético aritmético relacional relacional lógico lógico condicional atribuição Operadores ( ) nome() ++ -. impressora.1 . mouse.).) e emita o resultado de seu processamento de volta para o meio externo (monitor.). caracteres e strings. etc. Propósito: A função printf() (print formated) imprime dados da lista de argumentos lista_arg formatados de acordo com a string de controle st_contr. existem muitas funções pré-definidas que tratam desta troca de informações. etc. Em C. Esta função retorna um valor inteiro representando o número de caracteres impressos. Os operadores de menor precedência são os o operadores de atribuição. Exemplo: Observe no exemplo abaixo as instruções de saída formatada e os respectivos resultados. A partir do estudo destas funções é possível escrever um programa propriamente dito com entrada.3. Categoria parênteses função incremental. Os operadores de maior precedência são os parênteses e as chamadas de funções. em detalhe. Nos exemplos mostrados nos capítulos anteriores foram vistas algumas funções de entrada (scanf(). Estafunção é dita de saída formatada pois os dados de saída podem ser formatados (alinhados. getch()) e algumas funções de saída (printf()).Precedência entre os operadores do C A tabela 3. Sintaxe: A string de controle é uma máscara que especifica (formata) o que será impresso e de que maneira será impresso. portas de comunicação.1 mostra a ordem de precedência de todos os operadores estudados neste capítulo. Neste capítulo veremos. lista_arg]). alto-falante. Saída Olá. processamento e saída de dados.! * / % + < > <= == != && || ?: = += -= *= /= %= >= Prioridade interno → externo E →D E ←D E →D E →D E →D E →D E →D E →D E ←D E ←D Tabela 3. Esta função imprime dados numéricos.1: Precedência dos operadores.8 . 4. Instrução printf(“Olá. nas duas seções iniciais as mais importantes funções de entrada e saída de dados em C: as funções printf() e scanf(). estas e outras funções de modo a permitir escrever um programa completo em C. menor precedência na base. com número de dígitos variáveis. Mundo!“). portas de comunicação. etc. Maior precedência no topo.Saída formatada: printf() Biblioteca: stdio. 4Entrada e Saída Para que um programa torne-se minimamente funcional é preciso que ele receba dados do meio externo (teclado. São as funções de entrada e saída do C. De outro modo: um programa deve trocar informações com o meio externo. drives de disco. Mundo! 25 .h Declaração: int printf (const char* st_contr [.

/* ******************************************************************* Programa: e0401.2 \nTroco: %f. Execute o programa passoa-passo e verifique a saída dos dados. [. seguem-se alguns modificadores.idade).3 e 15.precisão] tipo [flag] justificação de saída: (Opcional) . Admita que idade seja uma variável int contendo o valor 29 e que tot e din sejam variáveis float cujo valores são. linha 1 linha 2 Observe que na primeira instrução.justificação à esquerda. dígitos a direita do ponto decimal. a saída é exatamente igual a string de controle.n Tipo d o x f e c s caracter de conversão de tipo (Requerido) inteiro decimal inteiro octal inteiro hexadecimal ponto flutuante: [-]dddd. Isto se deve ao \n que representa o código ASCII para quebra de linha (veja seção 2.tot. Exemplo: Observe no exemplo abaixo as instruções de saída formatada e os respectivos resultados. Nesta mascara é possível reservar espaço para o valor de alguma variável usando especificadores de formato. Deve haver um especificador de formato para cada variável a ser impressa. positivas sem sinal) [tamanho] n especificação de tamanho (Opcional) pelo menos n dígitos serão impressos (dígitos faltantes serão completados por brancos). 0n pelo menos n dígitos serão impressos (dígitos faltantes serão completados por zeros).30 Dinheiro: 15.2 \nDinheiro: %f.00 Troco: 2.dddd. são impressos n dígitos decimais.precisão] (nada) . + conversão de sinal (saída sempre com sinal: + ou -) <espaço> conversão de sinal (saídas negativas com sinal. cuja sintaxe é a seguinte: % [flag] [tamanho] [.cpp contém um programa que ilustra o uso da função printf() usando várias combinações de strings de controle e especificadores de formato. ponto flutuante com expoente: [-]d.cpp Propósito: Uso da função printf() Ultima Revisão: 20/05/2000 26 .3).0. Já na segunda instrução a impressão se deu em duas linhas. Um especificador de formato marca o lugar e o formato de impressão das variáveis contidas na lista variáveis.1. 12. nenhum digito decimal.dddde[+/-]ddd caracter simples string Programa Exemplo: O arquivo e0401.printf(“linha 1 \nlinha 2 “).70 Depois do sinal %.0 .2“. Saída: Total: 12. (Opcional) padrão: 6 dígitos para reais. Todos os especificadores de formato começam com um %. especificador de precisão.din. respectivamente. Instrução: printf(“Tenho %d anos de vida”. Saída: Tenho 29 anos de vida Instrução: printf(“Total: %f.din-tot).

h> // biblioteca da função printf() #include <conio.i. float r = 5.******************************************************************* */ #include <stdio.j.i.k+1). printf("\n %06d %012f".k).k. printf("\n%c". printf("Texto Exemplo").j.k. int j = -35.k+1. printf("\n %6. t. // formato caracter printf("\n%c". float t = 5467.r). printf("\n %6d %6X printf("\n %6d %6X printf("\n %6d %6X Com 3 decimais").k.t). printf("\n\nDecimal. %6o".r).i. // limpa tela // sem quebra de linha // somente texto printf("Texto Exemplo").t). printf("\n\nCom zeros").r).s). printf("\n %6.i.3f". printf("\n %+6d %+12f". s. Hexa.83.r). printf("\n %+6d %+12f".s). // Uso dos modificadores de formato printf("\n\nJustificacao a direita").75. printf("\n %6d %12f".i.3.0f %8.r). %6o".s). char letra = 'a'. printf("\n %06d %012f". printf("\n\nJustificacao a esquerda"). printf("\n %-6d %-12f". int k = 9386. char* nome = "Teste".k.t). // formato string printf("\n%s". printf("\n %-6d %-12f". printf("\n %6d %12f". printf("\n %-6d %-12f". clrscr(). printf("\nConsumo Medio: %f kWh". float s = -82.0f %8. printf("\n %+6d %+12f".3f".i). // texto e numero sem formatacao printf("\nJoaozinho tem %d amiguinhos!".k.k+1. printf("\nTexto Exemplo").letra). %6o". printf("\n %6. Octal").h> // biblioteca da função clrscr() void main() { int i = 12.k. printf("\n\nSem decimais.r).0f %8. 27 .s).i).3f". printf("\n\nPadrao. printf("\n %6d %12f".s). r. Cientifico").t).'b').j.i. printf("\n %06d %012f".j.nome).t). // com quebra de linha printf("\nTexto Exemplo"). printf("\n\nCom sinal").

%e". a um determinado tipo de variável (int.printf("\n %11f printf("\n %11f printf("\n %11f } %e".s). define o tipo de dado a ser lido (Requerido) inteiro decimal (int) ponto flutuante (float) inteiro octal (int) inteiro hexadecimal (int) inteiro decimal de qualquer formato(int) inteiro decimal sem sinal (unsigned int) string (char*) caracter (char) A lista de variáveis é o conjunto de (endereços) de variáveis para os quais serão passados os dados lidos.cpp contém um programa que ilustra o uso da função scanf() na leitura de dados. Campo de qualquer tamanho. float preco. Tamanho n <ausente> Tipo d f o x i u s c especificador de tamanho(Opcional) Especifica n como o numero máximo de caracteres para leitura do campo. A função lê da entrada padrão (em geral.ano. Variáveis simples devem ser precedidos pelo caracter &. Sintaxe: O uso da função scanf() é semelhante ao da função printf(). .).. Veja mais sobre strings e vetores na seção 7. cuja sintaxe é a seguinte: % [*] [tamanho] tipo * indicador de supressão (Opcional) <presente> Se o indicador de supressão estiver presente o campo não é lido.2 .Leitura formatada: scanf() Biblioteca: stdio. int cod. Execute o programa passo-a-passo e verifique a saída dos dados. char. // leitura individual printf("\nDigite o nome do item: "). Programa Exemplo: O arquivo e0402.h Declaração: int scanf(const char* st_contr [. t.]). teclado) uma lista de valores que serão formatados pela string de controle e armazenados nos endereços das variáveis da lista. A string de controle é formada por um conjunto de especificadores de formato.r). caracteres e 'strings' e sua respectiva atribuição a variáveis cujos endereços são end_var.h> // biblioteca das funções scanf() e printf() void main(){ { char* nome. s. /* ******************************************************************* Programa: e0402. r.. <ausente> O campo é lido normalmente.cpp Propósito: Uso da função scanf() Ultima Revisão: 08/08/97 ******************************************************************* */ #include <stdio. Veja mais sobre endereços na seção 8. Variáveis string e vetores não são precedidos pelo caracter &.nome). // texto de aviso (prompt) // leitura do dado 28 . Propósito: A função scanf() (scan formated) permite a entrada de dados numéricos.&cod). printf("Digite o código do item: ").t).mes. end_var. scanf("%d".. . Este supressor é útil quando não queremos ler um campo de dado armazenado em arquivo.. Esta função é dita de entrada formatada pois os dados de entrada são formatados pela string de controle st_contr. 4. float. int dia. scanf("%s". %e".

&dia.5 .Leitura de teclado: getch().h 29 . scanf("%s %d %f". Propósito: A função cin >> lê um caracter individual ou um valor numérico da entrada padrão (em geral. Esta função é dita line buffered.&preco). isto é. Para cada informação é necessário um par de <<. código e preço do item: "). // leitura conjunta com supressão printf("\nDigite o nome.&cod.Entrada não formatada: cin >> Biblioteca: iostream.&preco). printf("\nVocê nasceu em %d de %d de 19%d!".6 . // após leitura. Propósito: Esta função putchar() (put character) imprime um caracter individual c na saída padrão (em geral o monitor de vídeo). preço não é alterado // leitura segmentada printf("\nDigite sua data de nascimento (ddmmaa): "). É uma função muito simples. 4.&mes.h Declaração: cout << var. 4.printf("Digite o preço do item: "). scanf("%s %d %*f".Entrada de caracter individual: getchar() Biblioteca: stdio. 4.h Declaração: cin >> var. é enviado pelo teclado quando a tecla [enter] é pressionada. Se ocorrer um erro ou uma condição de 'fim-de-arquivo' durante a leitura. o teclado).ano). a função retorna o valor da constante simbólica EOF (end of file) definida na biblioteca stdio.3 .h Declaração: int putchar(int c).h. } 4. scanf("%2d %2d %2d". normalmente.Saída de caracter individual: putchar() Biblioteca: stdio. scanf("%f".7 . 4. Propósito: A função getchar() (get character) lê um caracter individual da entrada padrão (em geral. código e preço do item: ").dia.nome.4 – Saída não formatada: cout << Biblioteca: iostream. não retorna valores até que o caracter de controle line feed (\n) seja lido.&preco). Esta função permite uma forma eficiente de detecção de finais de arquivos.mes. É uma função muito simples. o teclado).&cod.nome. Este caracter.&ano). Então. Não possibilita controle de leitura. Propósito: A função cout << escreve um ou mais caracteres individuais ou um valor numérico na tela. Se forem digitados vários caracteres. estes ficarão armazenados no buffer de entrada até que a tecla [enter] seja pressionada.cpp mostra o uso das funções getchar() e putchar() em um programa que lê caracteres do teclado e os reimprime convertidos para maiúsculos. getche() Biblioteca: conio. // leitura conjunta printf("\nDigite o nome. cada chamada da função getchar() lerá um caracter armazenado no buffer.h Declaração: int getchar(void). Programa Exemplo: O programa e0403.

*. Por exemplo. Ao ser executada.Declaração: int getch(void). Alguns valores de cor não podem ser usados como cor de fundo. Para que a saída seja colorida é necessário definir as cores de fundo e de letra para a impressão antes do uso da função. Para se usar uma letra piscante deve-se adicionar o valor 128 ao valor da cor de letra. [Page Up].) ou combinação de teclas ([Alt] + [A]. se a tecla [F1] for pressionada os valores 0 e 59 serão armazenados e a função deve ser chamada duas vezes para ler os dois códigos.). teclas de comandos ( [enter]. Código Especial: ao serem pressionadas certas teclas (ou combinação de teclas) que não correspondem a um caracter ASCII. caracteres e strings usando cores. [F1]. Por exemplo. se a tecla A for pressionada o código 65 será armazenado no buffer e lido pela função. int getche(void). etc. A função getche()(get character and echoe) também escreve na tela. o caracter correspondente. [delete]. etc. suas constantes simbólicas e onde podem ser usadas: Exemplo: O trecho de programa abaixo imprime uma mensagem de alerta em amarelo piscante sobre fundo vermelho. 4. recebe do teclado o código correspondente e retorna este valor. [Ctrl] + [Page Down].h> 30 . sendo o primeiro sempre 0.). 8. etc. O uso da função cprintf()é semelhante a printf()porém permite que a saída seja a cores. Propósito: Estas funções fazem a leitura dos códigos de teclado. onde cor_de_letra e cor_de_fundo são números inteiros referentes as cores da palheta padrão (16 cores. lista_arg]).Escrita formatada em cores: cprintf() Biblioteca: conio. o teclado envia ao 'buffer' do computador dois códigos. quando possível.h Declaração: int cprintf (const char* st_contr [. Estes códigos podem representar tecla s de caracteres (A.h. y.8 . a função getch() (get character) aguarda que uma tecla (ou combinação de teclas) seja pressionada. o teclado envia um código ao 'buffer' de entrada do computador e este código é lido. [Shift] + [F1]. modo texto). textbackground(cor_de_fundo). Código ASCII: ao ser pressionada uma tecla correspondente a um caracter ASCII. Estes valores de cor são representadas por constantes simbólicas definidas na biblioteca conio. Cores (Modo Texto) Cor Constante Preto BLACK Azul BLUE Verde GREEN Cian CYAN Vermelho RED Magenta MAGENTA Marrom BROWN Cinza Claro LIGHTGRAY Cinza Escuro DARKGRAY Azul Claro LIGHTBLUE Verde Claro LIGHTGREEN Cian Claro LIGHTCYAN Vermelho Claro LIGHTRED Magenta Claro LIGHTMAGENTA Amarelo YELLOW Branco WHITE Piscante BLINK Valor 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 128 Fundo ok ok ok ok ok ok ok ok ---------Letra ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok Estas definições são feitas pelas funções texcolor() e textbackground() cuja sintaxe é: textcolor(cor_de_letra). A relação acima mostra as cores. #include <conio. Propósito: Esta função cprintf() (color print formated) permite a saída de dados numéricos.

Propósito: A função sound() ativa o alto-falante do PC com uma freqüência freq (Hz).h> #define T 250 void main(){ clrscr(). // enquanto ano e' ultima cor de fundo cf = BLACK..h Declarações: void sound(unsigned freq). . /* ******************************************************************* Programa: e0406. // limpa tela cf = BLACK. do{ textbackground(cf). }while(++cl <= WHITE). textbackground(BLACK).. 31 . A função nosound() desativa o alto-falante.cpp Proposito: Uso das funcoes sound(). textcolor(YELLOW + BLINK). Programa Exemplo: O uso destas funções é muito simples mas produz resultados interessantes. textbackground(cf).h> #include <conio.9 . Programa Exemplo: O programa do arquivo e0406. // imprime teste de cor }while(++cl <= WHITE)..Saída sonora: sound().cpp Proposito: Uso das funcoes cprintf(). delay() e nosound() Ultima Revisão: 11/08/97 ******************************************************************* */ #include <dos. delay(). // cor de fundo preta do{ // faz. do{ textcolor(cl + BLINK). // cor de letra int cf. // cor de letra preta do{ // faz. A função delay() realiza uma pausa (aguarda intervalo de tempo) de duração tempo (milisegundos). // ativa cor de texto cprintf(" Teste "). /* ******************************************************************* Programa: e0407. textcolor(cl). cl = BLACK. textbackground(RED).h> #include <stdio.. // ativa letra padrão } 4. cprintif(“ Alerta: Vírus Detectado! ”). // enquanto ano e' ultima cor de letra }while(++cf <= LIGHTGRAY).. No arquivo e0407.. nosound() Biblioteca: dos.. textbackground() e textcolor() Ultima Revisão: 08/08/97 ******************************************************************* */ #include <conio. // cor de fundo clrscr(). // ativa letra piscante cprintf(" Teste "). // ativa fundo padrão textcolor(LIGHTGRAY). }while(++cf <= LIGHTGRAY). void nosound(void).. // ativa cor de fundo cl = BLACK..h> void main(){ int cl.cpp mostra todas as combinações possíveis de impressão colorida em modo texto.cpp temos um exemplo do uso de sons em programas. void delay(unsigned tempo).

sound(660).delay(T). sound(495). sound(594).delay(2*T).delay(T). sound(660). nosound(). sound(440).h Declarações: void clrscr(void).h Declarações: void gotoxy(int pos_x. sound(495).10 . sound(660). sound(660). sound(330).Limpeza de tela: clrscr(). sound(550).delay(T). sound(550).. sound(734). printf("\nMas o certo.delay(T). sound(660).delay(T).11 .. sound(495)."). sound(594). sound(550).delay(2*T).. Propósito: A função clrscr() (clear screen) limpa a janela de tela e posiciona o cursor na primeira linha e primeira coluna da janela (canto superior esquerdo da janela). sound(440). int pos_y).delay(6*T). sound(550). onde o Grêmio estiver!").delay(T). 4.delay(6*T).delay(T). sound(704).delay(2*T).Posicionamento do cursor: gotoxy() Biblioteca: conio. void clreol(void). sound(440).delay(T).delay(2*T). A função clreol() (clear to end of line) limpa uma linha desde a posição do cursor até o final da linha mas não modifica a posição do cursor.delay(4*T). sound(550).delay(4*T).delay(2*T)..delay(T).textbackground(BLUE). sound(634). sound(660). sound(704). é que nós estaremos. sound(550). } 4. sound(734).delay(2*T). printf("\nAtenção pois nos iremos."). cprintf("Hino do Grêmio").delay(T).delay(T). sound(495).delay(T). clreol() Biblioteca: conio.").delay(T).delay(T). sound(495).delay(T).delay(T).delay(2*T). sound(660).delay(2*T)..delay(T). sound(550). printf("\b\b\b para o que der e vier. sound(495). 32 . sound(594). textcolor(WHITE + BLINK). sound(844).delay(T). sound(495).delay(2*T). Ambas funções preenchem a tela com a cor de fundo definida pela função textbacground().delay(2*T).delay(T).delay(T). printf("\b\b\b com o Grêmio.

int dir. gotoxy(1.Redimencionamento de janela: window() Biblioteca: conio.Propósito: Em modo texto padrão. int sup.h> #include <dos. 4. kbhit(). Observe que.25). Sendo que a posição (1. Propósito: Esta função permite redefinir a janela de texto. 80] dir = esq + random(81-esq). a tela é dividida em uma janela de 25 linhas e 80 colunas. As coordenadas esq e sup definem o canto superior esquerdo da nova janela. Caso nenhuma tecla seja pressionada a função retorna 0.1) corresponde ao canto superior esquerdo da tela e a posição (80.80. o texto que ficar fora da janela fica congelado até que se redefina a janela original. gotoxy(). // bordas char* tit = "Teste de video: Blocos coloridos". gotoxy().13 . A função gotoxy() permite posicionarmos o cursor em qualquer posição (pos_x.strlen(rpe)/2.1).25) corresponde ao canto inferior direito.cpp contém um programa para exemplificar o uso das funções clrscr().h> void main(){ int esq.dir. Como as funções printf() e cprintf() escrevem a partir da posição do cursor. podemos escrever em qualquer posição da tela. // rodapé clrscr(). // pausa pra ano ficar muito ligeiro esq = 1 + random(80). cprintf("%s". textbackground(BLUE). // dir <. enquanto as coordenadas inf e dir definem o canto inferior direito da nova janela. 25). esta função não aguarda que uma tecla seja pressionada.[1 . gotoxy(40 . ela retorna um número não nulo e o valor armazenado no buffer pode ser lido com as funções getch() ou getche(). 1).strlen(tit)/2. Propósito: Esta função (keyboard hitting) permite verificar se uma tecla foi pressionada ou não. 80] // limpa tela // seleciona cor de fundo de linha // cor de letra // // // // // // // // posiciona cursor no canto esquerdo desenha fundo de linha posiciona cursor escreve titulo centralizado posiciona cursor no canto esquerdo desenha fundo de linha posiciona cursor escreve rodapé centralizado 33 . clreol().25).12 . window() e kbhit() Ultima Revisão: 11/08/97 ******************************************************************* */ #include <conio.pos_y) da tela.[esq. gotoxy(40 . clreol().inf.rpe).h Declarações: void window(int esq. clreol().h> #include <stdlib. Esta função verifica se existe algum código no buffer de teclado. int inf). textcolor(WHITE).h> #include <string.cpp Proposito: Uso das funcoes clrscr(). gotoxy(1.sup. Programa Exemplo: O arquivo e0408. window(). clreol(). ao contrário de getch(). // esq <. Para reativar a janela padrão escreve-se a instrução window(1. Se houver algum valor.h Declarações: int kbhit(void).Monitoração de teclado: kbhit() Biblioteca: conio.1. /* ******************************************************************* Programa: e0408. 4. Quando uma janela é definida.tit). cprintf("%s". // titulo char* rpe = "Pressione alguma tecla para terminar". do{ delay(100).

}while(!kbhit()). textbackground(BLACK).25). clrscr(). 24] inf <.80.dir. 24] define janela seleciona cor de fundo aleatória preenche janela com cor } // restaura janela // restaura cor de fundo // limpa tela 34 .sup = 2 + random(23).sup.[sup.inf).[ 2. // // // // // sup <. window(esq. textbackground(random(8)). inf = sup + random(25-sup). window(1. clrscr().1.

Exemplo: Observe nas condições abaixo. do { puts("Digite um número positivo:").2: Fluxograma da estrutura while. variáveis ou constantes lógicas.0)..5Estruturas de Controle Estruturas de controle permitem controlar a seqüência das ações lógicas de um programa. A leitura é repetida caso o número lido seja negativo. quando for dito que uma condição é falsa ou verdadeira quer se dizer que seu valor e igual a zero ou diferente de zero.Estrutura do. bloco onde: condição é uma expressão lógica ou numérica. nas estruturas que estudaremos neste capítulo. j = 3.while.. A estrutura de repetição permite que um bloco de instruções seja executado repetidamente uma quantidade controlada de vezes. e verdadeira se seu valor for diferente de zero. condição? V F Figura 5. ela será considerada falsa se seu valor for igual a zero. bloco é um conjunto de instruções. A estrutura de decisão permite executar um entre dois ou mais blocos de instruções.Condição de controle Em todas as estruturas...1: Fluxograma da estrutura do. 5. Sua sintaxe é a seguinte: Sintaxe: do { bloco }while(condição). Considere as variáveis int i = 0. Neste capítulo estudaremos em detalhe as instruções do C que permitem implementar estas estruturas. Sua sintaxe é a seguinte: Sintaxe: while(condição) Figura 5. O fluxograma desta estrutura é mostrada na figura 5. a linguagem C não possui. 5. assim quando uma expressão numérica se encontra em uma condição de controle. seu valor numérico e seu significado lógico. possui somente expressões numéricas.. a leitura de um número é feita dentro de um laço de repetição condicional.3 . Basicamente.Estrutura while A estrutura de repetição condicional while é semelhante a estrutura do. existem dois tipos de estruturas de controle: estruturas de repetição e estruturas de decisão.&num). Uma condição de controle é uma expressão lógica ou aritmética cujo resultado pode ser considerado verdadeiro ou falso. scanf("%f"..2 . Conforme vimos na seção 3.1: Exemplo: No trecho abaixo.1 . Após a execução do bloco. entretanto.while. }while(num <= 0. Esta estrutura faz com que o bloco de instruções seja executado pelo menos uma vez. condição (i == 0) (i > j) (i) (j) valor numérico 1 0 0 3 significado lógico verdadeiro falso falso verdadeiro Este fato deve ficar claro pois. caso contrário a repetição é terminada.while Esta é uma estrutura básica de repetição condicional. F c n iç o od ã? V b c lo o 5. a condição é avaliada.5. Permite a execução de um bloco de instruções repetidamente. existe pelo menos uma expressão que faz o controle de qual bloco de instruções será executado ou quantas vezes ele será executado: é o que chamamos de condição de controle. Se a condição é verdadeira o bloco é executado outra vez. 35 .

Esta estrutura. as vezes. Por exemplo: for(i=0.). Esta condição é. i<10.} 36 . 10. for(i = 0. } É interessante notar que a mesma estrutura lógica pode ser implementada usando as estruturas for ou do. se a condição é falsa termina-se o laço. j=10. i<=10. condição. A contagem dos ciclos é feita por uma variável chamada de contador.. Estas expressões devem ser separadas por vírgula (. A variável eps tem seu valor dividido por 2 enquanto o processador conseguir distinguir entre 1 e 1+ε . O fluxograma desta estrutura é mostrada na figura 5.while.0.i)... Sua sintaxe é a seguinte: Sintaxe: for(inicialização. Então a expressão de condição é avaliada: se a condição for verdadeira. i++) { bloco } Podem existir mais de uma expressão de inicialização e de incremento na estrutura for.2: Exemplo: No trecho abaixo. for(i=1. calcula-se a precisão (ε ) do processador aritmético do PC.. uma expressão lógica que determina o ultimo valor do contador.. bloco é um conjunto de instruções a ser executado. o valor de eps contém a precisão da máquina. em geral. } 5. o bloco é executado novamente e o ciclo recomeça. j--){. o contador i é inicializado com o valor 1.. entretanto costuma ser utilizada quando se quer um número determinado de ciclos. Esta estrutura executa um número determinado de repetições usando um contador de iterações.. Por exemplo: i++ ou cont -= 2. ou cont = 20. do { bloco i++... condição é uma expressão lógica de controle de repetição. O bloco é repetido enquanto a condição i <= 10 for verdadeira. basta que a condição seja inicialmente falsa. A estrutura for é. 9. }while(i <= 100). chamada de estrutura de repetição com contador. Então o bloco é executado e depois de cada iteração. O contador é incrementado com a instrução i++. . eps = 1. Exemplo: No trecho abaixo. incremento) { bloco } onde: inicialização é uma expressão de inicialização do contador.Estrutura for A estrutura for é muito semelhante as estruturas de repetição vistas anteriormente. Esta estrutura faz com que a condição seja avaliada em primeiro lugar.{ } bloco onde: condição é uma expressão lógica ou numérica. i <= 100. Por exemplo: i <= 100 ou cont > 0. deste modo. o bloco de instruções pode não ser executado nenhuma vez.4 .while: Exemplo: As seguintes instruções são plenamente equivalentes: i = 0.. 2. ao contrário da estrutura do. i++) { printf(" %d". Mas não pode haver mais de uma expressão de condição. while(1. o contador é incrementado de acordo com a expressão de incremento.0. bloco é um conjunto de instruções. Se a condição é verdadeira o bloco é executado uma vez e a condição é avaliada novamente. i++.0 + eps > 1. Observe que nesta estrutura.0) { eps /= 2. incremento é uma expressão de incremento do contador. O contador é inicializado na expressão de inicialização antes da primeira iteração. imprime os números 1. Após a execução do laço. Caso a condição seja falsa a repetição é terminada sem a execução do bloco. Por exemplo: i = 0.

5.3: Fluxograma da estrutura de decisão onde: condição é uma expressão lógica ou numérica.. O fluxograma desta estrutura é mostrada F na figura 5. Caso contrário..i)... Esta estrutura pode se apresentar de modos ligeiramente diferentes.. } 5.else .h> #include <stdio.1 Decisão de um bloco (if. Se a condição verdadeira. então o seu valor é redefinido como 10. for(i = 1. { sound(600). Esta estrutura permite executar um entre vários blocos de instruções.. bloco é um conjunto de instruções. A figura 5.else) Também é possível escrever uma estrutura que execute um entre dois blocos de instruções.. // ³ nosound().Decisão de dois blocos (if. o bloco é executado..5.. o bloco não é executado..h> // inclusão de bibliotecas #include <conio.. Observe que o bloco constitui-se de um única instrução.... // ³ Pim! delay(50).3.h> void main() { int i... O controle de qual bloco será executado será dado por uma condição (expressão lógica ou numérica).5.. se o valor lido for maior que 10. { printf("\n%2d. 5.. // contador clrscr().". /******************************************************************* Programa: e0504. // ³ } // fim se delay(500). para emitir um sinal sonoro ao imprimir um número múltiplo de 4. // imprime numero if(i%4 == 0) // se múltiplo de 4.. printf("Digite o número de repetições: (máximo 10)".cpp mostra um programa que utiliza a estrutura if.cpp Propósito: Uso da estrutura if. i++) // para i de 1 a 20.2 .4 mostra o fluxograma correspondente a esta estrutura de decisão.) A estrutura de decisão de um bloco permite que se execute (ou co d o n içã V não) um bloco de instruções conforme o valor de uma condição seja verdadeiro ou falso. // espera } puts("Oba! Ganhei o prêmio!"). puts("Jogo do Pim!"). Exemplo: No trecho abaixo.else A estrutura if. b co lo Sintaxe: Decisão com um bloco: if(condição){ bloco } Figura 5.5 . scanf("%d".&iter). Sintaxe: Decisão de dois blocos: if(condição) condição? bloco 1 bloco 2 37 Figura 5.. Ultima Revisão: 26/08/97 *******************************************************************/ #include <dos.. i <= 20. if(iter > 10){ iter = 10.. } Programa Exemplo: O arquivo e0504.4: Fluxograma da estrutura de decisão if.Estrutura de decisão if.else é a mais simples estrutura de controle do C. Nesta seção vamos apresentar separadamente cada uma das possibilidades de sintaxe. if.

b. será atribuído a min.else para determinar o tipo de raízes de uma equação de segundo grau.Decisão de múltiplos blocos (if. delta). A figura 5. if(delta >= 0.5 mostra o fluxograma correspondente a esta estrutura de decisão.) Também é possível escrever uma estrutura que execute um entre múltiplos blocos de instruções. bloco1 e bloco2 são conjuntos de instruções. /* ******************************************************************* Programa: e0505. // calculo do discriminante printf("Discriminante: %f". caso contrario. // discriminante: b^2-4ac puts("\nBaskara").5. 38 ..&c). o bloco2 é executado.. { puts(" Raízes Complexas"). Se a condição for verdadeira o bloco1 é executado. } else { min = raiz. } else { bloco2.. // leitura dos parâmetros delta = b * b .&b. Exemplo: No trecho abaixo. // raízes reais } else // .else if. scanf("%f %f %f". se o valor de raiz*raiz for maior que num o valor de raiz será atribuído a max. c: "). } Programa Exemplo: O arquivo e0505..4.cpp Proposito: Uso da estrutura if. * a * c..3 . Caso contrário..else Ultima Revisão: 26/08/97 ******************************************************************* */ #include <stdio.0) // se delta e' positivo. // parâmetros de ax^2+bx+c=0 float delta. if(raiz*raiz > num) { max = raiz..c. } onde: condição é uma expressão lógica ou numérica...{ bloco1.senão. // raízes complexas } } 5. b..&a...h> void main(){ float a. puts("Digite valores para a. { puts(" Raízes Reais").cpp mostra um programa que utiliza a estrutura if...

a condição 2 é avaliada. negativo ou nulo.. } Programa Exemplo: O arquivo e0506. uma determinada ação é executada se o valor de num for positivo. Observe que apenas um dos blocos é executado.else if.5: Fluxograma da estrutura de decisão if.cpp Proposito: Uso da estrutura if. Exemplo: No trecho abaixo.1. Caso contrario.. ... bloco 2. Se a condição 2 for verdadeira o bloco 2 é executado. bloco 1 . if(num > 0){ a = b. Caso contrario... são expressões lógicas ou numéricas.. condição 2.C n içã od o 1 ? V b co 1 lo F C n içã od o 2 ? V b co 2 lo F C n içã od o 3 ? V b co 3 lo F ... .else if para determinar se um número é maior.else if 39 ... }else if(num < 0){ a = b + 1. a condição 3 é avaliada e assim sucessivamente. Se a condição 1 for verdadeira o bloco 1 é executado.. são conjuntos de instruções. }else if(condição N){ bloco N. }else{ a = b . Se nenhuma condição é verdadeira bloco P é executado... }else{ bloco P } onde: condição 1. Figura 5. /* ******************************************************************* Programa: e0506.. menor ou igual a outro.. . Sintaxe: Decisão de múltiplos blocos: if(condição 1){ bloco 1..cpp mostra um programa que utiliza a estrutura if.

. conjunto instruções..Estrutura switch. . Sintaxe: Esta estrutura possui a seguinte sintaxe: switch(expressão){ case rótulo_1: conjunto_1 case rótulo_2: conjunto_2 ...Ultima Revisão: 26/08/97 ******************************************************************* */ #include <stdio..h> void main() { int palpite. // mensagem }else{ // senao acertou puts("Acertou!").h> #include <stdlib.&palpite). rótulo_2. conjunto 2.. • • rótulo_1. case rótulo_n: conjunto n default: conjunto_d } onde: • expressão é uma expressão inteira.senao se chute baixo. A figura 5. // palpite do usuário int numero.. // mensagem } } 5. O resultado deste expressão é comparado ao valor de cada um dos rótulos.h> #include <math.case é uma estrutura de decisão que permite a execução de um conjunto de instruções a partir pontos diferentes conforme o resultado de uma expressão inteira de controle.6 .. conjunto_n e conjunto_d são conjuntos de 40 . e as instruções são executadas a partir desde rótulo. // inicializador do gerador aleatório numero = random(10).. // leitura do palpite if(palpite > numero){ // se chute alto. // numero do computador randomize(). // escolhe numero aleatório puts("\nEscolhi um número. rótulo_n e rótulo_d são constantes inteiras.. . puts("Chute baixo!"). 1. scanf("%d".case A estrutura switch.. // mensagem }else if(palpite < numero){ // ..6 mostra o fluxograma lógico desta estrutura. . Adivinha qual é?\n").. puts("Chute alto!").

.&val). }while(1). while) ou para terminar um conjunto switch.1 . o uso da instrução break poderia ter sido evitado. esta instrução força a interrupção do laço independentemente da condição de controle. if(val < 0.. Porém..6: Fluxograma da estrutura switch. como segue: 41 .soma/num). scanf("%f". do{ puts("valor:"). porém se pode começar em pontos diferentes. int seleção... Exemplo: O trecho abaixo ilustra o uso da instrução switch em um menu de seleção.Interrupção e desvio: break.. puts("digite valores:"). } epes o x r sã rtl 1 ou o c n no1 o ju t rtl 2 ou o c n no2 o ju t .. Os rótulos devem ser expressões constantes inteiras diferentes entre si..case.7 .A instrução break Esta instrução serve para terminar a execução das instruções de um laço de repetição (for..0){ break. Esta estrutura é particularmente útil quando se tem um conjunto de instruções que se deve executar em ordem. case 4: // polimento. Neste exemplo. case 2: // desbaste fino. As instruções que veremos a seguir devem ser usadas com muita parcimônia.. switch(seleção){ case 1: // desbaste grosso. // saída do laço } num++.7.while. a principio.&selecao). Caso o resultado da expressão for diferente de todos os valores dos rótulos então conjunto d é executado. do{ Exemplo: No exemplo acima... o programa iniciará o processo de usinagem de uma peça em um ponto qualquer dependendo do valor lido. goto. rtl N o o u c n noN o ju t rtl D o o u c n noD o ju t Figura 5. a saída do laço se dá pela instrução break que é executada quando um valor negativo é lido.. 5. continue. . é um erro: laço infinito. O rótulo default é opcional. Exemplo: No trecho abaixo um laço de repetição lê valores para o cálculo de uma média. puts("digite valores:"). // sempre verdadeiro printf("média: %f". exit() As instruções vistas anteriormente podem sofrer desvios e interrupções em sua seqüência lógica normal através do uso certas instruções. do. 5.. O laço possui uma condição de controle sempre verdadeira o que. Quando em um laço de repetição. scanf("%d". puts("Digite estagio de usinagem:"). pois fogem da lógica estruturada tem a tendência de tornar um programa incompreensível. soma += val. case 3: // acabamento.case.O valor de expressão é avaliado e o fluxo lógico será desviado para o conjunto cujo rótulo é igual ao resultado da expressão e todas as instruções abaixo deste rótulo serão executadas..

sem executar o resto das instruções. ela pula as instruções de um laço de repetição sem sair do laço. Foram usadas duas instruções goto. Exemplo: No trecho abaixo revemos um laço de repetição lê valores para o cálculo de uma média.. printf("média: %f".. . if(val < 0. continue.. 5. // . no entanto.case. rótulo: .0) então o programa salta diretamente para a condição de controle.. case ´C´: // prepara pizza calabreza. case ´A´: // prepara pizza Alho&Oleo.. São raros os casos onde a instrução goto é necessária. Isto é.. if(val >= 0.puts("valor:").. Exemplo: No trecho abaixo revemos um laço de repetição lê valores para o cálculo de uma média..A instrução goto Esta instrução é chamada de desvio de fluxo.0){ // se val é negativo.. scanf("%f". } }while(val >= 0.fim do laço printf("média: %f". default: puts("Opcao incorreta"). puts("Muzzarela Calabreza Alho&Oleo:"). scanf("%f". onde rótulo é um identificador válido. } 5. // se (val < 0. O outro uso da instrução break. Esta instrução opera de modo semelhante a instrução break dentro de um laço de repetição.salta para.7.. ela pode ser útil..soma/num). puts("digite valores:"). há certas circunstâncias.0) estas instruções soma += val. onde usada com prudência. soma += val.... puts("digite valores:"). A instrução desvia o programa para um rótulo (posição identificada) no programa. puts("Selecione o sabor de sua pizza:"). // . tipo = getch().. serve para separar os conjuntos de instruções em cada case.0).soma/num).. Exemplo: Estrutura switch.&val).2 A instrução continue. Se (val < 0..&val).0){ num++. // não são executadas! }while(val >= 0. 42 .7. } num++. Sintaxe: A sintaxe da instrução goto é a seguinte: goto rótulo. Quando executada. do{ puts("valor:").0). a instrução força a avaliação da condição de conttrole do laço. em estruturas switch.3 .case com a instrução break: int tipo...... switch(tipo){ case ´M´: // prepara pizza muzzarela. inicio: // rótulo puts("valor:").

&val). Esta função (não instrução) exit() . Exemplo: o código mostrado abaixo é uma função definida pelo usuário para calcular a média aritmética de dois números reais: float media2(float a. // não são executadas! goto inicio. } num++. é uma função que termina a execução de um programa. cada um escrevendo um segmento separado. A função exit() tem a seguinte declaração: void exit(int status). veremos como escrever funções de usuário em C. getch() ou putchar()). um nome pelo qual a chamamos e uma lista de argumentos passados a função. return(med).. puts("digite valores:"). 5.7. Já vimos o uso de funções nos capítulos anteriores: funções já providenciadas pelas bibliotecas-padrão do C (como sqrt(). Normalmente um programa é terminado quando se executa a última sua instrução. Neste capítulo. porém pode-se terminar a execução do programa a qualquer momento com o uso desta função. Deste modo pode-se segmentar um programa grande em vários programas menores. exit(0).salta para fim } num++. Esta segmentação é chamada de modularização e permite que cada segmento seja escrito. É possível ao programador. Funções são segmentos de programa que executam uma determinada tarefa específica. Foi usado a função exit para terminar a execução do programa.. alem disso.4 .h. } 43 . testado e revisado individualmente sem alterar o funcionamento do programa como um todo. if(val < 0..scanf("%f".A função exit(). // . Chamamos este conjunto de elementos de definição da função.1 . 6.. // se (val < 0.0) estas instruções soma += val. soma += val. Permite ainda que um programa seja escrito por vários programadores ao mesmo tempo. da biblioteca stdlib.0){ // se val é negativo. if(val < 0. Onde o argumento da função é um valor inteiro que será passado para o Sistema Operacional: (variável de sistema errorlevel no DOS).. }while(1). goto fim.0){ printf("média: %f". // imprime resultado // termina programa 6Funções Funções (também chamadas de rotinas. // salta para inicio fim: // rótulo printf("média: %f". do{ puts("valor:"). scanf("%f".. float b){ float med. med = (a + b) / 2. Uma função de usuário constitui-se de um bloco de instruções que definem os procedimentos efetuados pela função.Estrutura das funções de usuário A estrutura de uma função de usuário é muito semelhante a estrutura dos programas que escrevemos até agora. escrever suas próprias rotinas.&val). ou sub-programas) são a essência da programação estruturada. toupper(). Exemplo: No trecho abaixo revemos um laço de repetição lê valores para o cálculo de uma média.0. // se val é negativo.soma/num). São as chamadas de funções de usuário ou rotinas de usuário.soma/num).

med). Vale notar que existe apenas um valor de retorno para funções em C.3 . Se nenhum tipo de retorno for especificado o compilador entenderá que o retorno será tipo int.2 .Corpo da função antes do programa principal (no mesmo arquivo) Quando escrevemos a definição de uma função antes do programa principal e no mesmo arquivo deste. Exemplo: No exemplo abaixo chamamos a função media2() dentro de um programa principal: void main() { float num_1. Depois de definimos um função. puts(”Digite dois números:”).. seu tipo de retorno e a lista de argumentos que recebe. Porém isto não é um limitação séria pois o uso de ponteiros (cap. para o programa que a chamou. b. d.. dentro de chaves {}. . Esta instrução tem duas finalidades: determina o fim lógico da rotina e o valor de retorno da função. med. ?) contorna o problema. podemos usá-la dentro de um programa qualquer. o nome da função segue as mesmas regras de definição de identificadores (veja seção 2. O tipo de retorno da função especifica qual o tipo de dado retornado pela função. 6.No exemplo acima definimos uma função chamada media2 que recebe dois argumentos tipo float: a e b.) { [bloco de instruções da função] } A primeira linha da função contém a declaração da função.Localização das funções Existem basicamente duas posições possíveis para escrevermos o corpo de uma função: ou antes ou depois do programa principal.1 . um valor também do tipo float: o valor da variável med.) // definição da função 44 . A sintaxe geral para isto é a seguinte: Sintaxe: Uma função escrita antes do programa principal: tipo nomef(. Se a função não retorna nenhum valor para o programa que a chamou devemos definir o retorno como void. Em seguida. Na declaração de uma função se define o nome da função. &num_1. &num_2).5 adiante). A média destes dois valores é calculada e armazenada na variável med declarada internamente.. A chamada de uma função termina com a instrução return() que transfere o controle para o programa chamador da função. num_2. Por ser um identificador. a sintaxe de uma função é a seguinte: tipo_de_retorno nome_da_função(tipo_1 arg_1.3: int. // chamada a função printf(”\nA media destes números e´ %f”.3. c. Este retorno de valor é feito pela função return()que termina a execução da função e retorna o valor de med para o programa que a chamou. tipo_2 arg_2. 6. O argumento de return() será retornado como valor da função. scanf(”%f %f”. ou seja um retorno ausente. A lista de argumentos da função especifica quais são os valores que a função recebe. definimos o bloco de instruções da função. float.Definição de funções De modo formal. } 6. As variáveis da lista de argumentos são manipuladas normalmente no corpo da função (veja seção 6. Podemos ainda escrever uma função no mesmo arquivo do programa principal ou em arquivo separado. podendo ser qualquer tipo de dado mostrado na seção 2.desvio] = estat(a. nenhuma outra instrução é necessária. Dizemos que estamos fazendo uma chamada a função. e)). med = media2(num_1. A função retorna.. etc. num_2). Não podemos fazer o retorno de dois ou mais valores como em algumas linguagens (no MatLab: [media.2).

) .. return(med). puts(”Digite dois números:”). . scanf(”%f %f”.0.num2.{ [corpo de função] } void main() { . // chamada da função printf(”\nA media destes números e´ %f”. num_2. &num_1... float b) // funcao max() { if(a > b) { return(a). } // programa principal // chamada da função Exemplo: Função media2() escrita antes do programa principal. } void main() // programa principal { float num_1. } else { return(b). O protótipo de uma função indica ao compilador quais são as funções usadas no programa principal os tipo. med. Um protótipo é uma instrução que define o nome da função.h> float max(float a.. num_2). med = media2(num_1. seu tipo de retorno e a quantidade e o tipo dos argumentos da função.num2). } 6.. } // programa principal // protótipo da função // chamada a função 45 . // chamada da funcao printf("O maior valor e': %f".Corpo da função depois do programa principal (no mesmo arquivo) Quando escrevemos a definição de uma função depois do programa principal e no mesmo arquivo deste.&num2).h> #include <stdio. &num_2). float media2(float a. scanf("%f %f".. med = (a + b) / 2. getch().cpp Propósito: Função de usuário escrita antes de programa principal Ultima Revisão: 29/09/97 *****************************************************************/ #include <conio.) . var = nomef(..&num1. m = max(num1. float b) // função { float med..3. puts("Digite dois numeros:"). /***************************************************************** Programa: e0601. } Programa exemplo: No arquivo e0601. var = nomef(..m. clrscr().m).). med)..2 .cpp existe um programa que calcula o maior valor entre dois números digitados. Este programa faz uso da função max()escrita pelo usuário.. devemos incluir um protótipo da função chamada.. A sintaxe geral para isto é a seguinte: Sintaxe: Uma função escrita depois do programa principal: void main(){ tipo nomef(. puts("*** Valor maximo de dois reais ***")... } } void main() // programa principal { float num1.

// protótipo da funcao max() float num1. &num_1.h> #include <stdio. Programa exemplo: No arquivo e0602. return(med).float). clrscr(). scanf(”%f %f”. /***************************************************************** Programa: e0602. } float max(float a. // protótipo de media2() float num_1. num_2). } } // funcao max() 6. float b){ // função media2() float med. printf("O maior valor e': %f". num_2. Sintaxe: A sintaxe de inclusão de funções de usuário é a seguinte: #include ”path” void main(){ // inclusão da função // programa principal 46 .0. como em muitas outras linguagens. med).h> void main(){ // programa principal float max(float.&num2).. med. puts("*** Valor maximo de dois reais ***"). puts("Digite dois numeros").Corpo da função escrito em arquivo separado Em C. puts(”Digite dois números:”).. num2. Quando escrevemos a definição de uma função em arquivo separado do programa principal devemos incluir este arquivo no conjunto de arquivos de compilação do programa principal.2 e 3. }else{ return(b).&num1. } float media2(float a.3 . é permitido que o usuário crie uma função em um arquivo e um programa que a chame em outro arquivo distinto. Esta facilidade permite a criação de bibliotecas de usuário: um conjunto de arquivos contendo funções escritas pelo usuário.3. &num_2). Este programa faz uso da função max()escrita pelo usuário.tipo nomef(. Observe ainda que na lista de argumentos do protótipo podem ser escritos apenas os tipos dos argumentos. med = (a + b) / 2. scanf("%f %f".cpp Proposito: Funcao de usuário escrita depois de programa principal Ultima Revisão: 29/09/97 *****************************************************************/ #include <conio.num2)). Esta inclusão é feita com a diretiva #include. // chamada a funcao getch(). instrui o compilador para incluir na compilação do programa outros arquivos que contem a definição das funções de usuário e de biblioteca. vista nas seções 2.7. } Observe que o protótipo de uma função nada mais é que a declaração da função sem o seu corpo. med = media2(num_1. void main(){ // programa principal float media2(float. Esta possibilidade é uma grande vantagem utilizada em larga escala por programadores profissionais.4.){ [corpo de função] } // definição da função Exemplo: Função media2() escrita depois do programa principal.cpp existe um programa que calcula o maior valor entre dois números digitados.float). float b){ if(a > b){ return(a). // chamada a função printf(”\nA media destes números e´ %f”.max(num1. Esta diretiva.1.

h” // inclusão da função void main(){ // programa principal float num_1. // chamada a função printf(”\nA media destes números e´ %f”. Quando isto acontece dizemos que a função chamadora tem hierarquia maior (ou superior) a função chamada. med). puts(”Digite dois números:”). switch (tipo){ case 0: sound(100). uma função chamada é escrita antes de uma função chamadora.) . scanf(”%f %f”.. isto é. Ultima Revisão: 29/09/97 *********************************************************/ // 1 inclusão de bibliotecas padrão C // ********************************** #include <dos.c.h> #include <string.. #include ”c:\tc\userbib\stat. min(). &num_2). var = nomef(. num_2). Quando um arquivo possui a definição de mais de uma função.h> // 2 rotina bip() // ************** void bip(int tipo){ int i. &num_1..h> #include <stdio. devemos ter o cuidado de definir (ou incluir) as funções em ordem crescente de hierarquia.4 . Por exemplo. Quando isto ocorre.. Ou que a função chamadora está em um nível hierárquico superior a função chamada.cpp Propósito: Uso de varias funções de usuário. delay(5)...cpp existe um jogo de “jackpot” que ilustra o uso de várias rotinas por um programa principal. definindo-as em um arquivo chamado stat. delay(100).h> #include <stdlib.. /********************************************************* Programa: e0605. med. Em geral.lib. quando o arquivo possui apenas uma função ele é nomeado com o mesmo nome da função e extensão *. case 1: sound(200).cpp. 6. Isto se deve ao fato de que o compilador deve conhecer uma função antes de que chamada seja compilada. num_2. max().. etc. } Observação: Um arquivo pode conter a definição de uma ou mais funções. poderíamos definir a função media() no arquivo media.Hierarquia de Funções Sempre é possível que um programa principal chame uma função que por sua vez chame outra função.h> #include <conio. // contador de iteração // seleciona tipo de som.h. med = media2(num_1. Exemplo: A função media2() está escrita em um arquivo separado. } // chamada a função Na diretiva #include. break. ele é nomeado com a extensão *. dsvpd(). // giro da roleta // parada da roleta 47 . Programa exemplo: No arquivo e0605. Por exemplo: poderíamos criar um conjunto de funções estatísticas chamadas media(). indicamos entre aspas duplas o caminho de localização do arquivo onde está definida a função chamada.cpp ou *..h ou *. e assim sucessivamente. Observe também que estas funções chamam-se umas as outras. moda()...

delay(20).} break... gotoxy(coluna.linha++). cprintf(" ÛÛÛÛÛ "). cprintf(" Û°°°°°Û "). gotoxy(coluna. } nosound(). cprintf("Û°°Û°Û°°Û"). cprintf("Û°°°°°°°Û").linha++). gotoxy(coluna. case 3: // ouro if(status == 0){ // se roleta girando. // cor da figura } gotoxy(coluna... // cor normal }else{ textcolor(RED). gotoxy(coluna. int coluna){ switch (figura){ // seleciona figura. // cor normal 48 . gotoxy(coluna. gotoxy(coluna.linha++). cprintf(" Û°°°Û "). case 2: // moedas caindo sound(3000).linha++).linha++). textcolor(LIGHTGRAY).linha++).linha++). cprintf("Û°°°°°°°Û"). cprintf(" Û°°°°°Û "). gotoxy(coluna. gotoxy(coluna.linha++).. // 3 rotina pinta() // **************** void pinta(int figura. case 1: // happy face if(status == 0){ // se roleta girando. gotoxy(coluna..linha++).linha++).linha++). cprintf("Û°°°Û°°°Û"). int linha. gotoxy(coluna. gotoxy(coluna. gotoxy(coluna.linha++).. break. cprintf("Û°°°°°°°Û").int status. // cor da figura } gotoxy(coluna. textcolor(LIGHTGRAY). gotoxy(coluna. // posiciona cursor cprintf(" ÛÛÛÛÛ "). cprintf("Û°°°°°°°Û").linha++). textcolor(LIGHTGRAY).linha++).. cprintf("Û°°ÛÛÛ°°Û").linha++).linha++). gotoxy(coluna. // posiciona cursor cprintf(" ÛÛÛ ÛÛÛ "). cprintf(" Û ").linha++). cprintf("Û°Û°°°Û°Û").linha++). break. // cor normal }else{ textcolor(YELLOW+BLINK). cprintf(" Û°°°°°Û "). gotoxy(coluna. cprintf(" Û°Û "). case 2: // copa if(status == 0){ // se roleta girando. cprintf("Û°°°°°°°Û"). gotoxy(coluna.

linha++).. cprintf("Û°°°°°°°Û"). cprintf(" Û°°°Û "). gotoxy(coluna.}else{ textcolor(BLUE). cprintf(" Û "). gotoxy(coluna. cprintf(" Û°Û ").linha++). // cor normal }else{ textcolor(CYAN). cprintf(" Û°°°Û "). gotoxy(coluna.linha++). cprintf(" ÛÛÛ "). // cor da figura } gotoxy(coluna.. // cor da figura } gotoxy(coluna. 49 . gotoxy(coluna. gotoxy(coluna.linha++).linha++).linha++). textcolor(LIGHTGRAY). cprintf(" Û°Û ").linha++). break.linha++).linha++). gotoxy(coluna. gotoxy(coluna. gotoxy(coluna. textcolor(LIGHTGRAY). gotoxy(coluna. cprintf(" Û°Û "). cprintf(" Û°°°Û "). gotoxy(coluna. cprintf(" Û°°°°°Û "). cprintf(" Û "). cprintf(" Û°°°°°Û "). cprintf("Û°°°°°°°Û"). // cor normal }else{ textcolor(GREEN). gotoxy(coluna. gotoxy(coluna. cprintf(" ÛÛ Û ÛÛ "). gotoxy(coluna.linha++). gotoxy(coluna.linha++).. gotoxy(coluna. cprintf(" ÛÛ°°°ÛÛ ").linha++).linha++). gotoxy(coluna. cprintf(" Û°Û "). cprintf(" Û°°°°°Û "). case 4: // espada if(status == 0){ // se roleta girando. cprintf("Û°°ÛÛÛ°°Û"). gotoxy(coluna. gotoxy(coluna.linha++).linha++). cprintf(" Û°°°Û "). gotoxy(coluna. gotoxy(coluna. // cor da figura } gotoxy(coluna. break.linha++).. cprintf("Û°°°°°°°Û"). cprintf(" Û ").linha++).linha++).linha++).linha++). // posiciona cursor cprintf(" Û ").linha++). cprintf("Û°°°°°°°Û").linha++). cprintf(" Û°°°Û "). gotoxy(coluna.linha++).linha++). case 5: // pau if(status == 0){ // se roleta girando.

};

}; textcolor(LIGHTGRAY);

gotoxy(coluna,linha++); cprintf("Û°°ÛÛÛ°°Û"); gotoxy(coluna,linha++); cprintf(" ÛÛ Û ÛÛ "); gotoxy(coluna,linha++); cprintf(" Û "); // cor padrao

// 4 rotina imprimec() // ******************* void imprimec(int linha,char* texto){ int col,tam; textcolor(WHITE); // cor de letra textbackground(BLUE); // cor de fundo gotoxy(1,linha); // posiciona o cursor clreol(); // limpa linha(imprime fundo) tam = strlen(texto); // calcula o tamanho do texto col = 40 - tam / 2; // calcula a coluna de inicio gotoxy(col,linha); // posiciona o cursor cprintf("%s",texto); // imprime o texto textcolor(LIGHTGRAY); // cor de letra original textbackground(BLACK); // cor de fundo original }; // 5 rotina regras() // ***************** void regras(){ clrscr(); imprimec(1,"J a c k p o t !"); imprimec(10,"Regras:"); imprimec(11,"- Pressione [enter] para rodar a roleta."); imprimec(12,"- Pressione [esc] para sair."); imprimec(13,"- Quanto maior o numero de CARAS FELIZES, maior seu prêmio!"); getch(); clrscr(); } // 6 Rotina Saida() // **************** void saida(void){ imprimec(12,"Vencedores não usam drogas!"); delay(2000); textcolor(LIGHTGRAY); textbackground(BLACK); clrscr(); } // 7 rotina roleta() // ***************** void roleta(int naipe1,int naipe2,int naipe3,int naipe4,int naipe5){ int volta1=2,volta2=4,volta3=8,volta4=16,volta5=32,tempo=25; do{ if(volta1 > 1){ pinta(random(4)+2,0,5,6); bip(0); volta1--; }else if(volta1 == 1){ pinta(naipe1,1,5,6); bip(1); volta1--; } delay(tempo);

50

if(volta2 > 1){ pinta(random(4)+2,0,5,21); bip(0); volta2--; }else if(volta2 == 1){ pinta(naipe2,1,5,21); bip(1); volta2--; } delay(tempo); if(volta3 > 1){ pinta(random(4)+2,0,5,36); bip(0); volta3--; }else if(volta3 == 1){ pinta(naipe3,1,5,36); bip(1); volta3--; } delay(tempo); if(volta4 > 1){ pinta(random(4)+2,0,5,51); bip(0); volta4--; }else if(volta4 == 1){ pinta(naipe4,1,5,51); bip(1); volta4--; } delay(tempo); if(volta5 > 1){ pinta(random(4)+2,0,5,66); bip(0); volta5--; }else if(volta5 == 1){ pinta(naipe5,1,5,66); bip(1); volta5--; } delay(tempo); }while(volta5 > 0); } // 8 rotina abertura() // ******************* void abertura(){ imprimec(1,"J a c k P o t !"); roleta(1,1,1,1,1); imprimec(25,"T e n t e s u a getch(); }

// // S o r t e !"); // //

titulo caras felizes rodapé aguarda

// 9 rotina simnao() // ***************** int simnao(){ int tecla,resp; do{ tecla = getch(); // leitura do teclado switch (tecla){ case 13: // pressionou [enter]? resp = 1;

51

break; case 27: // pressionou [esc]? resp = 0; break; default: // pressionou qq outra coisa? printf("\a"); }; }while(tecla != 13 && tecla != 27); // nao sai enquanto tecla != [enter] ou [esc] return(resp); }; // 10 rotina sorte() // **************** int sorte(int f1,int f2,int f3,int f4,int f5){ int lucro,cont = 0; if(f1 == 1){cont++;}; if(f2 == 1){cont++;}; if(f3 == 1){cont++;}; if(f4 == 1){cont++;}; if(f5 == 1){cont++;}; switch (cont) { case 0: lucro = 0; break; case 1: lucro = 1; break; case 2: lucro = 5; break; case 3: lucro = 20; break; case 4: lucro = 50; break; case 5: lucro = 250; }; return(lucro); }; // 11 rotina plim_plim() // ******************** int plim_plim(int total,int lucro){ do{ if(lucro > 0){ lucro--; total++; bip(2); delay(50+random(100)); }; gotoxy(1,25); clreol(); printf("Dinheiro: $ %d",total); }while(lucro > 0); textcolor(7); textbackground(0); return(total); }; // 12 programa principal // ******************** void main(){

52

fig2. Variáveis Locais: Uma variável é dita local. &num_2). y.fig2. getch(). // termina } // * * * * f i m d o p r o g r a m a p r i n c p a l ! * * * * Neste programa exemplo. O espaço de memória alocado para esta variável é criado quando a execução do bloco é iniciada e destruído quando encerrado.2). onde uma variável é declarada define ainda seu escopo de validade. Isto por que o processador deve reservar um local da memória para armazenar os valores atribuídos à variável.fig3. // valor recebido na roleta int moedas = 10.fig3.3. // . uma variável só pode ser usada após ser declarada (ver seção 2. // despeja moedas }while(simnao() && moedas).fig4. os níveis hierárquicos das funções podem ser colocados da seguinte maneira: main() regras() abertura() sorte() imprimec() pinta() plim_plim() roleta() bip() saida() simnao() No exemplo acima temos um primeiro nível onde se encontra a função main() [o programa principal também é uma função] que chama as funções x. Observe que neste exemplo os protótipos das funções estão colocados de modo a que as funções de menor hierarquia são escritas antes das funções de maior hierarquia.int fig1. Em outras palavras define onde as variáveis e funções são reconhecidas. Exemplo: float media2(float a..Regra de escopo para variáveis A regra de escopo define o âmbito de validade de variáveis. Em C.. med = media2(num_1. roleta(fig1. &num_1. fig3 = random(5)+1. // calcula ganho na roleta moedas = plim_plim((moedas-2).fig4. med. // gera figuras da roleta fig2 = random(5)+1. variáveis distintas. // anuncia regras abertura(). // abertura do programa do{ // joga. // inicializa gerador aleatório regras(). // aguarda } saida(). 6. num_2. // figuras geradas na roleta int lucro = 0.fig2. // gira a roleta lucro = sorte(fig1. isto significa que podem ser apenas acessadas e modificadas dentro de um bloco. fig5 = random(5)+1. e t. A função x por sua vez chamas as funções s. med = (a + b) / 2. Uma variável pode ser local.0. imprimec(25. mas seu dinheiro acabou!"). } void main(){ float num_1. são para todos os efeitos..5 . Porém o local. fig1 = random(5)+1.fig5.fig5). 53 . puts(”Digite dois números:”).fig5).. se for declarada dentro do bloco de uma função.fig3.fig4. fig4 = random(5)+1. float b){ float med. z.lucro). assim variáveis de mesmo nome mas declaradas em blocos distintos. // dinheiro disponível randomize()."Sinto muito. scanf(”%f %f”. return(med). num_2).. enquanto desejar e tiver moedas if(moedas <= 0){ // se não tem mais moedas. Uma variável local tem validade apenas dentro do bloco onde é declarada. global ou formal de acordo com o local de declaração. do programa.. r.

54 . pode ser acessadas e modificada por qualquer função. void media2(void){ med = (a + b) / 2. a e b são parâmetros formais declarados na função media2(). } void main(){ puts(”Digite dois números:”). Para todos os efeitos estas variáveis são distintas. isto é. (n-1) . Outra variável med é também definida pela função main(). Por serem variáveis locais. 6. 1 0! = 1 onde n é um numero inteiro positivo. med. (n-2) . } No exemplo acima. No exemplo acima. float a. media2(). como no exemplo a seguir. Este tipo de passagem de argumentos é chamado de passagem por valor pois os valores das variáveis do programa chamador são copiados para as correspondentes variáveis da função chamada. a. tem validade apenas dentro da função onde é declarada. med). Vejamos um exemplo clássico para esclarecermos o conceito: calculo do fatorial de um número. se for declarada fora do bloco de uma função. Mesmo que os valores de a e b fossem alterados os valores de num_1 e num_2 não seriam alterados. Uma variável global tem validade no escopo de todas as funções.. Veremos no capitulo ? como alterar os valores das variáveis do programa chamador. med são variáveis globais definidas fora dos blocos das funções media() e main(). (n-1)! Esta propriedade é chamada de propriedade recursiva: o fatorial de um numero pode ser calculado através do fatorial de seu antecessor. . Variáveis Formais: Uma variável formal é uma variável local declarada na lista de parâmetros de uma função. 3 .Recursividade A recursividade talvez seja a mais importante vantagem das funções em C. } No exemplo acima. porém serve de suporte para os valores passados pelas funções. Exemplo: Uso de variáveis globais. &b). em C. A definição de fatorial é: n! = n . Para criarmos uma rotina recursiva. Recursão é o processo pelo qual uma função chama a si mesma repetidamente um numero finito de vezes. podendo ser acessadas e modificadas por quaisquer uma das funções. Ora. basta criar uma chamada a própria função dentro dela mesma. Observe que a função é chamada com os valores de num_1 e num_2. . Variáveis Globais: Uma variável é dita global. Este recurso é muito útil em alguns tipos de algoritmos chamados de algoritmos recursivos. med). Uma propriedade (facilmente verificável) dos fatoriais é que: n! = n . 2 . Deste modo. podemos utilizar esta propriedade para escrevermos uma rotina recursiva para o calculo de fatoriais. Chamaremos esta passagem de passagem por endereço. As variáveis formais na declaração da função e na chamada da função podem ter nomes distintos. O espaço de memória alocado para esta variável é criado no momento de sua declaração e destruído apenas quando o programa é encerrado.. med é uma variável local definida pela função media().6 . Deste modo ambas as funções tem pleno acesso as variáveis. os valores que uma função passa para outra não são alterados pela função chamada.0.printf(”\nA media destes números e´ %f”. &a. scanf(”%f %f”. A única exigência é de que sejam do mesmo tipo. printf(”\nA media destes números e´ %f”. b. Assim não é necessário a passagem de parâmetros para a função. b.

Uma função recursiva cria a cada chamada um novo conjunto de variáveis locais. Teoricamente uma algoritmo recursivo pode ser escrito de forma iterativa e vice-versa. 55 . além do alcance deste texto. porém. simulação numérica. etc. busca e ordenação em arvore binaria. A principal vantagem destes algoritmos é que algumas classes de algoritmos [de inteligência artificial. O estudo deste tipo de algoritmo está. Não existe ganho de velocidade ou espaço de memória significativo com o uso de funções recursivas.] são mais facilmente implementadas com o uso de rotinas recursivas.

Declaração e inicialização de vetores 7. Nestes casos. A quantidade de memória (em bytes) usada para armazenar um vetor pode ser calculada como: quantidade de memória = tamanho do tipo * tamanho do vetor 1 Alguns autores preferem chamar todos os tipos de estruturas homogêneas.Introdução Em muitas aplicações queremos trabalhar com conjuntos de dados que são semelhantes em tipo.4 6. nesta apostila. Por exemplo o conjunto das alturas dos alunos de uma turma.7Vetores Neste capítulo estudaremos o conceito de vetor.5. // // declara um vetor chamado 'idade' do tipo 'int' que recebe 100 elementos. e poder referenciar cada dado individual deste conjunto por um número índice. float. Em programação. Outros preferem chamar de matrizes. nome é o nome identificador do vetor.6 7. As regras de nomenclatura de vetores são as mesmas usadas em variáveis (seção 2. isto é.1). n 0 1 2 3 4 nota 8. n representa um número de referência e nota é o nome do conjunto..Declaração de vetores Em C.9 4. Na declaração de um vetor estamos reservando espaço de memória para os elementos de um vetor. onde: tipo é o tipo dos elementos do vetor: int. Exemplo: Veja as declarações seguintes: int idade[100].2. um vetor é um conjunto de variáveis de um mesmo tipo que possuem um nome identificador e um índice de referência. como trabalhar com vetores de mais de uma dimensão. Neste caso. double . de elementos com um nome coletivo e um índice de referência aos valores da lista. Assim podemos dizer que a 2a nota é 6.. 7.9 ou representar nota[1] = 6. etc. Como são usados vetores em argumentos de funções. ou um conjunto de seus nomes.5 4. Outros ainda distinguem vetores (uma dimensão) de matrizes (mais de uma dimensão). cada dado é referenciado por dois índices e dizemos que se trata de um vetor bidimensional (ou matriz)1.2. Também podemos organizar dados sob forma de tabelas. Sintaxe: A sintaxe para a declaração de um vetor é a seguinte: tipo nome[tam]. E. este tipo de estrutura de dados é chamada de vetor (ou array. Exemplo: A maneira mais simples de entender um vetor é através da visualização de um lista. Vetores de mais de uma dimensão serão vistos na seção 7. declara um vetor chamado 'nome' do tipo 'char' que pode armazenar 80 caracteres. declara um vetor chamado 'nota' do tipo 'float' que pode armazenar 25 números. em inglês) ou. tam é o tamanho do vetor. // // float nota[25]. ainda.1 . vamos usar a primeira nomenclatura: toda estrutura homogênea de dados será chamada de vetor.2 Nesta lista.9 Esta não é a única maneira de estruturar conjunto de dados. de maneira mais formal estruturas de dados homogêneas. Não vamos entrar no mérito da questão (existem boas justificativas para todas as interpretações) e. seria conveniente poder colocar estas informações sob um mesmo conjunto. não importando o numero de índices de referência (ou dimensões) de vetores. 56 .1 . o número de elementos que o vetor pode armazenar. // // char nome[80].2 . 7. sua declaração e uso.

valor[random(MAX)] = 2. // declaração de vetor vogal[0]='a'. // inicialização por lista char letra[80]. cor_menu[2] = GREEN.YELLOW. 200(2x100). 100(4x25) e 80(80x1) bytes. // declaração de vetor char vogal[5].h> void main(){ int total[5] = {0.cpp contém um programa que mostra o uso de vetores: declaração.7.Inicialização de vetores Assim como podemos inicializar variáveis (por exemplo: int j = 3.2 . Opcionalmente. Observe que a inicialização de nota gera o vetor do exemplo do início desta seção. int i.4. float nota[5] = {8. /**************************************************** Programa: e0701.0}. no exemplo anterior. O índice de um vetor deve ser inteiro.2. separada por vírgulas. Programa Exemplo: O arquivo e0701. valor[1] = 6. cor_menu[1] = YELLOW.705.h> #include <ctype.2. ‘u'}. // inicialização por elemento vogal[1]='e'. char vogal[5] = {'a’..2}.).. ‘e’. ou int cor_menu[4].6.2 . Exemplo: Algumas referências a vetores: #define MAX 5 int i = 7. int dia[7] = {12. inicialização. vogal[4]='u'.j. // contadores clrscr().0.645. valor[MAX] = 3.0.13. O primeiro elemento do vetor tem índice 0 e o último tem índice tam-1.6.h> #include <stdio. i=0.6}. respectivamente.Referência a elementos de vetor Cada elemento do vetor é referenciado pelo nome do vetor seguido de um índice inteiro.30.4. vogal[3]='o'.7. 7.GREEN. leitura e escrita de elementos. dos valores de cada elemento do vetor. valor[sqrt(MAX)] = 2. ‘i’.768. podemos inicializar vetores. float valor[10]. do{ // faz a leitura das teclas.867.GRAY}. cor_menu[0] = BLUE. puts("Digite uma frase de teste:"). // declaração de vetor // NÃO é válido! 7.Assim. vogal[2]='i'.. a quantidade de memória utilizada pelos vetores é. // i-esimo elemento de 'letra' recebe tecla 57 .5. Exemplo: Veja as inicializações seguintes. ‘o’. valor[i] = 7.0.4.9. Exemplo: Observe que estas duas inicializações são possíveis: int cor_menu[4] = {BLUE. podemos inicializar os elementos do vetor enumerando-os um a um..645.15. Sintaxe: A sintaxe para a inicialização dos elementos de um vetor é: tipo nome[tam] = {lista de valores}.14. cor_menu[3] = GRAY.cpp Propósito: Manipula vetores Ultima Revisão: 20/10/97 ****************************************************/ #include <conio. letra[i] = tolower(getche()). onde: lista de valores é uma lista.

{ printf("%c: %d \n". enquanto não for [enter] puts("\nTotal de vogais digitadas:"). Deste modo podemos alterar o número de elementos do vetor antes de qualquer compilação do programa. Mas é possível declarar um vetor com tamanho parametrizado: usando uma constante simbólica. i<=4. Estes testes de limite devem ser feitos logicamente dentro do programa. A princípio este fato poderia parecer um defeito da linguagem.. . &num)..3 . Observe que acessar um segmento fora do espaço destinado a um vetor pode destruir informações reservadas de outras variáveis. O primeiro segmento será reservado para vet[0]. de modo que vet[0] será localizado no segmento base. // . usando a sintaxe descrita acima. O segmento inicial é chamado de segmento base. // imprime totais } getch().Limites Na linguagem C. 7. j<=4. Exemplo: O trecho de código seguinte faz uma declaração errada de vetor..for(j=0. tenhamos definido o tamanho de um vetor. estamos a acessando segmento base+7 que não foi reservado para os elementos do vetor e que provavelmente está sendo usado por uma outra variável ou contém informação espúria (lixo).vogal[i]. Este fato se deve a maneira como o C trata vetores.. puts("Quantos números?"). i++) // para todas as vogais. teoricamente só tem sentido usarmos os elementos valor[0]. { total[j]++. // pausa } 7. e também testar os limites de um vetor. A memória do microcomputador é um espaço (físico) particionado em porções de 1 byte. // declaração de vetor (errado!) .Tamanho parametrizado Na linguagem C não é possível.2 .3. Declaramos uma constante simbólica (parâmetro) com a diretiva #define no cabeçalho do programa e depois declaramos o vetor com esta constante simbólica como tamanho do vetor. A solução mais adequada é sempre avaliar os limites de um vetor antes de manipulá-lo.. Poder manipular sem restrições todos os segmentos de memória é uma flexibilidade apreciada pelos programadores. .. 58 .total[i]).3.. float valor[num]. estamos reservando 6 bytes (3 segmentos de 2 bytes) de memória para armazenar os seus elementos.. Quando acessamos o elemento vet[i]. for(i=0.. o C não faz nenhum teste de verificação de acesso a um elemento dentro do vetor ou não. Se declaramos um vetor como int vet[3]. o C não acusa erro se usarmos valor[12] em algum lugar do programa.Tamanho de um vetor e segmentação de memória 7.. estamos acessando o segmento base+2 ou vet[2](o ultimo segmento reservado para o vetor). Esta é uma maneira simples de administrar o espaço de memória usado pelo programa. Se i for igual a 2. devemos ter cuidado com os limites de um vetor. Embora na sua declaração.. Por exemplo se declaramos um vetor como int valor[5]. o processador acessa o segmento localizado em base+i. Estes erros são difíceis de detectar pois o compilador não gera nenhuma mensagem de erro.. Porém.. int num. se i for igual a 7. o segundo segmento para vet[1] e o terceiro segmento para vet[2]. scanf("%d”. mas na verdade trata-se de um recurso muito poderoso do C. Porém. valor[4]. // incrementa i-esimo contador } } }while(letra[i++] != '\r').1 . declarar um vetor com tamanho variável... j++) // para todas as vogais. { if(letra[i] == vogal[j]) // se tecla digitada e' vogal...

int valor[MAX].. Na declaração da função: float media(float vetor[]. n).4 .Programa Exemplo: O arquivo e0703. printf("\n%3d: %d". i <= MAX-1. i++) // somente MAX valores sao calculados { valor[i] = 1+random(100). // declaração do vetor usando MAX randomize(). med = media(valor.. Sintaxe: Na passagem de vetores para funções usamos a seguinte sintaxe: nome_da_função(nome_do_vetor) onde: nome_da_função é o nome da função que se está chamando. nome_vetor é o nome do vetor.cpp Propósito: Mostra declaração de vetor com tamanho parametrizado Ultima Revisão: 17/10/97 *****************************************************************/ #include <conio. } Na chamada da função: // declaração da função void main(){ float valor[MAX].h> #include <stdio. // declaração do vetor . podem ser usados como argumentos de funções. tipo_vetor é o tipo de elementos do vetor. sem índices. Indicamos apenas o nome do vetor..valor[i]). Mostra também o uso deste parâmetro como teste de limite do vetor.. // passagem do vetor para a função ..cpp contém um programa que mostra a declaração de um vetor com tamanho parametrizado..float N){ .. } 59 . for(i = 0. clrscr(). /***************************************************************** Programa: e0703.h> #include <stdlib.. Observe que depois do nome do vetor temos um índice vazio [] para indicar que estamos recebendo um vetor. Sintaxe: Na declaração de funções que recebem vetores: tipo_função nome_função(tipo_vetor nome_vetor[]){ . Vejamos como se declara uma função que recebe um vetor e como se passa um vetor para uma função. nome_função é o nome da função. } onde: tipo_função é o tipo de retorno da função. assim como variáveis. Exemplo: Observe o exemplo abaixo. printf("Calculo de %d números aleatórios: ".i+1. } 7.Passando Vetores para Funções Vetores.h> #define MAX 5 // definição do parâmetro MAX // Experimente alterar este valor! void main() { int i=3. Compile este programa com outros valores para o parâmetro MAX e verifique que a execução do programa é alterada automaticamente. // o valor e' impresso } getch(). nome_do_vetor é o nome do vetor que queremos passar.MAX).

do{ puts("\nDigite a quantidade de numeros a ordenar: ").num[i]). } getch(). Ultima Revisão: 20/10/97 ***********************************************************************/ #include <dos. i++){ printf("%2d ".int). i<=(n-1) . Uma abordagem mais detalhada deste procedimento será feita no capítulo ? sobre ponteiros. randomize(). // imprime vetor ordenado delay(50).h> #include <stdlib.&n). for(i = 0. // ********************************* // 1. // // // // // contador de iteração numero de elementos do vetor declaração do vetor 'num' de MAX elementos protótipo da função de ordenamento inicializa gerador aleatório // ******************** // 1.. Neste caso a modificação é desejada pois queremos ordenar os elementos do vetor.cpp contém um programa que mostra a modificação de um vetor por uma função. scanf("%d". // passagem do vetor idade para a função puts("\nValores ordenados:"). }while(n < 1 || n > MAX).2 Geração de numeros aleatórios // ********************************* puts("Gerando lista de numeros aleatorios. Isto ocorre porque a passagem de vetores para funções é feita de modo especial dito Passagem por endereço. Programa Exemplo: O arquivo e0705.Atenção: Ao contrário das variáveis comuns.1 Entrada de dados // ******************** clrscr(). i++){ num[i] = random(100).h> #include <stdio. void ordem(int[]. } // 2 rotina ordem() 60 .h> #include <conio.cpp Propósito: Mostra a modificação de elementos de um vetor passado como argumento de uma função. o conteúdo de um vetor pode ser modificado pela função chamada. Isto significa que podemos passar um vetor para uma função e alterar os valores de seus elementos. for(i=0 .num[i]).h> #define MAX 150 // ******************** // 1 Programa principal // ******************** void main(){ int i. int n. /*********************************************************************** Programa: e0705. // imprime vetor gerado delay(50). Portanto devemos ter cuidado ao manipularmos os elementos de um vetor dentro de uma função para não modifica-los por descuido. } // ************************* // 1. // gera numero aleatório printf("%2d ".. int num[MAX].3 Ordenação e impressão // ************************* ordem(num.n). i <= n-1.").

7}}.5.55}.6 6. {{lista}.{lista}}. {50.9.7. float nota[5][3] = {{8..2.4 6.3}. int tabela[2][3][2] = {{{10.4 2.. {{40.9}. // .9 8.4 8.7.15}. {4.45}.. // troca.35}}. física e química. if(valor[i] > valor[i+1]){ // se fora de ordem. {20. três.J.2 1 7.8.. t++. // Referencia: MANZANO.5 4.1] = 6. 61 .int num){ // declaração da função int t. Algoritmos: Lógica para desen// volvimento de programação. // contador de iteração do{ // ordena. 1996 [p.3 7.4 ou representar nota[2. Sintaxe: A sintaxe para declaração de vetores multidimensionais é: tipo nome[tam_1][tam_2]. O nome nota é o nome do conjunto.5 .N. {30.7}..6 7.9. valor[i] = valor[i+1]. São Paulo.6. temp = valor[i].5...65}}.25}. nome é o nome do vetor..A. Exemplo: veja algumas declarações e inicializações de vetores de mais de uma dimensão.enquanto houver trocas } 7.. nota 0 1 2 3 4 0 8.7 4.2.. i++){ // para todos os elementos do vetor. [tam_1][tam_2].4.6. assim podemos dizer que a nota do 3 o aluno na 2a prova é 6.G.4 7.J.5..8.{lista}.6}. Observe que a inicialização de nota gera a tabela do exemplo do início desta seção. Podemos ter vetores de duas.4..Declaração e inicialização A declaração e inicialização de vetores de mais de uma dimensão é feita de modo semelhante aos vetores unidimensionais..{lista}} são as listas de elementos. Podemos entender um vetor de duas dimensões (por exemplo) associando-o aos dados de um tabela.9 3.{lista}.3.4.9 4.7 Nesta tabela representamos as notas de 5 alunos em 3 provas diferentes (matemática. {6.1 . // armazenador temporário para troca int i.// ************************************************************************** // Método: Ordenação Bolha. {7. ou mais dimensões. valor[i+1] = temp... {60..4.. onde: tipo é o tipo dos elementos do vetor.6. // nenhuma troca ainda for(i = 0. // contador de trocas int temp..OLIVEIRA. i <= num-2.6.F..Vetores Multidimensionais Vetores podem ter mais de uma dimensão. Exemplo: Um vetor bidimensional pode ser visualizado através de uma tabela.121] // "O mais simples e mais ineficiente algoritmo desenvolvido pela humanidade" // ************************************************************************** void ordem(int valor[]. //conta troca } } }while(t).6 2 5. Erica. t = 0. {4.[tam_N]={{lista}. mais de um índice de referência. isto é.7 6..7.[tam_N] é o tamanho de cada dimensão do vetor... por exemplo).

med = media(valor. sem índices.h> #include <stdio. // passagem do vetor para a função ...&n). // declaração do vetor .Neste exemplo.. /********************************************************************** Programa: e0706.int).. scanf("%d". // contadores de iteração void impmtz(int[MAX][MAX].&m). // leitura da ordem da matriz do{ puts("Digite o numero de LINHAS da matriz:"). Ultima Revisão: 20/10/97 **********************************************************************/ #include <conio.cpp contém um programa que mostra a manipulação de vetores bidimensionais: leitura de elementos. n).int N.int). } Programa Exemplo: O arquivo e0706.[tam_n]){ . // leitura dos elementos da matriz puts("Digite os elementos (INTEIROS) da matriz:")..int.Passagem de vetores multidimensionais para funções A sintaxe para passagem de vetores multidimensionais para funções é semelhante a passagem de vetores unidimensionais: chamamos a função e passamos o nome do vetor. int M){ .int. } // declaração da função Na chamada da função: void main(){ int valor[5][7].. scanf("%d". passagem para funções.cpp Propósito: Mostra a manipulação de vetores de 2 dimensões.l. nota é um vetor duas dimensões ([][]). do{ puts("Digite o numero de COLUNAS da matriz:"). A única mudança ocorre na declaração de funções que recebem vetores: Sintaxe: Na declaração de funções que recebem vetores: tipo_f função(tipo_v vetor[tam_1][tam_2].5. etc.2 .h> #define MAX 5 // 1 Programa principal // ******************** void main(){ int a[MAX][MAX].. // vetor bidimensional!! int n. Exemplo: Observe o exemplo abaixo: Na declaração da função: int max(int vetor[5][7]. Este vetor é composto de 2 vetores de 3 sub-vetores de 2 elementos cada. // função de transposição de matriz // titulo clrscr().. tabela é vetor de três dimensões ([][][]). 7. // numero de linhas(n) e colunas(m) da matriz int c. escrita. // função de impressão de matriz void transp(int[MAX][MAX]. }while(m < 1 || m > MAX). puts("Transposicao de Matrizes"). 62 .. } Observe que depois do nome do vetor temos os índices com contendo os tamanhos de cada dimensão do vetor.. }while(n < 1 || n > MAX). Este vetor é composto de 5 vetores de 3 elementos cada.m.

j <= max_col-1 . int max_lin. l++){ for(c = 0 . getch(). j++){ // para todas as colunas j >= i temp = matriz[i][j]. // imprime elemento } } puts("\n").m. • Os índices dos vetores multidimensionais. // quebra linha for(j = 0 .. j <= max_col-1 . i <= max_lin-1 . scanf("%d". for(i = 0 . for(i = 0 . • Embora uma tabela não seja a única maneira de visualizar um vetor bidimensional. j++){ // para todas as colunas. printf("%3d ". // À > elemento do vetor } } // impressão da matriz original clrscr(). impmtz(a. podemos entender o primeiro índice do vetor como o índice de linhas da tabela e o segundo índice do vetor como índice das colunas. // pausa } // 2 rotina impmtz() // ***************** void impmtz(int matriz[MAX][MAX]. // impressão da matriz transposta puts("Matriz Transposta:").j.j. for(j = i . // transposicao transp(a.. os vetores multidimensionais podem ter seus elementos modificados pela função chamada. i++){ // para todas as linhas. matriz[j][i] = temp.c+1). } // ***************** // 3 rotina transp() // ***************** void transp(int matriz[MAX][MAX].for(l = 0 .m). l <= n-1 .temp. } } } Observações: Algumas observações a respeito de vetores multidimensionais podem ser feitas: • Do mesmo modo que vetores unidimensionais.int max_col){ int i. c <= m-1 .&a[l][c]).. puts("Matriz original:").int max_col){ int i.. puts("\n"). também começam em 0.n. é o primeiro elemento do vetor. i <= max_lin-1 . impmtz(a. // troca: m[i][j] <-> m[j][i] matriz[i][j] = matriz[j][i]. i++){ // para todas as linhas.matriz[i][j]). c++){ printf("\na[%d][%d]: ".l+1.n).n. Por exemplo: vet[0][0].. int max_lin. 63 ..m).

......8 2..11 3....................Conjunto de caracteres.........4..............29 64 .................................7.........................................................................................7 2............................................................................................................................................4 1................7.......................ESTRUTURA DE UM PROGRAMA EM C........................................................FUNÇÕES DE BIBLIOTECA...................................................................................OPERADORES INCREMENTAIS...........1 ..............1 ..........................................................................As bibliotecas disponíveis e algumas funções interessantes..........Limites do intervalo do tipo de dado...................................................1 ............5 ......................2 ....................1.........................2 ...............3 .......................................................LINGUAGENS DE PROGRAMAÇÃO........................3......5 2.......................1 .........................................Strings.......9 2......1............1 .........................................................29 4..................................................3 ......................................................................2 ............................................................................OPERADORES DE ATRIBUIÇÃO ARITMÉTICA..7 2....................6 ...........1.....................................2 .......6 2.............................................................4 – SAÍDA NÃO FORMATADA: COUT <<....................................................................................................................3..............................................................LEITURA DE TECLADO: GETCH().....3 1...........................19 3.............................................................................................................Exemplos de códigos................................2............................2 .............................................................1 ....................................................................................3 ......3 ..............2.........................10 3OPERADORES.........3 .......................................6 2........OPERADOR DE ATRIBUIÇÃO..................1FUNDAMENTOS DA LINGUAGEM C...................................................................................................29 4..............2 ........................................5.4 ...........................LEITURA FORMATADA: SCANF().1 ......................4 1.....................................6 .................20 3.........................................1 1......................TIPOS DE DADOS...........................................................Estruturas de Controle........5 2.........................................................................5 ...................................2 .............................................................................................Operadores relacionais.....................................5..............1 ..................12 3......................13 3.......3 ..4 ..............Entrada e saída de dados..........................................................1 .....................................................OPERADOR CONDICIONAL.............................9 2........................................................2 ....2 ....................9 2..................................................................................................8 .....................7 2...............................................1..........................................................................17 3...............................................................................................................................................................................2.........................PRECEDÊNCIA ENTRE OS OPERADORES DO C................... EXPRESSÕES E FUNÇÕES..........................................................Declaração de variáveis........................................................................Regras de sintaxe....................2 .................Tipos básicos..............................3.........7 ........................................................................SAÍDA DE CARACTER INDIVIDUAL: PUTCHAR()...........................................................................1 .....Precedência de operadores.....................Constantes de ponto flutuante...................................................................1....................................................................3...........................CONSTANTES SIMBÓLICAS............2...............11 3....2 1.............16 3............................................3.....................3..............25 4............1...........22 3.........................................18 3............................................Constantes pré-definidas......................................................................................................25 4..........12 3.......................................................................................3...........................21 3................................................1...........10 3.........OPERADORES RELACIONAIS E LÓGICOS.......................Tipos modificados................................................Restrições de operandos..............................................................................................3.........................................................................................................................................................OPERADORES ARITMÉTICOS.........2 -IDENTIFICADORES..................................................................................Constantes definidas pelo programador ................................................................................................5 2..................................................................................4 .....................................Atribuição múltipla.......................................SAÍDA FORMATADA: PRINTF().................3................5 ....................2 ...............O uso de funções ...Operadores lógicos................................1 1...............................2 ..............................................................Constantes inteiras...........................4 1...2...................Inicialização de variáveis..................................................................Palavras reservadas................4 2CONSTANTES E VARIÁVEIS........................4 ......................................4 2.........................................CONSTANTES.......................................................................................................................................................................5 2........................................................... GETCHE()......................................................................................................................Linguagens de baixo e alto nível.............Histórico...................................4...............................................................................2 1......................................................6 2.13 3.............................................................................................1 1.................................................1...Declaração de variáveis.............3...................................................................................................29 4..........................................1 ......................Conversão de tipo (Casting)...............................................................Constantes strings........................Conversão de tipo.......1 ............7 .15 3............................25 4ENTRADA E SAÍDA.21 3.............................1............6 .LINGUAGEM C...............................18 3..............................Diretivas de Compilação......Conversão de tipo....................................................................7 2......................4 .................................................................................................................8 2.......................................2 1.......................................................................................3.....................................................................................................................................................................3 1........8 2...1 .................3 ...................................................................1 ........................................................................................................................................................................................28 4...........................................14 3......1 ............................Constantes caracteres.......................................2 .................................................ENTRADA NÃO FORMATADA: CIN >>..2...................................5 .................................................................6 ........................................................................................................................................................Características do C............................ENTRADA DE CARACTER INDIVIDUAL: GETCHAR()..................................................................................3 .......1 1..Comentários.4 .....2 1..............................29 4.......................................................2 ...........2.......................3.....

.........................Decisão de dois blocos (if............................else if....5 ............................. GOTO.........CASE.........................7..............................................A função exit()........................31 4.................................................47 6............3 ...............6 ......else)......................2 ...................57 7..........................CONDIÇÃO DE CONTROLE.............................................................................................Declaração e inicialização.......ESTRUTURA DE DECISÃO IF............................................................................................................Limites ...........................................................................................................................................................................................56 7...............................................................................................................................ESTRUTURA DAS FUNÇÕES DE USUÁRIO............)....... CLREOL()..................1 ..................................2 A instrução continue.......................................2 ...........................4 ...................10 ...........36 5..5................................35 5.37 5.............................3.................45 6................................37 5......................43 6..................................ELSE........................38 5.......)...............................ESTRUTURA WHILE..................61 7......................1 ..................A instrução break.................................................................................56 7....................2 .........ESTRUTURA SWITCH................................................................................................PASSANDO VETORES PARA FUNÇÕES...................................................................41 5.................................................ESCRITA FORMATADA EM CORES: CPRINTF().....................................................................................................56 7.......4 ............................................43 6...........................................................................ESTRUTURA DO..........53 6...........INTERRUPÇÃO E DESVIO: BREAK............40 5...........3 ...... NOSOUND()...............................................LIMPEZA DE TELA: CLRSCR().59 7........................................................61 7..........................32 4..................7.............................................................A instrução goto...............................4 ...............3......................................46 6................LOCALIZAÇÃO DAS FUNÇÕES.HIERARQUIA DE FUNÇÕES........7 .......................................................................................................................................................................................................................................7........5 ..........................Corpo da função antes do programa principal (no mesmo arquivo)..........................................3 ......................44 6...................................................3..............................................................56 7...............................2 .........................................................DECLARAÇÃO E INICIALIZAÇÃO DE VETORES.......................1 .... DELAY()......1 .........................................58 7..............................................................................................................Decisão de múltiplos blocos (if.....................DEFINIÇÃO DE FUNÇÕES.....................................................RECURSIVIDADE.................................................................................................................33 4........................Referência a elementos de vetor............7.................................................................................................32 4.............REDIMENCIONAMENTO DE JANELA: WINDOW()..........................................................2 .........2 .....................3......................44 6...........................5.............42 5.......................2 .......................Corpo da função escrito em arquivo separado............................VETORES MULTIDIMENSIONAIS............2.............................................................................................................3 .................42 5...........................................................................................................................................WHILE..............................................................3..................................30 4...........................................................................INTRODUÇÃO.....................Tamanho parametrizado......35 5.........3 ...............................54 7VETORES....................................11 ..................1 ...............REGRA DE ESCOPO PARA VARIÁVEIS................2 ............6 ....................................43 6FUNÇÕES.....Inicialização de vetores...............................5..................1 ....................................................................................37 5.................................ESTRUTURA FOR.......................Declaração de vetores.....................Corpo da função depois do programa principal (no mesmo arquivo)...............................1 Decisão de um bloco (if.........................35 5.................................................................................................41 5...58 7.........................44 6........................................58 7...........................TAMANHO DE UM VETOR E SEGMENTAÇÃO DE MEMÓRIA....................................33 5ESTRUTURAS DE CONTROLE............................................ EXIT()....................................................................35 5.................POSICIONAMENTO DO CURSOR: GOTOXY().............................................1 ...1 .............8 .......................................................................9 ....................................................................3 .13 .................................................................12 .....................Passagem de vetores multidimensionais para funções......57 7.................62 65 ...................................................................................5 ..............MONITORAÇÃO DE TECLADO: KBHIT()......SAÍDA SONORA: SOUND()..........................................................................................................................................2............................4.................................5.................................................... CONTINUE..................................2...................2 ...........................................................5.................................................................................4 .....

Sign up to vote on this title
UsefulNot useful