ApostilaANSI-C

Prévia do material em texto

CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Introdução ao C 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Rosângela Fátima da Silva 
Setembro – 2008 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
1 
 
ÍNDICE 
 
 
 
Introdução 
 
03 
Aula Prática 01 
� Ambiente de programação Builder C++ 
 
05 
Aula Prática 02 
� Função 
� Tipos de dados: caractere e string 
� Comandos de entrada e saída: getche, getch, gets, scanf e printf 
 
14 
Aula Prática 03 
� Palavras reservadas do C 
� Tipos de dados 
� Variáveis e constantes 
� Operadores aritméticos, lógicos, relacionais etc 
 
23 
Aula Prática 04 
� Expressões aritméticas e lógicas. 
 
37 
Aula Prática 05 
� Estruturas condicionais: if e switch 
 
46 
Aula Prática 06 
� Estruturas de repetição: for, while e do while 
 
52 
Aula Prática 07 
� Função e passagem de parâmetros por valor 
� Escopo de variáveis 
 
58 
Aula Prática 08 
� Comandos de desvio: continue, break e goto 
 
67 
Aula Prática 09 
� Dispositivos de entrada e saída (IO) 
 
74 
Aula Prática 10 
� Vetores 
 
89 
 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
2 
 
 
 
 
 
 
Aula Prática 11 
� Matrizes 
 
 
 
 
 
 
 
98 
Aula Prática 12 
� Ponteiros 
 
103 
Aula Prática 13 
� Funções e passagem de parâmetros por referência 
� Argumentos argc e argv 
 
115 
 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
3 
 
INTRODUÇÃO 
 
 
Este curso busca criar uma fundamentação mínima para aplicação da linguagem 
C em sistemas dedicados que tem como plataforma básica os microcontroladores. 
O primeiro passo é escolher uma linguagem de programação para que possamos 
determinar a aplicação que os microcontroladores exercerão. Depois estudaremos 
os microcontroladores. Então escolhemos a linguagem C, por vários motivos: 
 
 
� Possui muitos operadores e combinações de operadores facilitando a 
execução de operações aritméticas, lógicas e relacionáis; 
� Possui uma série de funções prontas que poderão ser utilizadas pelo 
programador; 
� Suporta programação modular; 
� Permite o acesso flexível a um mesmo dado com tipos distintos; 
� Utiliza ponteiros para endereçamento de área do sistema; 
� Permite operações aritméticas com ponteiros; 
� Permite que um mesmo código possa ser executado em qualquer 
computador ou sistema operacional; 
� Tem resistido às diversas mudanças no universo do software para sistemas 
de uso geral, como computadores. 
 
Além de todo o potencial descrito, a linguagem C possui um conjunto de 
operadores para manipulação de bits e permite a inserção de código e subrotinas, 
em Assembly, com passagem de parâmetros. O que facilita sobremaneira o 
desenvolvimento de sistemas dedicados tão comum no nosso contexto. Não 
podemos deixar de mensionar que os microcontroladores além de apresentar um 
alto grau de integração de memória e controle de dispositivos de I/O, estão 
trabalhando com volume de dados, permitindo, portanto o uso da linguagem C. 
 
Antes de comerçar os nossos estudos, vamos contar um porquinho de história... 
 
A linguagem C está relacionada ao desenvolvimento do sistema operacional 
UNIX. O sistema operacional tinha como objeto tornar a máquina, PDP-7 da Bell, 
algo mais accessível ao programador. Então 1969, nos Laboratórios da Bell em 
New Jersey, foi desenvolvido o sistema operacional UNIX, escrito inteiramente em 
linguagem montadora do PDP-7. Logo após o desenvolvimento do UNIX, Ken 
Thompson implementou um nova linguagem denominada B que juntamente com o 
sistema UNIX permitiram o desenvolvimento software de forma mais simples. 
Entretanto, logo após o lançamento de uma nova máquina, o PDP-11, os 
projetistas encontraram muitas dificuldades na transferência do UNIX e do B para 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
4 
mesma. Este fato foi o elemento motivador para criação de uma nova linguagem 
que permitisse transferências de software de forma mais simples. 
 
Foi então que Dennis Ritchie em 1972, no laboratório da Bell, desenvolveu a 
linguagem C. Seu grande mérito foi criar uma linguagem que oferece recursos de 
baixo nível que permite especificar cada um dos detalhes da lógica do algoritmo 
para conseguir eficiência máxima do computador. Por outro lado também oferece 
recursos de alto nível que permite ocultar os detalhes da arquitetura do 
computador tornando o hardware um pouco mais abstrato para o programador. 
 
O nosso objetivo é oferecer um caminho que lhe motive a desenvolver sistemas 
embutidos. Imaginamos que a linguagem C pode lhe ajudar nesta tarefa. Cabe a 
você, ao final deste curso, verificar se nós, professores do CEFET-MG, 
escolhemos o melhor caminho. Lembre-se VOCÊ é o nosso melhor feedback. 
 
 
 
 
Atenciosamente, 
 
 
 
Rosângela Fátima da Silva 
 
 
 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
5 
AULA PRÁTICA 01 
 
 
OBJETIVO: 
 
� Introduzir o ambiente de programação Borland C++ Builder. 
 
 
INTRODUÇÃO 
 
Para que possamos estudar uma nova linguagem de programação é fundamental 
escolher um ambiente de programação onde é possível executar os programas 
que elaboramos. Para este curso escolhemos Borland C++ Builder por ser uma 
ferramenta com recursos que facilitam consideravelmente a verificação de bugs 
em programas. Mas existem outros compiladores tais como o Microsoft Visual C++ 
e DEV-C++, sendo que esse último é um software encontrado gratuitamente na 
Internet. O primeiro passo é estudar o ambiente escolhido. 
 
 
BORLAND C++ BUILDER 
 
Para acessar o programa Borland C++ Builder clique sobre o ícone 
denominado C++ Builder 4 que está na pasta Atalhos, localizada na 
área de trabalho do seu computador, figura ao lado. 
 
O programa será aberto e você observará na Figura 1 a janela: C++ Builder 4 
Projet 1. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Figura 1 - Janela C++ Builder 4 Projet 1 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
6 
Observe a Barra de Ferramentas horizontal, nela temos vários botões: File, Edit, 
Search, View, Project, Rum, Component, Database, Tools e Help. Clique no botão 
File e escolha a opção New mostrada na Figura 2 a seguir: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Figura 2 - Opções da aba File 
 
Aparecerá a janela de Novos Itens (New Itens), escolha o item Console Wizard e 
clique no botão OK, Figura 3. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Figura 3 - Janela New Otems 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
7 
Em seguida observe a janela de Ajuda para Aplicações do Console, Figura 4. 
Como as opçõesexistentes nesta janela correspondem às opções desejadas, 
clique no botão Finish. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Figura 4 - janela de Ajuda para Aplicações do Console 
 
A nova janela é o Editor de texto do Builder, local onde você deverá digitar o seu 
programa. Ela sempre será apresentada com o esqueleto de um programa. Veja 
Figura 5: 
Figura 5 - Editor de texto do Builder 
 
Você pode aproveitá-lo, inserindo o seu programa que neste caso é o código 
apresentado a seguir: 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
8 
#include <stdio.h> 
#include <stdlib.h> 
 
/***************************************************************************** 
Programa 01 
Este programa imprime na tela a seguinte frase: 
Botafogo Campeão 
 
******************************************************************************/ 
int main () 
{ 
 printf ("Botafogo Campeão\n\n"); 
 system(“pause”); 
 return 0; 
 } 
 
Não se esqueça de salvar o seu programa. O primeiro passo é criar uma nova 
pasta com o seu nome no diretório C:\Temp. Em seguida vá à Barra de 
Ferramentas Horizontal, clique no botão File e escolha a opção Salve As.... 
Aparecerá a janela Save Project1 As, Figura 6. Localize a sua pasta e na caixa 
denominada Nome do Arquivo digite o nome escolhido, exemplo: Exercicio01. 
Não coloque a extensão. 
 
 
 
 
 
 
 
 
 
 
 
Figura 6 - Janela para salvar o projeto 
 
A pasta escolhida para salvar o Exercicio01 foi LucasDeAquino. A sua pasta tem o 
seu nome, ela deve guardar todos os seus programas. 
 
O programa que acabamos de digitar e salvar é um arquivo do tipo texto. Em 
outras palavras, ele não pode ser executado. Temos que compilar, montar e 
linkeditar para que possamos fazê-lo: 
 
1. Compilar é o processo de verificação dos erros de sintaxe, ou seja, o 
compilador verificará se você digitou alguma instrução incorretamente ou deixou 
de declarar alguma informação fundamental para a execução do programa. Para 
compilar vá à Barra de Ferramentas Horizontal e clique sobre o botão Project, 
aparecerá uma janela com várias opções, escolha a opção Compile Unit e clique 
sobre ele, veja Figura 7. 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
9 
 
Figura 7 - Opções da aba Project 
 
A próxima janela, Compiling é um relatório simplificado a respeito do seu 
programa. Observe que nesta janela, mostrada na Figura 8, está a localização e o 
nome do programa, a ação que acabou de ser executado: “Compilação”. Além de 
constar o número total de linhas do programa, os warnings e o número de erros 
contidos no seu programa. Os warnings são avisos, isto é, previnem o 
programador a respeito de possíveis problemas. Você consegue rodar o seu 
programa caso eles existam, mas pode ocorrer alguma inconsistência. Os erros 
têm que ser corrigidos, caso contrário o seu programa NÃO será executado. Se 
tudo ocorreu conforme o esperado, isto é, sem erros, clique no botão OK para 
continuar, se não tente descobrir os erros indicados. Caso você não consiga, 
espere um pouquinho até que possamos resolver o seu problema. 
 
 
 
 
 
 
 
 
 
Figura 8 - Relatório de Compilação do programa 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
10 
 
Erros poderão ocorrer durante a execução dos nossos programas. O compilador 
detecta e envia uma mensagem identificando o erro ocorrido, veja a Figura 9 a 
seguir: 
 
 
 
 
 
 
 
 
 
Figura 9 - Erro de Compilação 
 
Verificamos através do relatório apresentado na janela Compiling que ocorreu um 
erro, para identificá-lo clique no botão OK. Imediatamente, será apresentada a 
janela com o programa corrente, aparecendo em destaque a linha onde houve a 
ocorrência do erro e uma mensagem identificando o tipo do erro, veja Figura 10 a 
seguir: 
 
Figura 10 - Identificação do erro de compilação 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
11 
Neste caso a mensagem de erro relata que o compilador está esperando o ponto 
e vírgula após a instrução return 0. 
 
2. Montar é traduzir o texto digitado em linguagem de máquina, gerando um 
arquivo objeto. Para montar o seu programa vá à Barra de Ferramentas Horizontal 
e clique sobre o botão Project, e em seguida na opção Make Exercicio01 (Make 
<Nome_do_programa>). Um novo relatório aparecerá na tela, mas desta vez a 
atividade executada é a Montagem, verifique na Figura 11 a seguir. 
 
 
 
 
 
 
 
 
 
 
Figura 11 - Relatório da montagem do programa 
 
3. A linkedição só pode ser executada se NÃO houver erros na montagem, caso 
contrário eles têm que ser resolvidos. Linkeditar consiste em inserir no código 
objeto informações relativas ao sistema operacional. Alguns programas são 
construídos em módulos distintos. Esses módulos têm que ser ligados formando 
um único projeto através da linkedição. A linkedição gera um arquivo executável 
do programa. Como o próprio nome indica é o arquivo que o computador 
executará. 
 
Para linkeditar o seu programa vá à Barra de Ferramentas Horizontal e clique 
sobre o botão Project, e em seguida na opção Build Exercicio01 (Build 
<Nome_do_programa>). Se tudo ocorrer bem, logo em seguida será apresentada 
a janela mostrada na Figura 12: 
 
 
 
 
 
 
 
 
 
 
Figura 12 - Relatório de linkedição do programa 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
12 
Agora que seu arquivo executável está pronto basta rodar o programa. Vá à Barra 
de Ferramentas Horizontal e clique sobre o botão Run, aparecerá uma janela com 
várias opções, escolha a opção Run e clique sobre ela. Será impresso no Console 
a frase “Botafogo Campeão” e também a mensagem “Pressione qualquer tecla 
para continuar...”. Veja Figura 13: 
Figura 13 - Console apresentando o resultado do programa 
Agora que já sabemos como editar, compilar, montar e linkeditar um programa em 
C , vamos entender o que o programa faz: 
 
 
ANÁLISE DO PROGRAMA 
 As linhas #include <stdio.h> e #include <stdlib.h> diz ao compilador que ele 
deve incluir o arquivo de cabeçalho stdio.h e stdlib.h. Os arquivos do tipo 
cabeçalho contêm informações que o compilador precisa para construir o 
programa executável. Os arquivos incluem as funções printf e system, 
respectivamente, que por serem muito utilizadas estão contidas em bibliotecas. 
 Quando fazemos um programa, uma boa idéia é usar comentários que ajudem a 
elucidar o funcionamento do mesmo. No programa anterior temos um comentário: 
/* Programa 01 ...*/. O compilador C desconsidera qualquer coisa que esteja 
começando com /* e terminando com */. Um comentário pode, inclusive, ter mais 
de uma linha. 
 A linha int main() indica que estamos definindo uma função de nome main. 
Todos os programas em C têm que ter uma função main, pois é primeira função 
que será chamada quando o programa for executado. O conteúdo da função é 
delimitado por chaves { }. O código que estiver dentro das chaves será executado 
seqüencialmente quando a função for chamada. A palavra int indica a função main 
retorna um inteiro. Tanto que a última linha do programa, “return(0);”, indica qual o 
número inteiro está sendo retornado pela função, que no caso é o númerozero. 
 Esse programa chama a função printf(), passando a string "Botafogo 
Campeão\n" como argumento. É por causa do uso da função printf() pelo 
programa que devemos incluir o arquivo-cabeçalho stdio.h. A função printf() 
neste caso irá apenas colocar a string na tela do computador. 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
13 
A função system(“pause”); como o próprio nome diz interrompe o sistema e exibe 
na tela a mensagem “Pressione qualquer tecla para continuar...” , obrigando o 
usuário a seguir a instrução especificada na mensagem para prosseguir. Essa 
função está definida no arquivo cabeçalho stdlib.h. 
 
 
ATIVIDADES 
 
1.1 Execute o programa apresentado a seguir e descreva o seu funcionamento: 
 
#include <stdio.h> 
#include <stdlib.h> 
 
/***************************************************************************** 
Programa 02 
Este programa. 
 
******************************************************************************/ 
 
int main () 
 
{ 
 int Anos, Meses; /*Declaracao de variáveis*/ 
 float Dias; 
 printf ("Quantos anos voce tem?\n\n"); /*Entrada de Dados*/ 
 printf ("\n"); 
 scanf ("%d",&Anos); 
 Meses = Anos * 12; /*Conversao Anos -> Meses*/ 
 Dias = Anos * 365.25; /*Conversao Anos -> Dias*/ 
 
 printf ("\n\nVoce ja viveu %d em meses e %f em dias.\n",Meses,Dias); 
 system(“pause”); 
 return 0; 
} 
 
Dica:Dica:Dica:Dica: 
 
� Se você não entendeu algum detalhe do programa, leia o guia de Aula 
Prática 2. 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
14 
 
AULA PRÁTICA 02 
 
 
OBJETIVO: 
 
� Estudar função em C. 
� Estudar os seguintes tipos de dados: caractere e string. 
� Estudar comandos de entrada e saída: getche, getch, gets, scanf e printf. 
 
 
 
INTRODUÇÃO 
 
Todos nós já sabemos o que é uma função e também o que é uma variável. Só 
não foi possível perceber, a princípio, que main é uma função e que int é um tipo 
de variável pois a sintaxe da linguagem C é diferente da linguagem Pascal. 
 
Nesta aula estudaremos alguns tipos de dados em C, como o caractere e a string. 
Em Pascal aprendemos os tipo integer e real que são tipos numéricos 
semelhantes aos tipos int e float existentes em C. Além disto, estudaremos alguns 
comandos de entrada e saída. No fundo veremos que a sintaxe varia, mas os 
conceitos são os mesmos. Afinal, comprovamos através dos dois programas 
executados na aula anterior que função e variável possuem a mesma definição 
nas duas linguagens, não é mesmo? 
 
 
FUNÇÃO EM C 
 
A unidade fundamental da linguagem C é a função. Um programa pode possuir 
várias funções, mas obrigatoriamente possui a função main. A função main 
estabelece o início e o final do programa, main significa principal. Quando é 
definida uma função obrigatoriamente é definido o seu tipo, ou seja, o valor que a 
função retorna. O tipo da função está declarado antes do nome da mesma. Após o 
nome da função estão definidos os parâmetros, eles estão entre parênteses e 
separados por virgulas. As chaves delimitam o início e o fim da função, ou seja, o 
corpo da função. Elas substituem o Begin e o End do PascaL, lembra-se? 
 
Atenção:Atenção:Atenção:Atenção: 
 
� O nome da função principal deve ser escrito com letras minúsculas: main. 
� A linguagem C é case sensitive. Isto é considera letras minúsculas e letras 
maiúsculas diferentes, portanto Main, MAIN e main são palavras distintas. 
 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
15 
 
A sintaxe de uma função em C é a seguinte: 
 
<Tipo_da_função> <Nome_da_função> ( <Parâmetro_1>, <parâmetro_2> ... , 
 <parâmetro_N>) 
{ 
 <Comando_em _C>; 
 <Comando_em _C>; 
 ....................... 
 <Comando_em _C>; 
} 
 
 
CARACTERES 
Os caracteres são um tipo de dado: char. O C trata os caracteres ('a', 'b', etc ...) 
como sendo variáveis de um byte (8 bits). Os inteiros (ints) têm um número maior 
de bytes. Dependendo da implementação do compilador, eles podem ter 2 bytes 
(16 bits) ou 4 bytes (32 bits). Char pode também ser usado para armazenar 
valores numéricos inteiros, desde que eles ocupem um byte. Você se lembra do 
código ASCII (Código Padrão Americano para Troca de Informações)? Em ASCII 
cada caractere corresponde a um código de oito bits. Para indicar um caractere de 
texto usamos apóstrofes. Veja um exemplo de programa que usa caractere: 
#include <stdio.h> 
#include <stdlib.h> 
 
/***************************************************************************** 
Programa 03 
Este programa imprime na tela um caractere e o código ASCII 
correspondente ao mesmo. 
 
******************************************************************************/ 
int main () 
{ 
 char Ch; 
 Ch='A'; 
 printf ("O caractere %c corresponde ao numero %d em ASCII.",Ch, Ch); 
 printf("\n\n"); 
 system(“pause”); 
 return(0); 
} 
 
Na realidade sabemos que o valor de uma variável só pode ser armazenado no 
computador em números binários (zeros e uns), então o tipo de dado impresso na tela 
dependerá do tipo estabelecido pelo programador. Estabelecendo-se %c é impresso 
um caractere e %d é impresso um número inteiro. 
 
Muitas vezes queremos ler um caractere fornecido pelo usuário. Para isto 
podemos utilizar a função scanf(), empregada no Programa 02, lembra-se? Ou 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
16 
então usamos as funções getch() e getche(), quando estamos trabalhando em 
ambiente DOS ou Windows. Ambas retornam o caractere pressionado. getche() 
imprime o caractere na tela antes de retorná-lo e getch() apenas retorna o 
caractere pressionado sem imprimi-lo na tela. Ambas as funções podem ser 
encontradas no arquivo de cabeçalho conio.h. Geralmente estas funções não 
estão disponíveis em ambiente Unix (compiladores cc e gcc), pois não fazem 
parte do padrão ANSI. Neste caso elas podem ser substituídas pela função 
scanf(), porém sem as mesmas funcionalidades. Eis um exemplo que usa a 
função getch(). 
 
#include <conio.h> 
#include <stdio.h> 
#include <stdlib.h> 
 
/***************************************************************************** 
Programa 04 
Este programa usa a função getch() para ler um caractere 
que foi introduzido através do teclado pelo usuário. 
Esta função requer o arquivo cabeçalho conio.h 
 
******************************************************************************/ 
int main () 
{ 
 char Ch; 
 printf ("Pressione uma tecla.\n"); 
 Ch= (char)getch(); 
 printf ("Voce pressionou a tecla %c.\n\n",Ch); 
 system("pause"); 
 return(0); 
} 
 
 
STRINGS 
Uma string é um conjunto de caracteres. Para armazenar um caractere utilizamos 
um espaço de memória de 8 bits. Se quisermos armazenar uma string com quatro 
caracteres é necessário utilizar um vetor, ou seja, quatro espaços de memória de 
8 bits. No C uma string é um vetor de caracteres terminado com um caractere 
nulo. O caractere nulo é um caractere com valor inteiro igual a zero (código ASCII 
igual a 0). O terminador nulo também pode ser escrito usando a convenção de 
barra invertidado C como sendo '\0'. 
Atenção:Atenção:Atenção:Atenção: 
 
� O algarismo zero em código ASCII é igual a 30H. 
 A declaração de uma string possui o seguinte formato geral: 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
17 
char nome_da_string[tamanho]; 
Nessa declaração temos um vetor de caracteres (uma string) com número de 
posições igual a tamanho. O tamanho do vetor é no mínimo um caractere maior 
que a maior string que pretendemos armazenar, uma vez que temos que incluir o 
caractere terminador. Imagine uma string de 7 posições onde foi armazenada 
CEFET: 
C E F E T \0 ... 
No caso acima, a células não usada têm valor indeterminado. Isto acontece 
porque o C não inicializa variáveis, cabendo ao programador esta tarefa. Portanto 
as únicas células inicializadas são as que contêm os caracteres 'C', 'E', 'F', 'E', 'T' e 
'\0' . 
Se quisermos ler uma string fornecida pelo usuário através do teclado, podemos 
usar a função gets(). Um exemplo do uso desta função é apresentado abaixo. A 
função gets() coloca o terminador nulo na string, quando você aperta a tecla 
"Enter". A função gets() está definida no arquivo de cabeçalho stdio.h. 
#include <stdio.h> 
#include <stdlib.h> 
 
/***************************************************************************** 
Programa 05 
Este programa usa a função gets() para ler uma string introduzida 
pelo teclado.Esta função requer o arquivo de cabeçalho stdio.h. 
 
******************************************************************************/ 
int main () 
{ 
 char string[50]; 
 printf ("Digite uma string:\n\n"); 
 gets (string); 
 printf ("\n\nVoce digitou a seguinte string: %s",string); 
 printf ("\n\n"); 
 system("pause"); 
 return(0); 
} 
Neste programa, o tamanho máximo da string que você pode digitar é uma string 
de 49 caracteres. Se você introduzir uma string de comprimento maior, o 
programa irá aceitar, mas os resultados podem ser desastrosos. Veremos porque 
posteriormente. 
Como as strings são vetores de caracteres, para se acessar um determinado 
caractere de uma string, basta "indexa-lo", ou seja, usarmos um índice para 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
18 
acessarmos o caractere desejado dentro da string. Suponha uma string chamada 
frase. Podemos acessar a segunda letra da string da seguinte forma: 
frase[1] = 'k'; 
É interessante observar que na linguagem C, o índice começa em zero. Assim, a 
primeira letra da string sempre estará na posição 0. A segunda letra sempre estará 
na posição 1 e assim sucessivamente. No exemplo a seguir o programa imprimirá 
a segunda letra da string "CEFET". Em seguida, mudará a letra mencionada e 
apresentará a string modificada no final. 
#include <stdio.h> 
#include <stdlib.h> 
 
/***************************************************************************** 
 Programa 06 
Este programa imprime: a string CEFET; 
* A segunda letra da string CEFET: E; 
* O novo caractere que substitui a segunda letra: A; 
* A string modificada: CAFET. 
 
******************************************************************************/ 
int main() 
{ 
 char frase[10] = "CEFET"; 
 printf("String: %s", frase); 
 printf("\n\nSegunda letra: %c", frase[1]); 
 frase[1] = 'A'; 
 printf("\n\nA segunda letra foi mudada para: %c", frase[1]); 
 printf("\n\nString resultante: %s", frase); 
 printf("\n\n"); 
 system("pause"); 
 return(0); 
} 
Observe que na string CEFET, o terminador nulo está na posição 5 e nas posições 
de 0 a 4 estão os caracteres válidos. Portanto podemos escrevê-los. Note a forma 
como inicializamos a string frase com os caracteres 'C' 'E' 'F' 'E' 'T' e '\0' 
simplesmente declarando char frase[10] = "CEFET". Veremos, posteriormente que 
" CEFET " (uma cadeia de caracteres entre aspas) é o que chamamos de string 
constante, isto é, uma cadeia de caracteres que está pré-carregada com valores 
que não podem ser modificados. Já a string frase é uma string variável, pois 
podemos modificar o que está armazenado nela. Como de fato acabamos de 
fazer. 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
19 
 
No programa anterior, %s indica que printf() deve colocar uma string na tela. 
Vamos agora fazer uma abordagem inicial às duas funções que já temos usado 
para fazer a entrada e saída de dados. 
Printf() 
A função printf() tem a seguinte forma geral: 
printf(<string_de_controle>, <Argumento_1>, <Argumento_2> ...<Argumento_N>); 
A função printf() pode ter um ou mais parâmetros, separados por vírgulas. O 
primeiro parâmetro é a string de controle, escrita entre aspas, e corresponde à 
seqüência de caracteres que será exibida pelo programa. Essa seqüência de 
caracteres pode conter alguns especificadores de formato que começam com a 
seguinte notação: %. Estes especificadores de formato indicam em quais posições 
da string de controle estão as variáveis a serem apresentadas e o tipo das 
mesmas. O segundo parâmetro é a lista de argumentos. É muito importante que 
você observe que para cada especificador de formato existe um argumento na 
lista de argumentos. Dê uma olhadinha no exemplo a seguir: 
 
 Argumento 
 
Printf ("\nAgora a segunda letra é: %c ", frase[1]); 
 
 Especificador de formato 
Neste caso, o especificador de formato é uma variável do tipo char e o argumento 
é a segunda posição do vetor frase. 
Não sei se vocês observaram, mas nas strings de controle apresentadas existe 
um caractere que nunca foi exibido no console. Ele é o caractere (invisível) de 
nova linha (\n) que provoca um salto para a próxima linha onde será impressa a 
nova mensagem. Existem outros caracteres semelhantes que apresentam barra 
invertida e são chamados constantes de barra invertida. 
 
Um especificador de formato começa sempre com o símbolo %, em seguida pode 
apresentar uma letra que indica o tipo de valor a ser exibido. Veja Tabela 1 a 
seguir. 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
20 
 
Tabela 1 - Especificadores de formato da função printf(). 
Caractere Propósito 
%c Exibir um caractere 
%d Exibir um valor inteiro com sinal 
%i Exibir um valor inteiro com sinal 
%e Exibir um valor em notação científica com “e” minúsculo 
%E Exibir um valor em notação científica com “E” maiúsculo 
%f Exibir um valor em ponto flutuante 
%g Exibir um valor de ponto flutuante em formato %f ou %e 
(formato mais significativo para exibir o valor). 
%G Exibir um valor de ponto flutuante em formato %F ou %E 
(formato mais significativo para exibir o valor). 
%o Exibir um valor em notação octal 
%s Exibir uma string de caracteres 
%u Exibir um valor inteiro sem sinal 
%x Exibir um valor hexadecimal sem sinal (letras minúsculas) 
%X Exibir um valor hexadecimal sem sinal (letras maiúsculas) 
%p Exibir o endereço de uma variável (ponteiro) 
%n O argumento associado é um ponteiro para inteiro no qual 
o número de caracteres escritos até esse ponto é colocado 
%% Exibir o símbolo % 
 
 
Scanf() 
O formato geral dafunção scanf() é: 
scanf(<string_de_controle>, <lista_de_argumentos>); 
Usando a função scanf() podemos pedir dados ao usuário. Um exemplo pode ser 
visto no Programa 02. Mais uma vez devemos ficar atentos não esquecendo de 
colocar o mesmo número de especificadores de formato e de argumentos. Outra 
coisa importante é lembrarmos de colocar o & antes das variáveis da lista de 
argumentos. É impossível justificar isto agora, mas veremos a razão para este 
procediemtno. 
 
 
ATIVIDADES 
 
2.1 Execute o Programa 04 e verifique o seu funcionamento. 
 
2.2 Execute o programa a seguir: 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
21 
 
#include <conio.h> 
#include <stdio.h> 
#include <stdlib.h> 
 
/***************************************************************************** 
Programa 07 
Este programa usa a função getche() para ler um caractere 
introduzido pelo teclado. Esta função requer o arquivo de 
cabeçalho conio.h. 
 
******************************************************************************/ 
int main () 
{ 
 char Ch; 
 printf ("Pressione uma tecla.\n\n"); 
 Ch= (char)getche(); 
 printf ("\n\n"); 
 system("pause"); 
 return(0); 
} 
 
2.3 Foi necessário mandar imprimir no console o caractere lido? Explique a 
diferença entre a função getch() e a função getche(). 
 
2.4 Troque a linha de programa “Ch= getche();” por “scanf("%c", &Ch);” no 
Programa 7 e descreva a diferença. 
 
 
Dica:Dica:Dica:Dica: 
 
� A função getche() permite que você digite mais de um caractere? 
� É necessária acionar a tecla Enter após ter sido digitado o caractere 
desejado usando a função getche()? 
� O que aconteceria se você digitasse um número com vários caracteres 
usando a função scanf()? 
� Se fosse necessário introduzir no seu programa um número inteiro, 
exemplo 123, e tivesse sido usado a função getch(), O que seria 
armazenado em uma variável tipo char? 
 
2.5 Execute os Programa 05 e Programa 06 e verifique o seu funcionamento. 
 
2.6 Escreva o que será impresso pelas seguintes linhas de programa e depois crie 
um programa para testá-los. Verifique se suas previsões estão corretas. 
 printf ("Teste %% %%") 
 printf ("%f",40.345”) 
 printf ("Um caractere %c e um inteiro %d.",'F',240) 
 printf ("%s e um exemplo:","Este") 
 printf ("%s%d%%.","Juros de ",10) 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
22 
 
2.7 Escreva um programa que leia duas strings, imprima as duas strings e a 
terceira letra de cada uma delas. 
 
2.8 Escreva um programa que leia o seu nome e a sua idade e apresente o 
seguinte relatório: 
 
O meu nome é __________________________, tenho _______ anos. 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
23 
 
AULA PRÁTICA 03 
 
 
OBJETIVO: 
 
� Conhecer as palavras reservadas do C. 
� Estudar as variáveis e constantes. 
� Estudar os operadores aritméticos, lógicos e operadores relacionais etc. 
 
 
INTRODUÇÃO 
 
Variáveis, constantes, operadores aritméticos e lógicos nós já estudamos na aula 
teórica. Neste guia de aula prático serão expostos alguns detalhes importantes e 
tabelas que possam ajudá-lo, maiores esclarecimentos consulte a sua apostila de 
teoria. 
 
 
PALAVRAS RESERVADAS DO C 
Todas as linguagens de programação têm palavras reservadas. As palavras 
reservadas não podem ser usadas a não ser nos seus propósitos originais, isto é, 
não podemos declarar funções ou variáveis com os mesmos nomes. Como o C é 
"case sensitive" podemos declarar uma variável For, apesar de haver uma palavra 
reservada for, mas isto não é uma coisa recomendável de se fazer pois pode 
gerar confusão. 
 Apresentamos a seguir, na Tabela 2, as palavras reservadas do ANSI C. 
Veremos o significado destas palavras chave à medida que o curso for 
progredindo: 
Tabela 2 - Palavras reservadas da linguagem C. 
auto 
break 
case 
char 
const 
continue 
default 
do 
double 
else 
enum 
extern 
float 
for 
goto 
if 
int 
long 
register 
return 
short 
signed 
sizeof 
static 
struct 
switch 
typedef 
union 
unsigned 
void 
volatile 
while 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
24 
NOMES DE VARIÁVEIS 
As variáveis no C podem ter qualquer nome se duas condições forem satisfeitas: o 
nome deve começar com uma letra ou sublinhado (_) e os caracteres 
subsequentes devem ser letras, números ou sublinhado (_). Há apenas mais duas 
restrições: o nome de uma variável não pode ser igual a uma palavra reservada, 
nem igual ao nome de uma função declarada pelo programador, ou pelas 
bibliotecas do C. Variáveis de até 32 caracteres são aceitas. Mais uma coisa: é 
bom sempre lembrar que o C é "case sensitive" e portanto deve-se prestar 
atenção às letras maiúsculas e minúsculas. 
Dica:Dica:Dica:Dica: 
 
� É uma prática tradicional do C, usar letras minúsculas para nomes de 
variáveis e maiúsculas para nomes de constantes. Isto facilita na hora da 
leitura do código; 
� Quando se escreve código usando nomes de variáveis em português, 
evita-se possíveis conflitos com nomes de rotinas encontrados nas 
diversas bibliotecas, que são em sua maioria absoluta, palavras em 
inglês. 
 
 
TIPOS DE DADOS 
 
O C tem cinco tipos básicos, veja a definição de cada um deles na Tabela 3 a 
seguir: 
 
Tabela 3 - Tipos de dados 
Tipo Nº bits Faixa de valores Característica 
char 8 -128 a 127 Inteiro 
int 32 -32768 a 32767 Inteiro 
float 32 3.4x10-38 a 3.4x1038 Ponto Flutuante 
double 64 1.7x10-308 a 1.7x10308 Ponto Flutuante 
 
 
O quinto tipo é o tipo void, representa valores que não ocupam lugar na memória, 
isto é, é o tipo vazio. A aplicação desse "tipo" será vista posteriormente. 
 
 É importante mencionar que o tipo int normalmente tem o valor natural de uma 
determinada máquina. 
 
O C tem quatro modificadores de tipo que são: signed, unsigned, long e short. 
Eles estão relacionados aos tipos de dados de acordo com a Tabela 4, a seguir: 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
25 
Tabela 4 - Modificadores de tipo 
Intervalo 
Tipo Num de bits 
Formato para 
leitura com 
scanf Inicio Fim 
char 8 %c -128 127 
unsigned char 8 %c 0 255 
signed char 8 %c -128 127 
int 32 %i -2.147.483.648 2.147.483.647 
unsigned int 32 %u 0 4.294.967.295 
signed int 32 %i -2.147.483.648 2.147.483.648 
short int 16 %hi -32.768 32.767 
unsigned short int 16 %uh 0 65535 
signed short int 16 %hi -32.768 32.767 
long int 32 %li -2.147.483.648 2.147.483.647 
signed long int 32 %li -2.147.483.648 2.147.483.647 
unsigned long int 32 %lu 0 4.294.967.295 
float 32 %f 3,4E-38 3.4E+38 
double 64 %lf 1,7E-308 1,7E+308 
long double 80 %Lf 3,4E-4932 3,4E+4932 
 
 
VARIÁVEIS 
 
Variável é um espaço de memória destinado a guardar um determinado tipo de 
dado. Cada linguagem de programação define os seus próprios tipos de dados, 
portanto possuem tamanho e formato distintos. 
As variáveis no C devem ser declaradas antes de serem usadas. A forma geral da 
declaração de variáveis é: 
tipo_da_variável <variável_1>, <variavela_2> ....<variável_N>; 
As e-nésimas variáveis listadasna declaração subseqüente são todas do mesmo 
tipo e deverão ser separadas por vírgula. Como o tipo default do C é o int, quando 
vamos declarar variáveis int com algum dos modificadores de tipo, basta colocar o 
nome do modificador de tipo. Assim um long basta para declarar um long int. 
Por exemplo, observe as seguintes declarações: 
 char letra; 
 long contador, somatória; 
 float pi; 
Observamos uma variável do tipo char (letra), duas variáveis long int (contador e 
somatória) e uma variável float, pi. 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
26 
Podemos inicializar variáveis no momento de sua declaração, basta seguir a forma 
geral, apresentada a seguir: 
tipo_da_variável nome_da_variável = constante; 
Isto é importante pois quando o C cria uma variável ele não a inicializa. Isto 
significa que até que um primeiro valor seja atribuído à nova variável ela tem um 
valor indefinido e não pode ser utilizado para nada. Nunca presuma que uma 
variável declarada vale zero ou qualquer outro valor. Exemplos de inicialização 
são dados a seguir: 
 char ch='D'; 
 int count=0; 
 float pi=3.141; 
Ressalte-se novamente que, em C, uma variável tem que ser declarada no início 
de um bloco de código. Assim, o programa a seguir não é válido em C (embora 
seja válido em C++). 
/***************************************************************************** 
int main() 
{ 
 int i; 
 int j; 
 j = 10; 
 int k = 20; /* Esta declaração de variável não é válida, pois 
 não está sendo feita no início do bloco */ 
 return(0); 
} 
 
/***************************************************************************** 
 
 
CONSTANTES 
Constantes são valores que são mantidos fixos pelo compilador. Podemos 
declarar constantes criando uma “variável” com o modificador const ou utilizando 
a diretiva define, exemplo: 
const int MIN=1, MAX=1000; 
const float JUROS=0.37; 
 
#define PI 3.1415 
São consideradas constantes: 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
27 
 
1. Constantes dos tipos básicos 
Tabela 5 - Constantes dos tipos básicas 
Tipos de dados Exemplos de Constantes 
char 'b' '\n' '\0' 
int 2 32000 -130 
long int 100000 -467 
short int 100 -30 
unsigned int 50000 35678 
float 0.0 23.7 -12.3e-10 
double 12546354334.0 -0.0000034236556 
 
2. Constantes hexadecimais e octais 
As constantes hexadecimais começam com 0x e as constantes octais começam 
com 0, exemplo: 
Tabela 6 - Constantes hexadecimais e octais 
Tipos de dados Exemplos de Constantes 
Hexadecimais 0xEF 0x12A4 
Octais 03212 0705614 
 
Atenção:Atenção:Atenção:Atenção: 
� Na linguagem C 013 é diferente de 13!!!. 
3. Constantes strings 
A string "CEFET" é na realidade uma constante string. Isto implica, por exemplo, 
que 't' é diferente de "t", pois 't' é um caractere enquanto que "t" é uma 
constante string com dois caracteres onde o primeiro é 't' e o segundo é '\0'. 
4. Constantes de barra invertida 
O C utiliza, para nos facilitar a tarefa de programar, vários códigos chamados 
códigos de barra invertida. Estes são caracteres que podem ser usados como 
qualquer outro. Uma lista com alguns dos códigos de barra invertida é dada a 
seguir 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
28 
Tabela 7 - Códigos de barra invertida 
Código Significado 
\b Retrocesso ("back") 
\f Alimentação de formulário ("form feed") 
\n Nova linha ("new line") 
\t Tabulação horizontal ("tab") 
\" Aspas 
\' Apóstrofo 
\0 Nulo (0 em decimal) 
\\ Barra invertida 
\v Tabulação vertical 
\a Sinal sonoro ("beep") 
\N Constante octal (N é o valor da constante) 
\xN Constante hexadecimal (N é o valor da constante) 
 
 
OPERADORES 
 
A linguagem C é rica em operadores. Através deles podemos executar operações 
aritméticas, lógicas, de deslocamento, de comparação e de avaliação de dados. A 
seguir serão apresentados os operadores em C: 
 
1. Operadores Aritméticos 
 
São usados para desenvolver operações matemáticas, eles são: 
 
Tabela 8 - Operadores Aritméticos 
Operador Ação 
+ Soma (inteira e ponto flutuante) 
- Subtração ou Troca de sinal (inteira e ponto flutuante) 
* Multiplicação (inteira e ponto flutuante) 
/ Divisão (inteira e ponto flutuante) 
% Resto de divisão (de inteiros) 
++ Incremento (inteiro e ponto flutuante) 
-- Decremento (inteiro e ponto flutuante) 
 
A linguagem de programação C possui operadores unários e binários. Os unários 
agem sobre uma variável apenas, modificando ou não o seu valor, e retornam o 
valor final da variável. Os binários usam duas variáveis e retornam um terceiro 
valor, sem alterar as variáveis originais. A soma é um operador binário pois pega 
duas variáveis, soma seus valores, sem alterar as variáveis, e retorna esta soma. 
Outros operadores binários são os operadores - (subtração), *, / e %. O operador 
“-“,como troca de sinal é um operador unário que não altera a variável sobre a 
qual é aplicado, pois ele retorna o valor da variável multiplicado por -1. 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
29 
 
O operador “/” (divisão) quando aplicado a variáveis inteiras, nos fornece o 
resultado inteiro. Quando aplicado a variáveis em ponto flutuante nos fornece o 
resultado "real". O operador % fornece o resto (inteiro) da divisão entre dois 
inteiros. Observe o programa a seguir: 
#include <stdio.h> 
#include <stdlib.h> 
 
/***************************************************************************** 
Programa 08 
Este programa executa algumas operações aritméticas. 
 
******************************************************************************/ 
int main () 
{ 
int a = 21, b = 4; 
int int1, int2; 
 float z = 21.0, ft1, ft2; 
 int1 = a/b; 
ft1 = a/b; 
ft2 = z/b; 
int2 = a%b; 
printf("A divisao entre operandos inteiros (21/4) e' um inteiro: \"%d\".\n\n", int1); 
 printf("Se um numero inteiro for atribuído a uma variavel do tipo\n"); 
 printf("float, o resultado e' um float: \"%.1f\". \n\n", ft1); 
 printf("Se houver pelo menos um operando float (21.0/4),\n"); 
 printf("o resultado da divisao e' um float: \"%.1f\".\n\n", ft2); 
 printf("O resto da divisao entre inteiros (21/4) e' um inteiro: \"%d\".\n\n", int2); 
system("pause"); 
return(0); 
} 
 
Os operadores de incremento e decremento são unários que alteram a variável 
sobre a qual estão aplicados. O que eles fazem é incrementar ou decrementar a 
variável sobre a qual estão aplicados: 
 
 x++ ou ++x equivalem a x = x +1 
 x- - ou - - x equivalem a x = x - 1 
Esses operadores podem ser pós ou pré-fixados. A diferença é que quando são 
pré-fixados eles incrementam e retornam o valor da variável já incrementada. 
Quando são pós-fixados eles retornam o valor da variável sem o incremento e 
depois incrementam a variável. 
#include <stdio.h> 
#include <stdlib.h> 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
30 
/***************************************************************************** 
Programa 09 
Este programa testa os operadores unários incremento e decremento. 
 
******************************************************************************/int main () 
{ 
int x = 7, z = 5, y; 
printf("Sendo x igual a: \"%d\".\n", x); 
y = x++; 
printf("O resultado da expressao y = x++ e’: \"%d\" e o valor de x e’: \"%d\"\n\n", y, x); 
printf("Sendo z igual a: \"%d\".\n", z); 
 y = --z; 
printf("O resultado da expressao y = --z e’: \"%d\" e o valor de z e’: \"%d\"\n\n", y, z); 
system("pause"); 
return(0); 
} 
2. Operador de Atribuição 
O operador de atribuição da linguagem C é “=”. Ele armazena o valor à direita na 
variável à esquerda. Além disso, ele retorna o valor que ele atribuiu. Isso faz com 
que as seguintes expressões sejam válidas: 
 x = y = z = 1.5; /*Expressão 1*/ 
 if(k = w) /*Expressão 2*/ 
A expressão 1 é válida, pois quando fazemos z=1.5 ela retorna 1.5, que é passado 
adiante, fazendo y = 1.5 e posteriormente x = 1.5. A expressão 2 será verdadeira 
se w for diferente de zero, pois este será o valor retornado por k=w. Pense bem 
antes de usar a expressão 2, pois ela pode gerar erros de interpretação. Você não 
está comparando k e w. Você está atribuindo o valor de w a k e usando este valor 
para tomar a decisão. 
3. Operadores Lógicos Bit a Bit 
Permitem a execução de operações lógicas "bit-a- bit" entre os operandos. 
Tabela 9 - Operadores Lógicos bit a bit 
Operador Ação 
& AND (E) 
| OR (OU) 
^ XOR (EXCLUSIVE OR) 
~ NOT 
<< Deslocamento à esquerda 
>> Deslocamento à direita 
 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
31 
 
4. Operadores Relacionais 
Os operadores relacionais realizam comparações entre variáveis, são eles: 
Tabela 10 - Operadores Relacionais 
Operador Ação 
> Maior do que 
>= Maior ou igual a 
< Menor do que 
<= Menor ou igual a 
== Igual a 
!= Diferente de 
O resultado retornado pelos operadores relacionais é sempre igual a 0 (falso) ou 1 
(verdadeiro). 
5. Operadores lógicos 
Para fazer operações com valores lógicos (verdadeiro e falso) temos os 
operadores lógicos: 
Tabela 11 - Operadores Lógicos 
Operador Ação 
&& AND (E) 
|| OR (OU) 
! NOT (NÃO) 
 
Geralmente os operadores lógicos são associados aos operadores relacionais, 
gerando uma grande gama de testes. 
 
As regras de utilização desses operadores, nós veremos em Expressões, por 
enquanto vamos fazer apenas alguns testes básicos com alguns deles. 
 
#include <stdio.h> 
#include <stdlib.h> 
 
/***************************************************************************** 
Programa 10 
Este programa realiza alguns testes básicos com alguns operadores 
 
******************************************************************************/ 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
32 
int main () 
{ 
 char a= 10, b = 5; 
 printf("Expressão aritmetica: a %% b = %d %% %d = %d\n\n", a, b, a % b); 
 printf("Expressão aritmetica: a / b = %d / %d = %d\n\n", a, b, a / b); 
 printf("Expressão logica bit a bit: a | b = %d | %d = %d\n\n", a, b, a | b); 
 printf("Expressão logica bit a bit: a & b = %d & %d = %d\n\n", a, b, a & b); 
 printf ("Expressão logica: a || b = %d || %d = %d\n\n", a, b, a || b); 
 printf ("Expressão logica: !b = !%d = %d\n\n", b, !b); 
 system("pause"); 
 return(0); 
} 
6. Operador Condicional 
A sintaxe do operador condicional é: 
(condição) ? Resultado_se_condição_verdadeira : Resultado_se_condição_falsa 
Os resultados (se a condição é verdadeira ou se a condição é falsa) podem ser de 
qualquer tipo: int, float, char e até string. Observe o próximo exemplo: 
#include <stdio.h> 
#include <stdlib.h> 
 
/***************************************************************************** 
Programa 11 
Este programa testa o operador condicional 
 
******************************************************************************/ 
int main () 
{ 
 char a= 10, b = 5; 
 printf(“O resultado da expressao a!=b e’ %s.”, (a != b) ? 
”verdadeiro” : “falso”); 
 system("pause"); 
 return(0); 
} 
 
 
ATIVIDADES 
3.1 Analise e execute o programa a seguir: 
#include <stdio.h> 
#include <stdlib.h> 
#include <math.h> 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
33 
/***************************************************************************** 
 Programa12 
Este calcula e imprime os maiores e menores valores de alguns 
tipos de dados. 
******************************************************************************/ 
int main () 
{ 
 int x; 
 short int y; 
 char a; 
 unsigned char b; 
 
 x = pow(2,31)-1; /*maior número inteiro*/ 
 y = pow(2,15)-1; /*maior número short int*/ 
 printf ("O maior numero inteiro e: %d\n\n", x); 
 printf ("O maior numero short int é: %hi\n\n", y); 
 
 x = x + 1; /*menor número inteiro*/ 
 y = y + 1; /*menor número long int*/ 
 printf ("O menor numero inteiro e: %d\n\n", x); 
 printf ("O menor numero short inteiro e: %hi\n\n", y); 
 
 a= pow(2,7) -1; /*maior número char*/ 
 b = pow(2,8) -1; /*maior número unsigned char*/ 
 printf ("O maior numero char e: %d\n\n", a); 
 printf ("O maior numero unsigned char e: %d\n\n", b); 
 
 a = a + 1 ; /*menor número char*/ 
 b = b + 1; /*menor número unsigned char*/ 
 printf ("O menor numero char e: %d\n\n", a); 
 printf ("O menor numero unsigned char e: %d\n\n:", b); 
 system("pause"); 
 return(0); 
} 
a. Sabendo-se que o tipo int possui 32 bits explique porque o maior valor int é 
calculado por (231 –1). 
b. Explique porque o menor número short int é calculado por (215 –1) + 1. 
c. Sabendo-se que o tipo unsigned char possui 8 bits explique porque o maior 
valor char é calculado por (28 –1). 
d. Explique porque o menor número unsigned char é calculado por (28 –1) + 1. 
 
3.2 Determine o resultado das questões propostas a seguir, em seguida elabore 
um programa e verifique se suas previsões estão corretas. 
a. int a = 5, b = 3; int c; 
c = a++ + b; 
printf ("a = %d, b = %d, c = %d\n\n", a, b, c); 
c = ++a + b; 
printf ("a = %d, b = %d, c = %d\n\n", a, b, c); 
c = --a + b; 
printf ("a = %d, b = %d, c = %d\n\n", a, b, c); 
c = a-- + b; 
printf ("a = %d, b = %d, c = %d\n\n", a, b, c); 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
34 
c = a---b; 
printf ("a = %d, b = %d, c = %d\n\n", a, b, c); 
 
b. int a = 0x0A50; 
int b = 0x00FF; 
int c; 
c = a << 4; 
printf ("%4x << 4 = %4x\n\n", a, c); 
c = a >> 4; 
printf ("%04X >> 4 = %04X\n\n", a, c); 
c = a & b; 
 printf ("%04x & %2x = %04x\n\n", a, b, c); 
 c = a | b; 
printf ("%04X | %04X = %04X\n\n", a, b, c); 
c = a ^ b; 
printf ("%04x ^ %04x = %04x\n\n", a, b, c); 
c = ~a; 
printf ("~ %04X = %04X\n\n", a, c); 
c = ~b; 
printf ("~ %04x = %09x\n\n", b, c); 
 
Explique porque o resultado de c = ~a possui oito caracteres hexadecimais. 
 
Dica:Dica:Dica:Dica: 
� Os especificadores de tipo %c, %x e %X você já viu, se houver alguma 
dúvida, basta consultar a Tabela 1. Mas o especificador %04x, ainda não. 
Consulte, o item Formatação de valores numéricos, ou faça alguns testes: 
substitua %4x por %05x ou %5x e veja o que acontece. 
 
3.3 Execute os programas a seguir: 
 
#include <stdio.h> 
#include <stdlib.h> 
#include <time.h> 
 
/***************************************************************************** 
 Programa 13 
Este programasimula um jogo de azar que verifica se o usuário 
acertou um número sorteado randomicamente. 
 
******************************************************************************/ 
int main () 
{ 
 int Aposta, Sorteio; /*Declaracao de variáveis*/ 
 time_t t; 
 
 srand((unsigned)time(&t)); /*Iniciar gerador de numeros 
 aleatorios*/ 
 printf ("Este programa simula um jogo de azar.\n\n"); /* Entrada de Dados */ 
 printf ("Digite um numero inteiro ente 0 e 10.\n\n"); 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
35 
 scanf ("%d",&Aposta); 
 Sorteio = random(10); /* Sorteio randomico*/ 
 printf ("\n\nVoce %s o numero sorteado e’ igual a %d.",(Aposta == Sorteio) ? "acertou" : 
 "errou" , Sorteio); 
 printf ("\n\n"); 
 system("pause"); 
 return 0; 
} 
 
a. Existe alguma estrutura que você estudou em PascaL que poderia substituir o 
operador condicional? 
 
#include <stdio.h> 
#include <stdlib.h> 
 
/***************************************************************************** 
 Programa 14 
Através deste programa você testara os operadores lógicos. 
 
******************************************************************************/ 
int main() 
{ 
 int i, j; 
 printf("Digite dois numeros inteiros (cada um sendo 0 ou 1): \n"); 
 scanf("%d\n%d", &i, &j); 
 printf("\n%d AND %d e’ %d\n", i, j, i && j); 
 printf("%d OR %d e’ %d\n", i, j, i || j); 
 printf("NOT %d e’ %d\n\n", i, !i); 
 system(“pause”); 
 return 0; 
} 
 
b. Execute o programa novamente, mas insira números inteiros quaisquer. Faça 
mais de uma execução e não se esqueça de introduzir o zero. Explique o ocorrido. 
 
 
Dica:Dica:Dica:Dica: 
� Se você não estiver entendendo dê uma olhadinha no item Expressões. 
 
#include <stdio.h> 
#include <stdlib.h> 
 
/***************************************************************************** 
 Programa 15 
Através deste programa você testara os operadores relacionais. 
 
******************************************************************************/ 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
36 
int main() 
{ 
 int i, j; 
 printf("Entre com dois numeros inteiros:\n"); 
 scanf("%d\n%d", &i, &j); 
 printf("\n%d == %d e’ %d.\n", i, j, i==j); 
 printf("\n%d != %d e’ %d.\n", i, j, i!=j); 
 printf("\n%d <= %d e’ %d.\n", i, j, i<=j); 
 printf("\n%d >= %d e’ %d.\n", i, j, i>=j); 
 printf("\n%d < %d e’ %d.\n", i, j, i<j); 
 printf("\n%d > %d e’ %d.\n\n", i, j, i>j); 
 system(“pause”); 
 return 0; 
} 
 
c. Explique porque o retorno de uma operação relacional assume apenas os 
inteiros “0” e “1” e o significado desses valores na linguagem C. 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
37 
 
AULA PRÁTICA 04 
 
OBJETIVO: 
 
� Estudar as expressões aritméticas e lógicas. 
 
 
INTRODUÇÃO 
 
Uma vez que vocês já sabem o que são variáveis, constantes, operadores 
aritméticos e lógicos, vamos aplicar esses conhecimentos utilizado-os em 
expressões que é um passo muito importante na solução dos nossos problemas. 
Além de expressões veremos a formatação de valores numéricos que possibilitará 
formatar os dados impressos por você. 
EXPRESSÕES 
As expressões são combinações de variáveis, constantes e operadores, elas 
podem ser expressões aritméticas ou lógicas. 
Expressões aritméticas 
Expressões aritméticas são executadas com operandos do mesmo tipo. O 
resultado da operação terá o mesmo tipo dos operandos. Como pode haver 
valores inteiros e valores ponto flutuante (float), haverá uma conversão implícita 
de tipo, de int para float, sempre que necessário para que a operação seja feita 
entre operandos do mesmo tipo. 
Observe a solução da seguinte expressão: v = (a + (d - c)) / ((b*b) * d) * (1.0 / c); 
Sabendo-se que: a= 15; b= 2; c= 4; d= 3 
Tabela 12 - Operadores aritméticos 
Ordem Operação Resultado Conversão de tipo? 
1º (d - c) 3 – 4 = -1 Não 
2º (b * b) 2 * 2 = 4 Não 
3º (1.0 / c) 1.0 / 4 = 0.25 Sim (4 para 4.0) 
4º a + 1º 15 + (-1) = 14 Não 
5º 2º * d 4 * 3 = 12 Não 
6º 4º / 5º 14/12 = 1 Não (divisão inteira) 
7º 6º * 3º 1 * 0.25 = 0.25 Sim (1 para 1.0) 
8º v = 7º v = 0.25 Não 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
38 
Se as conversões forem possíveis o processador as faz, seguindo as regras 
abaixo: 
1. Em operações onde um ou mais operandos são char ou short int e o(s) 
outro(s) operando(s) é int, haverá uma conversão daqueles (char ou short 
int) para int. O mesmo acontece com operando floats que são convertidos 
para doubles. 
2. Para pares de operandos de tipos diferentes: se um deles é long double o 
outro é convertido para long double; se um deles é double o outro é 
convertido para double; se um é long o outro é convertido para long; se 
um é unsigned o outro é convertido para unsigned. 
Ainda com relação à expressão que acabamos de resolver podemos verificar 
que ela foi executada da esquerda para a direita de acordo com a prioridade 
dos operadores. Observe se a ordem de execução seguiu a Tabela 13, 
apresentada a seguir: 
Tabela 13 – Precedência dos operadores 
Prioridade Operador Descrição 
() Parênteses 
[ ] Colchete 1º 
���� Membro de uma estrutura 
++ Incremento prefixado ou pós-fixado 
-- Decremento prefixado ou pós-fixado 
! NÃO lógico 
~ NÃO binário 
, Encadeamento de expressões 
-(unário) Número negativo 
*(unário) Ponteiro 
&(unário) Endereço de uma variável 
(cast) Modeladores de tipo de dado 
2º 
sizeof Retorna o tamanho de uma variável 
* Multiplicação aritmética 
/ Divisão aritmética 3º 
% Resto de divisão 
+ Mais aritmético 4º 
- Menos aritmético 
< Menor relacional 
<= Menor ou igual relacional 
> Maior relacional 5º 
>= Maior ou igual relacional 
 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
39 
 
. Tabela 13 – Precedência dos operadores 
Prioridade Operador Descrição 
6º && E lógico 
7º || OU lógico 
8º ?: Condicional 
= Atribuição 
*= Aritmético de atribuição (multiplicação) 
/= Aritmético de atribuição (divisão) 
%= Aritmético de atribuição (módulo) 
+= Aritmético de atribuição (adição) 
9º 
-= Aritmético de atribuição (subtração) 
 
 
Expressões lógicas bit a bit 
 
Expressões lógicas bit a bit são elaboradas entre operandos inteiros que podem 
ser escritos em decimal, octal ou hexadecimal e o resultado também é um inteiro. 
Se usarmos operandos inteiros com bases diferentes a operação é executada 
normalmente pois independente da base os operando e a respostas são inteiros. 
Na realidade o computador só efetua operações em binário e isso todos nós já 
sabemos. 
 
Podemos implementar através de software qualquer expressão booleana, uma vez 
que a linguagem C possui todos os operadores lógicos básicos (and, or e 
complemento). A única diferença é que se forem implementados em hardware, os 
circuitos serão mais rápidos. 
 
Observe a expressão a seguir: 
 
Int portaXNor, a= 017, b= 0x5A; 
portaXNor = (~a & ~b)| (a & b); 
 
No exemplo anterior implementamos uma porta Exclusive Nor, que poderia ser 
substituído pela expressão: portaXNor = ~(a^b), não é? 
 
Expressões lógicas 
 
Expressões que envolvem operandos lógicas só podem ser executadas entre 
operandos inteiros, não interessa a base. Qualquer número diferente de zero 
representa verdadeiro e zero representa falso. O resultado é também um número 
inteiro, mas assume apenas o valor 0 (falso) ou 1 (verdadeiro). A linguagem C não 
possui o tipo booleano. 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
40 
 
Expressões que envolvem operandos relacionais podem ser executadas entre 
operandos do tipo int e float. O resultado é um número inteiro, mas assume 
apenas o valor 0 ou 1 que representa falso ou verdadeiro, respectivamente. 
 
Observe a expressão a seguir: 
 
int i = 4, 
float j = 9.0; 
(i > 3.0) && ( j <= 9) && ( i != j); 
 V AND V AND V = V 
Nesta expressão temos operadores relacionais e lógicos. As variáveis são do tipo 
inteiro e float. Verificamos a comparação entre inteiros e float. O resultado das 
comparações é sempre falso ou verdadeiro, em outras palavras é um inteiro. Isto 
permite executar uma operação lógica entre esses resultados parciais. A resposta 
final também é um inteiro. 
Expressões que podem ser Abreviadas 
Através dos operadores de atribuição, apresentados na Tabela 14, uma expressão 
do tipo x = x + y pode ser escrita da seguinte maneira x+ = y. Essa equivalência 
pode ser usada para simplificar expressões ou para facilitar o entendimento de um 
programa. 
Tabela 14 - Operadores de Atribuição 
Operador Ação 
*= a*=b � a=a*b 
/= a/=b � a=a/b 
%= a%=b � a=a%b 
+= A+=b � a=a+b 
-= a-=b � a=a-b 
<<= A<=b � a=a<<b 
>>= a>>=b � a=a>>b 
= a = b 
Encadeando expressões: o operador “,” 
O operador “,” determina uma lista de expressões que devem ser executadas 
seqüencialmente. Em síntese, a vírgula diz ao compilador: execute as duas 
expressões separadas pela vírgula, em seqüência. O valor retornado por uma 
expressão com o operador “,” é sempre dado pela expressão mais à direita. No 
exemplo a seguir: 
x=(y=5,y+2); 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
41 
 
o valor 5 vai ser atribuído a y, se somará 2 e o retorno (7) será atribuído à variável 
x . Pode-se encadear quantos operadores forem necessários. 
O exemplo a seguir mostra um outro uso para o operador, dentro de uma estrutura 
de repetição for: 
#include <stdio.h> 
#include <stdlib.h> 
 
/***************************************************************************** 
 Programa 16 
Através deste programa você testara o operador “,”. 
 
******************************************************************************/ 
 
int main() 
{ 
 int x, y; 
 for(x=0 , y=0 ; x+y < 20 ; ++x , y++) 
 /* Duas variáveis de controle: x e y. Foi atribuído o valor zero a cada 
 uma delas na inicialização do for e ambas são incrementadas na 
 parte de incremento do for */ 
 printf("\n%d ", x+y); /* o programa imprimirá os números 
 pares de 0 a 18 */ 
 system("pause"); 
} 
 
Modeladores (Casts) 
 
Um modelador é aplicado a uma expressão. Ele força a mesma a ser de um tipo 
especificado. Sua forma geral é: 
 (tipo_do_modelador)expressão 
Um exemplo: 
 
#include <stdio.h> 
#include <stdlib.h> 
 
/***************************************************************************** 
 Programa 17 
O modelador (float) é usado para conversão de tipos de dados. 
 
******************************************************************************/ 
int main() 
{ 
 int Int; 
 float Flt1, Flt2; 
 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
42 
 Int= 12/5; 
 Flt1= 12/5; 
 Flt2=(float)12/5; /* O uso do modelador forca a transformacao 
 do numero inteiro 12 em um float */ 
 printf("A divisao entre operandos inteiros (12/5) e' um inteiro: \"%d\".\n\n", Int); 
 printf("Se um numero inteiro for atribuído a uma variavel do tipo\n"); 
 printf("float, o resultado e' um float: \"%.1f\". \n\n", Flt1); 
 printf("Se houver pelo menos um operando float ((float)12/5),\n"); 
 printf("o resultado da divisao e' um float: \"%.1f\".\n\n", Flt2); 
 system("pause"); 
 return(0); 
} 
 
Se não tivéssemos usado o modelador no exemplo acima o C faria uma divisão 
inteira entre 12 e 5. O resultado seria 2 (dois) que poderia ser convertido para 
float transformando-se em 2.0. Com o modelador temos o resultado correto:2.4. 
 
 
FORMATAÇÃO DE VALORES NUMÉRICOS 
 
Como já vimos podemos determinar o tipo de dado que queremos imprimir na tela. 
Além disso, podemos estabelecer o número total de caracteres impressos, 
inclusive os caracteres depois da vírgula. Dê uma olhadinha no exemplo a seguir: 
 
 
#include <stdio.h> 
#include <stdlib.h> 
 
/***************************************************************************** 
Programa 18 
Este programa mostra como formatar um número, determinando 
a precisão que o número pi será impresso. 
. 
******************************************************************************/ 
 
int main() 
{ 
 float PI = 3.1415; 
 printf("O valor de PI e': \"%f\".\n\n", PI); 
 printf("O valor de PI e': \"%07.3f\".\n\n", PI); 
 printf("O valor de PI e': \"%7.3f\".\n\n", PI); 
 printf("O valor de PI e': \"%.4f\".\n\n", PI); 
 printf("O valor de PI e': \"%4.4f\".\n\n", PI); 
 printf("O valor de PI e': \"%5.1f\".\n\n", PI); 
 printf("O valor de PI e': \"%05.1f\".\n\n", PI); 
 printf("O valor de PI e': \"%5.01f\".\n\n", PI); 
 printf("O valor de PI e': \"%57.1f\".\n\n", PI); 
 system("pause"); 
} 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
43 
O especificador de tipo %.4f determina um valor de ponto flutuante (%f) com 
quatro casas decimais. Além de especificar o número de casas decimais, 
podemos também especificar o número total de caracteres a ser impresso. 
Atenção, o número total de caracteres inclui o sinal e o ponto decimal. 
Assim, o especificador %5.3f significa: exibir um valor ponto flutuante com cinco 
caracteres no total, incluindo três casas decimais e a vírgula. 
Se houver necessidade, será acrescentado o caractere ‘ ‘ (espaço) à esquerda do 
valor para completar o tamanho total especificado. Ou poderão ser colocados 
zeros aa esquerda do número se for especificado %07.4f. 
 
 
ATIVIDADES 
 
5.1 Verifique se as seguintes expressões são verdadeiras ou falsas e faça um 
programa para testá-las. 
Dados: int i = 1, j = 2, k = 3; float x= 3.3; 
a. ‘j’ != ‘j’ + 2 
b. ‘j’ != ‘j’ == ‘j’ 
c. i < x && 2 >= k 
d. i < x || 2>= k 
e. i ==2 || j == 4 || k == 5 
f. x <= 5.0 && x != 1.0 || i > j 
g.10 > 5 || 2.0 == 2 
h. (!(5==6)&&(5!=6)&&((2>1)||(5<=4))) 
 
Dicas:Dicas:Dicas:Dicas: 
� Se algumas expressões estiverem confusas, use parênteses para torná-
las mais legíveis; 
� Use o operador condicional dentro da função printf, para verificar o 
resultado das expressões. Consulte o Programa 13. 
 
4.2 Analise os itens a, b e c apresentados a seguir: 
 
a. int i1; 
 float f3; 
 i1= 7/3; 
 f3= 7/3; 
 
b. int num= 12; 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensinodo 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
44 
 float f1, f2; 
 f1= (float)num/5; 
 f2= (float)(num/5); 
 
c. float f1= 37.8, f2= 3.0, f3; 
 int i; 
 f3= f1/f2; 
 i= f1/f2; 
 
Existem diferenças entre as duas respostas que você encontrou em cada item? 
Explique as possíveis diferenças. 
4.3 Faça um programa solicitando ao usuário que insira através do teclado uma 
temperatura em graus Celsius. O programa converterá a temperatura digitada em 
graus Fahrenheit, imprimindo na tela a seguinte mensagem: 
 XXXºC corresoinde a YYYºF 
 
 
Dicas:Dicas:Dicas:Dicas: 
� A fórmula de conversão de graus Celsius para Fahrenheit é: 
F= (9*C + 180)/ 
 
4.4 Elabore um programa solicitando ao usuário que digite um ano qualquer. O 
programa verifica se o ano digitado é bissexto e imprimi na tela uma das seguintes 
mensagens: 
 
 1. O ano XXXX É bissexto. 
 2. O ano XXXX NÂO é bissexto. 
 
 
Dicas:Dicas:Dicas:Dicas: 
� Um ano é bissexto se for divisível por 4 e NÃO for divisível por 100 ou 
quando for divisível por 100 e 400; 
� Use o operador condicional dentro da função printf, para identificar o ano. 
Consulte o Programa 13. 
4.5 Faça um programa que solicite ao usuário que digite uma letra, que seja lida 
através da função getch(), e imprime na tela uma das seguintes frases: 
 1. A letra digitada foi __ convertida para minúsculo é__. 
 2. A letra digitada foi __ convertida para maiúscula é__. 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
45 
 
 
Dicas:Dicas:Dicas:Dicas: 
� Os computadores, como todas as máquinas digitais, só entendem 0 e 1 
que é uma abstração das tensões 0V e 5V, respectivamente. Por esse 
motivo os caracteres têm que ser codificados. Um dos códifigos mais 
utilizados é o código ASCII (American Standard Code for Information 
Interchange). Em ASCII a letra A corresponde à 0x41, B= 0x42, C= 0x43, 
... Y= 0x59 e X=0x5A. As letras minúsculas correspondem: a= 0x61, b= 
0x62, c= 0x63, ... y= 0x79 e z= 0x7A; 
� Use o operador condicional dentro da função printf, para verificar se a 
letra digitada é maiúscula ou minúscula. Consulte o Programa 13. 
O operador condicional é a estrutura mais adequada para implementar este 
programa? Imagine se o usuário digitasse o número 1, por exemplo. 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
46 
 
AULA PRÁTICA 05 
 
OBJETIVO: 
 
� Estudar as estruturas condicionais: if e switch. 
 
 
INTRODUÇÃO 
Já estudamos os tipos de dados em C e como manipulá-los através de 
expressões lógicas e aritméticas. Agora estudaremos as estruturas de dados, tais 
como: as estruturas condicionais (if e switch) e as estruturas de repetição (for, 
while e do while). É uma tarefa fácil para nós, pois as estruturas básicas já foram 
vistas em PascaL, e como sabemos o conceito é o mesmo a diferença está na 
forma de escrever a estrutura. As outras, não estudadas, são variações das 
estruturas básicas. 
 
ESTRUTURAS CONDICIONAIS 
 
Os programas são executados pelo processador seqüencialmente, isto é, uma 
instrução após a outra. Às vezes é preciso, a partir de uma condição, executar um 
determinado conjunto de instruções e ignorar algumas outras. Ou seja, é preciso 
dar saltos. As estruturas de tomada de decisão apresentadas a seguir permitem 
escolher, ou seja, tomar decisões: 
 
1. if 
O comando if representa uma tomada de decisão do tipo "SE isto ENTÃO 
execute". A sua forma geral é: 
if(condição) declaração; 
A condição do comando if é uma expressão que será avaliada. Se a condição 
for verdadeira a declaração a seguir será executada, caso contrário ele será 
pulado, e o programa continuará a ser executado normalmente. A declaração 
pode ser um bloco de código ou apenas um comando. É interessante notar que no 
caso da declaração ser um bloco de código, temos que colocar o conjunto de 
instruções entre chaves, naturalmente. 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
47 
if(condição) 
{ 
 <Comando_em _C>; 
<Comando_em _C>; 
 ....................... 
<Comando_em _C>; 
} 
 
Em alguns casos, se a condição não for verdadeira é necessário executar um 
bloco de código específico. Isto é, esse novo bloco só é executado se a condição 
for falsa. Para esses casos existe a estrutura if_else, apresentada a seguir: 
 
if(condição) 
{ 
 <Comando_em _C> 
 <Comando_em _C>; 
 ....................... 
<Comando_em _C>; 
} 
else 
{ 
 <Comando_em _C>; 
 <Comando_em _C>; 
 ....................... 
<Comando_em _C>; 
} 
 
A condição será avaliada. Se ela for diferente de zero, ou seja, verdadeira, a 
primeira declaração será executada. Se for zero a segunda declaração será 
executada. É importante nunca esquecer que, quando usamos a estrutura if-else, 
estamos garantindo que uma das duas declarações seja executada. Nunca serão 
executadas as duas ou nenhuma delas. 
 
Existem situações em que é necessário analisar várias situações excludentes 
entre si. A primeira solução é a estrutura if_else_if, cuja sintaxe é apresentada a 
seguir: 
if (condição_1) declaração_1; 
else if (condição_2) declaração_2; 
else if (condição_3) declaração_3; 
. 
. 
. 
else if (condição_n) declaração_n; 
else declaração_default; 
Nem é preciso dizer que as declarações podem ser um bloco de instruções e 
neste caso devem ser colocadas entre parênteses. E é importante mencionar que 
o compilador sempre associa um else ao if mais próximo. Caso esta associação 
não corresponda à lógica do seu programa, use chaves. 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela Fátima da Silva 
 
 
48 
 
 
2. switch 
 
A segunda solução para várias condições de teste é o switch. Na estrutura 
if_else_if caso a opção selecionada não seja a primeira, será testada 
seqüencialmente cada uma delas até que seja encontrada a verdadeira ou que a 
opção default seja assumida. Na estrutura switch o programa assumirá a opção 
selecionada sem que seja necessário o teste de cada uma das opções. 
 
switch(variável) 
{ 
 case constante_1: 
declaração_1; 
break; 
 case constante_2: 
 declaração_2; 
break; 
. 
. 
. 
 case constante_n: 
declaração_n; 
break; 
default: 
declaração_default; 
} 
 
O switch testa se uma determinada variável corresponde a uma das constantes 
especificadas no case e executa a respectiva declaração. A declaração default é 
opcional e será executada apenas se a variável, que está sendo testada, não for 
igual a nenhuma das constantes. 
 
O comando break, faz com que o switch seja interrompido assim que uma das 
declarações seja executada. Mas ele não é essencial ao comando switch. Se 
após a execução da declaração não houver um break, o programa continuará a 
ser executado seqüencialmente. 
 
Analise o programa apresentado a seguir. Ele utiliza o comando switch para 
verificar se uma vogal minúscula foi digitada pelo usuário. Observe que após a 
palavra reservada case obrigatoriamente vem uma constante. 
 
 
#include <stdio.h> 
#include <stdlib.h> 
#include <conio.h > 
 
 
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS 
Departamento de Ensino do 2o grau - Coordenação de Eletrônica 
Disciplina: Laboratório de Introdução a Programação 
Professora: Rosângela