Programação II

Prévia do material em texto

Recife, 2009
Programação 2
Sônia Virginia Alves França
Universidade Federal Rural de Pernambuco
Reitor: Prof. Valmar Corrêa de Andrade
Vice-Reitor: Prof. Reginaldo Barros
Pró-Reitor de Administração: Prof. Francisco Fernando Ramos Carvalho
Pró-Reitor de Extensão: Prof. Paulo Donizeti Siepierski
Pró-Reitor de Pesquisa e Pós-Graduação: Prof. Fernando José Freire
Pró-Reitor de Planejamento: Prof. Rinaldo Luiz Caraciolo Ferreira
Pró-Reitora de Ensino de Graduação: Profª. Maria José de Sena
Coordenação Geral de Ensino a Distância: Profª Marizete Silva Santos
Produção Gráfica e Editorial
Capa e Editoração: Allyson Vila Nova, Rafael Lira, Italo Amorim e Glaydson da Silva
Revisão Ortográfica: Ivanda Martins
Ilustrações: Diego Almeida
Coordenação de Produção: Marizete Silva Santos
Sumário
Plano da Disciplina ...............................................................................5
Apresentação ........................................................................................9
Conhecendo o Volume 01 ..................................................................10
Capítulo 1 – Introdução ao C .............................................................13
1.1. Programas e Programação de Computadores ..........................13
1.2. Linguagens de Programação .....................................................15
1.3. Breve Histórico da Linguagem de Programação C ...................18
1.4. Criação, Compilação e Execução de um Programa ..................19
Capítulo 2 – Conceitos Preliminares para Programar em C ...........24
2.1. Estrutura de um Programa Básico em C ...................................25
2.2. Palavras Reservadas do C ........................................................28
2.3 Uso de Comentários ...................................................................29
2.4. Os Fundamentos do Ambiente C ...............................................31
2.5. Conhecendo o Dev-cpp .............................................................34
Capítulo 3 – Tipos de Dados, Variáveis e Constantes .....................40
3.1. Tipos de dados ..........................................................................40
3.2. Variáveis e Constantes ..............................................................42
3.3. Operador de Atribuição (=) ........................................................49
Capítulo 4 – Comandos de Entrada e Saída de Dados ....................54
4.1. Entrada de Dados ......................................................................54
4.2. Saída de Dados .........................................................................59
4.3. Erros Frequentes no Uso dos Comandos de Entrada e Saída .65
4.4. Primeiros programas em C ........................................................66
Capítulo 5 – Operadores, Expressões e Funções Matemáticas .....75
5.1. Operadores Básicos ..................................................................75
5.2. Operadores Aritméticos de Atribuição ......................................87
5.3. Operadores ++ e -- ....................................................................87
5.4. Conversão de tipo ......................................................................88
5.5. Funções Matemáticas (biblioteca math.h) .................................90
Plano da Disciplina
Carga horária: 60h
Ementa da Disciplina
 Introdução à linguagem de programação C. Tipos de dados, variáveis, operadores 
aritméticos, relacionais e lógicos. Comandos de entrada e saída. Estruturas de 
seleção e repetição. Modularização. Vetores e registros. Ponteiros. Arquivos. 
Manipulação de caracteres. Comandos de tela. Comandos de manipulação de 
data e hora.
Objetivos
Objetivo Geral
• Apresentar técnicas de programação estruturada utilizando como ferramenta a 
linguagem de programação C
Objetivos Epecíficos
• Desenvolver a capacidade de solução de problemas de programação, com o uso 
da linguagem C.
• Introduzir métodos de otimização para garantir eficiência e segurança aos 
programas.
• Desenvolver o auto-aprendizado.
Conteúdo Programático
Módulo 1 - Introdução à Linguagem de Programação C
Carga Horária do Módulo 01: 15 h
 Objetivo do Módulo 01: Introdução ao C e seus comandos básicos, para 
possibilitar a construção dos primeiros programas nesta linguagem.
Conteúdo Programático do Módulo 1
• Introdução ao C
 ○ Conceito de programa e linguagem de programação
 ○ Introdução ao C: Um breve histórico
 ○ Etapas de desenvolvimento de um programa
• Comandos Básicos do C
 ○ Estrutura de um programa C 
 ○ Diretivas de compilação
 ○ Uso de comentário
 ○ Tipos de dados
 ○ Variáveis, constantes, identificadores e atribuição
 ○ Comandos de entrada e saída
 ○ Operadores aritméticos, relacionais e lógicos
 ○ Modificadores de tipos de dados
 ○ Funções matemáticas
Módulo 2 – Estruturas de Controle de Fluxo e Modularização 
Carga Horária do Módulo 2: 15 h
 Objetivo do Módulo 2: Possibilitar o conhecimento das estruturas de controle 
(seleção e repetição) do C e métodos para modularização dos programas (criação 
de procedimentos e funções).
Conteúdo Programático do Módulo 2:
• Estruturas de Controle de Fluxo
 ○ Sequência
 ○ Estrutura de seleção: If e Switch
 ○ Estrutura de repetição: for, do/while e while
 ○ Comando break
• Modularização 
 ○ Construção de módulos: funções e procedimentos 
 ○ Passagem de parâmetros e escopo de variáveis
 ○ Comando return
Módulo 3 – Armazenamento de Dados em Vetores, Registros e Arquivos
Carga horária do Módulo 03: 15 h
 Objetivo do Módulo 03: Apresentar as formas de armazenamento de dados 
homogêneos (vetores) e heterogêneos (registros), além dos comandos para 
manipulação de arquivos.
Conteúdo Programático do Módulo 03:
• Tipos de Dados Homogêneos e Heterogêneos
 ○ Vetores
 ○ Registros
 ○ Vetor de registro
• Arquivos
 ○ Ponteiros
 ○ Comandos para manipulação de arquivo
Módulo 4 – Comandos Avançados 
Carga Horária do Módulo 4: 15 h
 Objetivo do Módulo 4: Apresentar comandos mais avançados da linguagem 
C, tais como: manipulação de caracteres, comandos de tela (para melhorias na 
interface dos programas) e manipulação de data e hora. 
Conteúdo Programático do Módulo 4:
• Comandos para Manipulação de Caracteres e Strings
 ○ Comandos da biblioteca ctype e string
 ○ Validação de campos
• Comandos de Tela – Interface
 ○ Comandos da biblioteca conio 
• Comandos para Manipulação de data e hora 
 ○ Comandos da biblioteca time
Avaliação
• Avaliação prática em laboratório correspondendo a 60% da nota.
• Resolução de listas de exercícios, que serão enviadas através do ambiente virtual 
(30%).
• Avaliação referente à participação do aluno nas aulas presenciais e ambiente 
virtual: fóruns de discussão, chats, etc (10%).
Bibliografia
Básica:
 SCHILDT, Herbert. C Completo e Total. São Paulo: Makron, 1996. 
 DEITEL, H, M e DEITEL, P. J. Como Programar em C. Rio de Janeiro: LTC, 
1999.
Complementar:
 ASCENIO, Ana Fernanda Gomes e CAMPOS, Edilene Aparecida Veneruchi. 
Fundamentos de Programação de Computadores. São Paulo: Prentice Hall, 
2002.
Apresentação
Caro(a) aluno(a),
Seja bem-vindo (a) ao primeiro módulo da disciplina Programação II. Nesta disciplina, 
você irá aprender a programar na linguagem de programação C, uma das mais utilizadas 
mundialmente. Desenvolver programas e garantir que estes sejam confiáveis, eficientes 
e agradáveis de usar requer conhecimento técnico e muito treinamento.
Este livro foi escrito pensando em você, que está iniciando neste mundo da 
programação de computadores e que precisa ser apresentado, com tranquilidade, a um 
conjunto de novos conceitos. Os assuntos serão transmitidos gradativamente, de forma 
que você os absorvacom naturalidade.
Este livro contém muitos exemplos de questões resolvidas, comentadas em 
detalhes, para que você não encontre dificuldades para aprender cada assunto. Além 
de apresentar dicas para que você desenvolva seus programas de forma eficiente e 
não cometa os principais erros de programação que ocorrem com quem está iniciando 
a programar. Ao final de cada capítulo, você poderá testar o seu aprendizado e assimilar 
melhor o que foi estudado, através da resolução de exercícios. Isto é muito importante! 
Não deixe de resolvê-los.
De antemão, informamos que programar é muito bom, você vai gostar! Nada melhor 
do que ver um programa rodando e saber que foi você quem o criou. Mas, não desanime 
se encontrar alguma dificuldade durante esta caminhada. Às vezes o programa dá 
um erro e não sabemos onde está o problema. Seja persistente! Ao longo do tempo, 
a experiência vai te dar mais segurança e você conseguirá encontrar tais erros com 
facilidade.
O objetivo deste primeiro módulo é fazer uma introdução à linguagem C, conhecer 
um pouco da sua história e iniciar o estudo da sintaxe da linguagem, que possibilitará 
a construção de programas básicos. Ao final deste primeiro módulo, você já estará 
desenvolvendo seus primeiros programas em C. O que você está esperando? Vamos 
começar?
Bons estudos!
Professora Sônia Virginia Alves França
10
Programação 2
Conhecendo o Volume 01
Neste primeiro volume, você irá encontrar o módulo 01 da disciplina: 
Programação II. Este volume está estruturado em cinco capítulos, que 
serão estudados ao longo de 15h/aula. Para facilitar seus estudos, 
veja a organização deste primeiro volume.
Capítulo 1: Introdução ao C
Carga Horária do Capítulo 1: 2 h/aula
 Objetivos do Capítulo 1: Introduzir os conceitos básicos da 
área de programação e apresentar um breve histórico sobre a 
linguagem C.
Conteúdo Programático do Capítulo 1
• Conceito de programas e programação de computadores;
• Linguagens de programação; 
• Breve histórico da linguagem de programação C;
• Etapas do desenvolvimento de um programa.
Capítulo 2: Conceitos Preliminares para Programar em C
Carga Horária do Capítulo 2: 3 h/aula
 Objetivos do Capítulo 2: Apresentar detalhes mais específicos 
da linguagem, necessários para dar início à programação 
em C. Neste capítulo, também será apresentado o ambiente 
de programação que utilizaremos no desenvolvimento dos 
programas. 
Conteúdo Programático do Capítulo 2
• Estrutura de um programa básico C;
• Palavras reservadas do C; 
• Uso de comentários;
• Fundamentos do ambiente C;
• Conhecendo o Dev-cpp.
11
Programação 2
Capítulo 3: Tipos de Dados, Variáveis e Constantes
Carga Horária do Capítulo 3: 2 h/aula
 Objetivos do Capítulo 3: Apresentar os tipos de dados 
suportados pelo C e introduzir o conceito de variáveis e 
constantes 
Conteúdo Programático do Capítulo 3
• Tipos de dados;
• Variáveis e constantes;
• Operador de atribuição; 
Capítulo 4: Comandos de Entrada e Saída de Dados
Carga Horária do Capítulo 4: 4 h/aula
 Objetivos do Capítulo 4: Apresentar os comandos de entrada 
e saída de dados do C. Neste capítulo, você terá acumulado 
conhecimento suficiente para desenvolver os primeiros 
programas em C. 
Conteúdo Programático do Capítulo 4
• Entrada de dados;
• Saída de dados;
• Desenvolvimento dos primeiros programas C.
Capítulo 5: Operadores, Expressões e Funções Matemáticas
Carga Horária do Capítulo 5: 4 h/aula
 Objetivos do Capítulo 5: Apresentar os operadores 
básicos (aritméticos, relacionais e lógicos), além de funções 
complementares para o desenvolvimento de programas que 
executem expressões mais complexas. 
Conteúdo Programático do Capítulo 5
• Operadores aritméticos, lógicos e relacionais;
• Operadores aritméticos de atribuição;
• Operadores ++ e --;
12
Programação 2
• Conversão de tipos;
• Funções matemáticas.
Ao final de cada capítulo você encontrará:
• A seção “Atividades e Orientações de Estudo”: que contém 
exercícios para a fixação do assunto estudado, além de 
indicação de fóruns de discussão. 
• A seção “Conheça Mais”: que contém dicas de sites e livros 
que devem ser lidos para ampliar os seus conhecimentos.
• A seção “Vamos Revisar?”: que apresenta um resumo dos 
principais tópicos abordados no capítulo.
13
Programação 2
Capítulo 1 – Introdução ao C
Vamos conversar sobre o assunto?
Neste primeiro capítulo, será feita uma apresentação do que é 
programação e quais as principais linguagens de programação do 
mercado, dando ênfase à linguagem C. Este capítulo é importante, 
porque conheceremos um pouco da história da linguagem de 
programação que iremos aprender nesta disciplina. Sempre que 
conhecemos uma pessoa nova, queremos saber alguns detalhes 
da sua vida, não é mesmo? Quantos anos ela tem, onde nasceu, 
quem são seus pais, etc. Neste capítulo, também, serão introduzidos 
conceitos utilizados na área de programação, visando a nossa 
preparação para nos lançarmos nesse mundo intrigante da criação de 
programas computacionais. Então, prontos (as) para o desafio?
1.1. Programas e Programação de 
Computadores
Um programa de computador é um conjunto de instruções que 
descrevem uma tarefa que será executada por um computador. 
Um programa de computador também é conhecido como software, 
software aplicativo, software de sistema ou simplesmente programa. 
O termo software é mais utilizado quando é feita uma referência à 
parte não física do sistema computacional, juntamente com o termo 
hardware, que faz referência ao conjunto de componentes eletrônicos 
que constituem um computador. 
Os programas que permitem ao usuário fazer uma ou mais tarefas 
específicas, como as planilhas eletrônicas, editores de texto e jogos 
são chamados de software aplicativo ou aplicação. Já os programas 
que dão suporte funcional aos computadores, como os sistemas 
operacionais e drivers de dispositivos, são chamados de software de 
sistema1. 
O ato de desenvolver programas é chamado de programação 
de computadores. A programação é o processo de escrita, teste 
e manutenção de um programa (ASCENIO e CAMPOS, 2002). 
O desenvolvimento de programas baseado em metodologias ou 
processos formalizados é conhecido por engenharia de software.
Saiba Mais
1 Além dos 
software 
aplicativo e 
software de 
sistema, ainda é 
possivel utilizar 
a categoria 
software 
embutido ou 
embarcado, 
destinado a 
funcionar dentro 
de uma máquina 
que não é um 
computador. 
Normalmente, 
estes software 
têm um 
propósito muito 
específico, como, 
por exemplo: 
controlar a 
injeção eletrônica 
de um carro 
ou gerenciar 
o cozimento 
dos alimentos 
no forno de 
microndas. Mais 
recentemente, 
surgiu também 
o software como 
serviço, que é 
um software que 
roda diretamente 
na internet, não 
sendo necessário 
instalar nada no 
computador do 
usuário. 
14
Programação 2
Os programas são escritos em uma linguagem de programação. 
Assim como o Português, o Inglês e o Espanhol, as linguagens 
de programação têm as suas regras e devemos seguí-las para 
escrever nossos programas corretamente. Portanto, a programação 
de computadores é uma ciência e, por isso, devemos seguir uma 
metodologia para termos como resultado: programas seguros e 
eficientes.
Em uma disciplina anterior, vocês aprenderam a desenvolver 
algoritmos, que são uma sequência de passos para realizar uma 
tarefa ou resolver um problema. Utilizamos algoritmos no nosso 
cotidiano para realizar atividades corriqueiras, definindo a sequência 
de passos que deve ser executada para atingirmos um objetivo, como, 
por exemplo, os passos que executamos para tomar banho, calibrar 
um pneu ou fazer um bolo.
Figura 1.1: Exemplos de algoritmos
Para efetuarmos estas atividades, seguimos umasequência 
lógica de passos. Se esses passos não tiverem uma lógica, podemos 
não conseguir atingir o nosso objetivo. Se vocês observarem, para 
fazer um bolo, existe uma ordem em que os ingredientes devem ser 
adicionados à receita, caso não sigamos esta ordem, o bolo não ficará 
bom. Na programação irá ocorrer a mesma coisa, devemos passar as 
instruções ao computador, utilizando uma linguagem de programação, 
seguindo uma lógica – a lógica computacional.
Na próxima seção vamos abordar as linguagens de programação, 
de uma forma mais abrangente, tratando os principais conceitos que 
envolvem este assunto. Vamos seguir em frente?
15
Programação 2
1.2. Linguagens de Programação
É através das linguagens de programação que poderemos criar 
nossos programas. Uma linguagem de programação é um conjunto de 
regras sintáticas e semânticas usadas para definir um programa. O 
conjunto de códigos (palavras e símbolos), compostos de acordo com 
essas regras, constituem o código fonte do nosso programa. Para 
ser executado pelo processador, o código fonte precisa ser traduzido 
para código de máquina.
Aprender uma linguagem de programação é um pouco similar 
a aprender um novo idioma. Temos que saber o significado das 
palavras, as regras da estruturação das frases, etc., para podermos 
nos comunicar corretamente no novo idioma.
Figura 1.2: Aprenda a dar ordens ao seu computador
Existem várias linguagens de programação. Vocês sabiam que 
cada linguagem de programação possui o seu conjunto de regras e 
um modo de funcionamento próprio? A escolha de uma linguagem 
de programação para o desenvolvimento de um programa deve estar 
atrelada ao tipo de problema que deseja resolver. Existem linguagens 
16
Programação 2
que são melhores para resolver um certo tipo de questão do que 
outras. 
De acordo com Sebesta (2003), as linguagens de programação 
vêm sendo classificadas de várias formas: por geração, de acordo com 
o paradigma de programação, quanto ao grau de abstração, de acordo 
com a estrutura de tipos, dentre outras. Uma das classificações mais 
utilizadas é quanto ao grau de abstração. Segundo esta classificação, 
as linguagens de programação são divididas em três grupos: 
linguagens de máquina, linguagens de baixo nível e linguagens 
de alto nível.
A linguagem de máquina é a linguagem natural dos computadores. 
Estas linguagens são ininteligíveis para o ser humano não treinado. 
As linguagens de máquina são representadas por sequências de 
bits (zeros e uns). Estas sequências representam instruções que 
serão executadas pelo processador do computador. As instruções 
correspondem a sequências muito simples de operações, tais como: 
transferir um dado em memória para a CPU ou somar dois valores. As 
linguagens de máquina são dependentes do processador, isto é, uma 
determinada linguagem de máquina só poderá usada por um tipo de 
computador.
As linguagens de baixo nível são próximas da linguagem de 
máquina. No entanto, os zeros e uns que formam uma instrução 
foram substituídos por palavras que representam tais instruções, 
tornando-as um pouco mais legíveis. Estas linguagens são mais 
voltadas para a máquina, isto é, são escritas usando as instruções 
do microprocessador do computador. São chamadas de linguagens 
Assembly (que significa montagem). Estas linguagens apresentam 
as seguintes vantagens: os programas são executados com maior 
velocidade de processamento (já que são executadas diretamente 
pela máquina) e ocupam menos espaço na memória. No entanto, de 
modo geral, os programas em Assembly têm pouca portabilidade2 (um 
código gerado para um tipo de processador não serve para outro) e 
não são estruturados, tornando a programação mais difícil.
As linguagens de alto nível são mais próximas à linguagem 
humana (do Inglês, por exemplo) e mais distantes das linguagens 
de máquina. Por isso, são linguagens mais simples de entender, já 
que, em geral, utilizam uma sintaxe estruturada, tornando seu código 
mais legível. Necessitam de compiladores ou interpretadores 
para gerar instruções do microprocessador. Interpretadores fazem 
Saiba Mais
2 No contexto da 
informática, a 
portabilidade de 
um programa é a 
sua capacidade 
de ser compilado 
ou executado 
em diferentes 
arquiteturas (seja 
de hardware ou 
de software).
Esse termo 
também vem 
sendo utilizado 
pelas empresas 
de telefonia 
móvel, quando 
se referem à 
portabilidade 
de número, ou 
seja, você muda 
de operadora, 
mas nao muda 
o número do 
celular.
17
Programação 2
a interpretação de cada instrução do programa fonte executando-a 
dentro de um ambiente de programação, Basic e Java são exemplos de 
linguagens interpretadas. Os 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 programação. A linguagem C e Pascal são exemplos de 
linguagens compiladas.
As linguagens de alto nível ainda podem ser divididas de acordo com 
a sua aplicação: genéricas (como C, Java e Pascal, que servem para 
o desenvolvimento de programas de propósito geral) ou específicas 
(como Fortran - utilizada para execução de cálculos matemáticos, 
LISP - desenvolvimento de aplicações na área de inteligência artificial 
e CLIPPER – utilizada para aplicações que manipulam bancos de 
dados). As vantagens das linguagens de alto nível são: portabilidade 
(por serem compiladas ou interpretadas podem ser executadas em 
várias plataformas com pouquíssimas modificações) e facilidade de 
desenvolvimento de programas. No entanto, as rotinas geradas são 
mais genéricas (e mais complexas) e por isso são mais lentas e 
ocupam mais memória.
A figura 1.3, a seguir, apresenta um trecho de código escrito em 
linguagem de máquina, linguagem de baixo nível e linguagem de alto 
nível, respectivamente.
Linguagem de 
Máquina
10110101 
11100110 
11000100
Linguagem de 
Baixo Nível
LOAD BASE 
ADD BONUS 
STORE SALARIO
Linguagem de Alto Nível
 
 
Salario = Base + Bonus
Figura 1.3: Trecho de código em diferentes linguagens
Notem como o código em linguagem de máquina é incompreensível. 
Difícil entender essas seqüências de zeros e uns, não é mesmo? 
O código na linguagem de baixo nível é mais legível e passamos 
a entender as instruções. Na linguagem de alto nível, o código fica 
menor e muito mais simples. Em qual tipo de linguagem vocês querem 
programar? Nem precisamos parar para pensar, não é mesmo?
18
Programação 2
Figura 1.4: Linguagens de baixo nível x linguagens de alto nível
1.3. Breve Histórico da Linguagem de 
Programação C
Vamos conhecer um pouco sobre a história do C? A linguagem 
de programação C nasceu em 1972 nos laboratórios Bell, Estados 
Unidos. Seus criadores são Brian Kernighan e Dennis M. Ritchie. A 
linguagem C foi criada a partir da linguagem B (sugestivo, não é?), 
que havia sido desenvolvida no final dos anos 60 por Ken Thompson. 
O C é uma linguagem de alto nível, compilada e estruturada3. 
No entanto, o C possui instruções de baixo nível, bem próximas à 
linguagem de máquina, que só o Assembler possui. O objetivo dos 
seus criadores era usar o C para desenvolver o sistema operacional 
UNIX, que originalmente foi escrito em Assembly (linguagem de baixo 
nível). Desde então, espalhou-se por muitos outros sistemas e tornou-
se uma das linguagens de programação mais usadas, e influenciando 
o desenvolvimento de muitas outras linguagens como C++ e Java.
Com a linguagem C podemos construir programas organizados 
e concisos (características dos programas das linguagens de alto 
Saiba Mais
3Uma linguagem 
é considerada 
estruturada 
quando 
permite que o 
programador 
pegue trechos 
de maior uso do 
seu programa e 
transforme-os 
em pequenos 
módulos 
(procedimentos 
e funções)que 
serão reutilizados 
sempre que 
necessário.
19
Programação 2
nível), ocupando pouco espaço de memória e com alta velocidade 
de execução (como o Assembler). Infelizmente, dada toda a 
flexibilidade da linguagem, também poderemos escrever programas 
desorganizados e difíceis de serem compreendidos. Portanto, cabe 
ao programador de C utilizar boas práticas de programação, para ter 
programas legíveis e de fácil manutenção. 
Existem inúmeras razões para que o C seja uma das linguagens 
mais preferidas dos programadores. As características da linguagem 
C mostram o porquê de sua ampla aceitação. Vejamos algumas 
características da linguagem C.
• Portabilidade entre máquinas e sistemas operacionais;
• Dados compostos em forma estruturada;
• Programas estruturados;
• Total interação com o sistema operacional;
• Código compacto e rápido, quando comparado ao código de 
outras linguagens de alto nível. 
Agora que já conhecemos um pouco mais da linguagem C, vamos 
entender o processo de desenvolvimento de um programa. Quais são 
os passos que devemos seguir para termos um programa pronto? 
Vamos começar a falar sobre isto agora mesmo. Continuem firmes na 
leitura!
1.4. Criação, Compilação e Execução de um 
Programa
Nesta seção vamos estudar as etapas de desenvolvimento de um 
programa em C. O desenvolvimento de um programa é dividido em 
três etapas, como mostra a figura 1.5.
Figura 1.5: Estados do desenvolvimento de um programa em C
A primeira etapa para o desenvolvimento de um programa em C é 
20
Programação 2
a criação do programa fonte, que consiste no “texto” formado pelo 
conjunto de comandos que nós desejamos que o computador execute. 
O programa fonte deve ser escrito respeitando as regras da linguagem. 
De modo geral, os programas fontes são digitados em editores de 
texto genéricos ou específicos dos ambientes de programação. No 
próximo capítulo deste volume, vamos conhecer detalhadamente o 
ambiente de programação que será utilizado para o desenvolvimento 
dos nossos programas em C.
Com o programa fonte pronto, passamos para a etapa de 
compilação. O compilador é um programa que verifica se o 
programa fonte não apresenta nenhum erro de sintaxe e gera o 
programa executável. Quando o programa fonte apresenta algum 
problema, dizemos que ocorreu um “erro de compilação”. Assim, o 
programador deverá avaliar o programa fonte, para a retirada tais 
erros. Normalmente, os compiladores indicam os prováveis erros de 
sintaxe cometidos pelo programador. Se o programa não tiver erros 
de sintaxe, o compilador irá gerar o programa executável.
A etapa final consiste na execução do programa executável. 
Neste momento, o programador deverá testar se o programa 
está produzindo os resultados esperados. Quando o programa 
apresenta algum erro nesta fase, como, por exemplo, mostrar um 
resultado incorreto, dizemos que ocorreu um “erro de lógica” ou 
“erro de execução”. Isso ocorre porque, apesar do programa não 
ter apresentado erros de sintaxe, o que tornou possível a geração 
do programa executável, a sequência de comandos não foi definida 
de forma correta. Quando ocorre um erro de lógica, o programador 
deverá revisar o seu programa fonte e passá-lo novamente pela fase 
de compilação, para que um novo executável, sem erros, seja gerado. 
Como o compilador não nos avisa onde estão os erros de lógica, estes 
são mais difíceis de serem corrigidos. 
Após ter certeza que o programa executável está correto, sem 
erros de lógica, o programador poderá entregá-lo ao seu cliente. É 
importante fazermos vários testes nos nossos programas. Testar com 
vários valores e verificar se está realmente tudo como esperado. Não 
fica bem nosso cliente ficar ligando, dizendo que o programa está com 
BUG!4 Lembrem-se sempre, o computador só executa as instruções 
que nós mandarmos. Se houver erros, a responsabilidade será nossa 
que não fizemos o programa corretamente! Vocês não vão querer 
passar por uma situação como essa? Vão?
Saiba Mais
4 Bug é um erro 
no funcionamento 
de um programa. 
É também 
chamado de 
erro de lógica, 
e pode causar 
discrepâncias 
no objetivo ou 
impossibilidade 
de utilização de 
um programa de 
computador. 
O uso do 
termo bug 
para descrever 
defeitos 
inexplicáveis foi 
parte do jargão da 
engenharia por 
várias décadas. 
Acredita-se que o 
termo foi criado 
por Thomas 
Edison quando 
um inseto (bug, 
em Inglês) causou 
problemas de 
leitura em seu 
fonógrafo em 
1878. 
21
Programação 2
Nesta fase de execução do programa executável, nós também 
devemos verificar a usabilidade do programa, ou seja, se o programa 
ficou fácil de ser utilizado pelo seu usuário. Quando o programa é de 
difícil utilização ou confunde o usuário, induzindo-o ao erro, ele perde 
o interesse em utilizá-lo ou comprá-lo. Também devemos verificar se 
nosso programa tem um bom desempenho, ou seja, se ele processa 
rapidamente as operações. Usuário não gosta de programa lento, não 
é mesmo?
Atividades e Orientações de Estudo
Agora é o momento de analisarmos se os assuntos abordados 
neste capítulo foram bem absorvidos. Foram vistos muitos conceitos 
novos, não é mesmo? Vamos responder as questões a seguir. Caso 
sintam necessidade, releiam alguma seção que não foi muito bem 
assimilada ou complementem as respostas com a leitura dos sites 
indicados na próxima seção. Vocês estão preparados(as)?
1. Para que serve uma linguagem de programação?
2. Quais as desvantagens das linguagens de baixo nível?
3. Por que desejamos programas portáveis?
4. O que motivou a criação da linguagem C? 
5. A linguagem C é de baixo ou alto nível? 
6. A linguagem C é compilada ou interpretada? 
7. Por que os erros de lógica são mais difíceis de serem 
corrigidos?
8. Por que devemos nos preocupar com a usabilidade dos nossos 
programas?
Conheça Mais
Para ampliar os seus conhecimentos sobre os assuntos 
tratados neste capítulo, visite o site da OReilly. Neste endereço, 
22
Programação 2
http://oreilly.com/pub/a/oreilly/news/languageposter_0504.html, 
foi disponibilizado um pôster, muitíssimo interessante, como uma 
“árvore genealógica” das principais linguagens de programação dos 
últimos 50 anos. Vale a pena dar uma olhada.
É muito importante que vocês se cadastrem em algum fórum de 
discussão sobre a linguagem C. Assim, vocês poderão conversar e 
trocar idéias com programadores de C mais experientes. Exemplos 
de fóruns de C: DevMedia e Linha de código.
Vamos revisar?
Vamos dar uma reforçada em nosso aprendizado com esta 
pequena revisão dos principais conceitos apresentados neste capítulo. 
Observem o resumo a seguir:
• Programa: é um conjunto de instruções que descrevem uma tarefa 
que será executada por um computador.
• Programação de Computadores: é o processo de escrita, teste e 
manutenção de um programa.
• Algoritmo: sequência de passos para realizar uma tarefa ou 
resolver um problema.
• Linguagem de Programação: é um conjunto de regras sintáticas e 
semânticas usadas para definir um programa.
• Linguagem de máquina: é a linguagem natural dos computadores. 
As instruções são formadas por zeros e uns. Estas linguagens não 
são legíveis para um programador sem experiência.
• Linguagens de baixo nível: são linguagens escritas usando as 
instruções do microprocessador do computador. Estas linguagens 
são mais difíceis de entender e criar programas.
• Linguagens de alto nível: são linguagens mais próximas à 
linguagem humana e mais distantes das linguagens de máquina. 
São linguagens mais simples de entender, já que, em geral, 
utilizam uma sintaxe estruturada, tornando seu código mais legível.
• Compiladores: são programas que fazem a tradução de todas as 
instruções do programa fonte gerando um programa executável.
23
Programação 2
• Interpretadores:são programas que interpretam cada instrução 
do programa fonte executando-a dentro de um ambiente de 
programação.
• Compilação: é o processo, executado pelo compilador, que verifica 
se existem erros de sintaxe no código fonte e gera um programa 
executável.
• Erro de sintaxe: ocorre durante o processo de compilação do 
programa, quando o programador, ao editar o seu programa 
fonte, não respeita alguma regra de sintaxe da linguagem de 
programação. 
• Erro de lógica: ocorre durante a execução de um programa, devido 
um erro na lógica dos comandos.
24
Programação 2
Capítulo 2 – Conceitos 
Preliminares para Programar 
em C
Vamos conversar sobre o assunto?
Neste capítulo, serão abordados conceitos preliminares que 
irão nos preparar para programar em C. Estes conceitos estão 
relacionados à estrutura de um programa básico em C. Aqui, também, 
será apresentado o ambiente de programação que utilizaremos 
para o desenvolvimento dos nossos programas – o Dev-cpp. Este 
ambiente apresenta uma interface amigável, que facilitará o processo 
de programação. Vocês devem baixar e instalar o Dev-Cpp5, o 
quanto antes, no computador que será utilizado para a prática desta 
linguagem. 
É importante que vocês tenham paciência neste início de 
aprendizado, já que precisamos, inicialmente, acumular o conhecimento 
necessário para a construção de um programa completo em C. 
Visando facilitar o aprendizado, em alguns momentos, será feito um 
paralelo entre a sintaxe do C e do Portugol do VisuAlg6 (linguagem 
utilizada para escrever algoritmos).
Saiba Mais
5 O Dev-cpp é 
uma ferramenta 
gratuita e pode 
ser baixada 
acessando o site: 
www.bloodshed.
net/devcpp.html
Saiba Mais
6 Conheça 
mais o VisuAlg 
pesquisando no 
site: http://www.
apoioinformatica.
inf.br/visualg/
linguagem.htm
25
Programação 2
Figura 2.1: Qualidades de um programador: atenção, paciência e persistência
Vale lembrar que qualquer linguagem de programação é assimilada 
através da resolução de exercícios. É importantíssimo que a prática 
de programar faça parte da rotina de vocês. Assim, separem sempre 
um tempo para resolver as questões propostas neste material. Vocês 
vão perceber o quanto é bom ver um programa rodando! Que venha 
o C!
2.1. Estrutura de um Programa Básico em C
Nesta seção, vamos estudar a estrutura de um programa básico 
em C. Visando facilitar o entendimento e não sobrecarregar vocês 
com muitos detalhes, alguns elementos da estrutura do programa 
serão omitidos. Mas, no momento certo, abordaremos tais elementos, 
certo? Assim, a estrutura do programa que será apresentada nesta 
seção, é a estrutura mínima de um programa em C.
Nas linguagens de programação em geral, existe uma estrutura que 
indica a ordem em que deve ser disposto cada elemento do programa. 
Esta ordem deve ser respeitada para que nossos programas fiquem 
corretos. Como será a estrutura de um programa em C?
A estrutura básica de um programa C deve seguir a seguinte 
ordem:
1. Inclusão de bibliotecas (quando necessário); 
2. Declaração das constantes (quando necessário);
3. Programa principal;
26
Programação 2
 • Declaração de variáveis (quando necessário);
 • Seqüência de comandos.
Para entendermos melhor a estrutura básica de um programa C, 
vamos analisar o programa de exemplo 2.1, abaixo. Este programa 
calcula o cubo de um número inteiro fornecido pelo usuário. Na 
sequência, temos este programa resolvido utilizando o portugol, que é 
do conhecimento de vocês. Assim, fica fácil compararmos a estrutura 
do programa em C, com a estrutura do algoritmo. Não se preocupem 
em entender cada comando do exemplo abaixo, estamos apenas 
começando a estudar o C, certo?
Exemplo 2.1: Programa C – Cálculo do cubo de um número
1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
main()
{
 int num,c;
 printf(“Cubo de um numero\n\n”);
 printf(“Digite o numero: “);
 scanf(“%d”,&num);
 c = num*num*num;
 printf(“\nCubo de %d = %d”,num,c);
 getche();
}
Segue abaixo o algoritmo, escrito no VisuAlg, que calcula o cubo 
de um número.
27
Programação 2
Exemplo 2.2: Algoritmo – Calculo do cubo de um número
1
2
3
4
5
6
7
8
9
10
algoritmo “Cubo”
var
 num, c: inteiro
inicio
 escreval(“Cubo de um numero”)
 escreva(“Digite o numero: “)
 leia(num)
 c <- num*num*num
 escreval(“Cubo de “, num, “ = “, c)
fimalgoritmo
Um programa em C inicia com a inclusão de bibliotecas. Uma 
biblioteca é um arquivo que contém comandos complementares, 
que são utilizados pelo nosso programa. Para a inclusão de uma 
biblioteca devemos usar um comando que é chamado de diretiva de 
compilação. Este comando informa ao compilador quais bibliotecas 
devem ser anexadas ao programa executável. Assim, o comando para 
a inclusão de uma biblioteca tem a seguinte sintaxe: 
Sintaxe
#include <nome_do_arquivo_da_ biblioteca>
De acordo com a sintaxe, para incluir uma biblioteca ao nosso 
programa devemos colocar a diretiva de compilação #include e, entre 
os símbolos < e >, colocamos o nome do arquivo da biblioteca. De 
maneira geral, os arquivos de biblioteca têm a terminação .h (esse h 
vem de header, ou seja, este é um arquivo de cabeçalho). Para cada 
biblioteca, que será incluída no nosso programa, devemos colocar 
um comando #include. No exemplo 2.1, na linha 1, é feita a inclusão 
de uma biblioteca: stdio.h. Na medida em que formos aprendendo 
os comandos, serão indicadas quais bibliotecas devem ser incluídas 
no programa. A quantidade de bibliotecas e quais bibliotecas serão 
28
Programação 2
incluídas, depende dos comandos que serão utilizados no programa. 
Pode ser que em um programa, não seja necessário incluir nenhuma 
biblioteca. 
O segundo item da estrutura de um programa C é a declaração 
das constantes, esse item é opcional, só constará no nosso programa, 
caso seja necessário. Veremos a declaração de constantes, em 
detalhes, no próximo capítulo. No exemplo 2.1 não foi necessário o 
uso de constantes.
O terceiro item da estrutura do programa C é o programa principal. 
É no programa principal que colocaremos a sequência de comandos 
que deve ser executada para a solução do problema que desejamos 
resolver. Nós devemos informar onde começa e termina o programa 
principal. O programa principal inicia com: main()7, como mostra a linha 
2, do exemplo 2.1. A sequência de comandos do programa principal é 
delimitada por um par de chaves: { (abre chaves) e } (fecha chaves). 
As chaves que delimitam o corpo do programa principal8 aparecem 
nas linhas 3 e 11, do exemplo 2.1. Fazendo uma comparação com 
o algoritmo do exemplo 2.2, as chaves fazem o papel do “inicio” e 
“fimalgoritmo”, das linhas 4 e 10.
Logo no início do programa principal, devem ser declaradas as 
variáveis (que serão abordadas no próximo capítulo). A declaração 
de variáveis é um item opcional, pode acontecer de não precisarmos 
declarar variáveis no nosso programa. No exemplo 2.1, a declaração 
de variáveis é feita na linha 4. Foram declaradas duas variáveis do 
tipo inteiro: num e c. No algoritmo, exemplo 2.2, as variáveis são 
declaradas fora do programa principal, na seção de declaração de 
variáveis (linhas 2 e 3). 
Após a declaração das variáveis, colocamos a sequência de 
comandos que o programa deverá executar. O programa termina com 
o fecha chaves que delimita o programa principal. 
Agora que já sabemos como é a estrutura de um programa básico 
em C, vamos começar a aprender a sintaxe dos comandos para 
darmos início ao desenvolvimento dos nossos programas.
2.2. Palavras Reservadas do C
Como mencionado no capítulo anterior, as linguagens de 
programação são formadas por um conjunto de regras de sintaxe e 
Saiba Mais
7 Do Inglês, 
main significa 
principal. Todoprograma C 
começa a sua 
execução a partir 
do programa 
principal. Assim, 
o programa 
principal é uma 
parte obrigatória 
na estrutura de 
um programa C.
Saiba Mais
8 Chamamos 
de corpo do 
programa 
principal toda 
a sequência 
de comandos 
que faz parte 
do programa 
principal. Ou seja, 
a seqüência de 
comando que 
aparece entre 
as chaves de 
abertura e término 
do programa 
principal.
29
Programação 2
semântica que ditam como o programa deve ser escrito. Com isso, 
dentro dessas regras, existe um conjunto de palavras que tem um 
significado para a linguagem de programação – são as palavras 
reservadas. Uma palavra reservada é, essencialmente, um comando 
e, na maioria das vezes, as palavras reservadas de uma linguagem 
definem o que pode ser feito e como pode ser feito.
As palavras reservadas são de uso exclusivo da gramática da 
linguagem, por isso, não podem ser utilizadas, pelo programador, para 
dar nome a alguma variável, constante ou função do seu programa. 
Assim, um programador não pode ter uma variável chamada “int” no 
seu programa C, já que “int” é uma palavra reservada que indica um 
tipo de dado.
Na linguagem C temos 32 palavras reservadas. Todas as palavras 
reservadas do C são escritas em minúsculo. A tabela abaixo mostra 
as palavras reservadas, conforme definido pelo padrão ANSI9, para a 
linguagem C.
auto 
break 
case 
char 
const 
switch 
volatile 
continue
default 
do 
double 
else 
typedef 
while 
enum 
extern
float 
for 
goto 
union 
if 
int 
long 
register
unsigned 
return 
short 
signed 
sizeof 
static 
struct 
void
No Dev-cpp, ambiente de programação que será utilizado, sempre 
que digitarmos uma palavra reservada no nosso programa, esta 
aparecerá em negrito. Isto facilita no momento da programação, pois 
não precisaremos decorar esta lista de palavras reservadas. Que 
alívio! Assim que uma palavra ficar em negrito no nosso programa, 
poderemos verificar se estamos utilizando-a de forma correta.
2.3 Uso de Comentários
Os comentários são utilizados para documentar um programa. A 
colocação de comentários em um programa é uma das boas práticas 
de programação10. Os comentários irão facilitar o entendimento 
e manutenção de programas. Por exemplo, um programador é 
responsável por desenvolver o sistema de controle de vendas 
Saiba Mais
9 A sigla ANSI 
significa: 
American 
National 
Standards 
Institute (Instituto 
Nacional 
Americano de 
Padronização). É 
uma organização 
que tem por 
objetivo facilitar a 
padronização dos 
trabalhos de seus 
membros.
Saiba Mais
10 Ao desenvolver 
nossos 
programas 
utilizando boas 
práticas de 
programação, 
teremos como 
resultado um 
código fonte 
mais legível e 
um progama 
executável mais 
seguro e eficiente. 
Ao longo deste 
material serão 
ensinadas boas 
práticas de 
programação. 
30
Programação 2
da sua empresa. Como o sistema é grande, após um tempo, ele 
não lembrará mais o porquê de ter colocado uma sequência de 
comandos no seu programa. Se o programa estiver bem comentado, 
o programador poderá, rapidamente, ter esta resposta. Além disso, 
quando desenvolvemos programas em grupo, é importante que os 
demais membros do grupo entendam o raciocínio do nosso programa 
e isso pode ser explicado através dos comentários.
Os comentários podem ser colocados em qualquer parte do 
programa. Quando o compilador identifica um comentário, ele os 
ignora, já que os comentários são apenas informações para o 
programador. A linguagem C fornece dois tipos de comentários: de 
linha e de bloco. Vamos detalhar como funciona cada um deles.
Os comentários de linha são mais utilizados quando desejamos 
comentar uma única linha do nosso programa. Um comentário de 
linha possui a sintaxe a seguir:
Sintaxe
// texto do comentário
Um comentário de linha inicia com duas barras “//” e, na sequência, 
vem o texto do comentário. O exemplo 2.3, a seguir, apresenta um 
programa comentado. Na linha 7 temos o exemplo de um comentário 
de linha. Este comentário serviu para informar para que serve a 
variável C. Assim que o compilador encontra “//”, ele ignora todo texto 
que vem após as duas barras11. Este tipo de comentário age apenas 
na linha que ele é inserido. 
O segundo tipo de comentário disponível na linguagem C é o 
comentário de bloco. Os comentários de bloco são utilizados quando 
queremos fazer um comentário maior, que compreenda mais de uma 
linha de comentário. A sintaxe do comentário de bloco é a seguinte: 
Sintaxe
/* texto do comentário
 texto do comentário
 texto do comentário */
Um comentário de bloco inicia com barra-asterisco “/*” e termina 
por asterisco-barra “*/”. O compilador irá ignorar tudo o que encontrar 
Saiba Mais
11No Dev-
cpp, quando 
colocamos um 
comentário, as 
letras do texto 
comentado ficam 
cinza
31
Programação 2
entre estes dois símbolos. Veja no exemplo 2.3, que nas linhas 2, 3, 
e 4 aparece um comentário de bloco. Este tipo de comentário do 
exemplo é utilizado para identificar quem é o programador quando 
o programa foi feito e o que o programa faz. Devemos Adotar este 
tipo de comentário no início dos nossos programas. Assim, ao abrir 
um programa, rapidamente, saberemos para que ele serve. Devemos 
tomar cuidado para não esquecer o “*/” que fecha o comentário de 
bloco.
Exemplo 2.3: Programa C Comentado – Calculo do cubo de um número
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
/* Programador: Sônia França
 Data: 09/03/2009
 Programa calcular o cubo de um número */
main()
{
 int Num, C; // C guarda o cubo do numero
 printf(“Cubo de um numero\n\n”);
 printf(“Digite o numero: “);
 scanf(“%d”,&Num);
 C = Num*Num*Num;
 printf(“\nCubo de %d = %d”,Num,C);
 getche();
}
2.4. Os Fundamentos do Ambiente C
Na seção 1.5, do capítulo anterior, foram abordados os processos 
de criação, compilação e execução de um programa. Nesta seção, 
vamos detalhar um pouco mais estes processos, entendendo os 
32
Programação 2
fundamentos do ambiente C. A figura 2.2 apresenta um ambiente 
C, com as seis fases pelas quais passa um programa, desde a sua 
edição, até a sua execução.
Figura 2.2: Ambiente C
A fase 1 compreende a edição do nosso programa. O programa 
é criado com a utilização de um editor e é armazenado no disco do 
computador (HD - Hard Disk). O arquivo que contém o nosso programa 
tem a terminação .c, e este é chamado de programa fonte ou código 
fonte.
Ao terminar a edição do programa, o programador solicita que 
o seu código fonte seja compilado. O compilador traduz o código 
fonte para o código em linguagem de máquina (também chamado 
de código objeto). Vocês se lembram das diretivas de compilação? 
Antes da tradução, temos a fase 2, em que o pré-processador 
33
Programação 2
analisa o código fonte, executando as diretivas de compilação. O 
pré-processador também é responsável por eliminar os comentários 
que o programador colocou no seu código fonte. O pré-processador é 
ativado automaticamente pelo compilador. Na fase 3, é que ocorre o 
processo de compilação, após o código fonte ter sido pré-processado. 
Para que o processo de compilação seja concluído, o programa não 
pode apresentar erros de sintaxe. 
Na fase 4, ocorre o processo de linking, que consiste na ligação do 
código objeto, gerado pelo compilador, com o código das funções que 
estão disponíveis nas bibliotecas que incluímos no nosso programa. 
Ou seja, no exemplo 2.1, em que foi incluída uma biblioteca, o linker 
deverá localizar o arquivo da biblioteca e fazer a ligação com o código 
objeto. Esta fase termina com a geração do programa executável, 
armazenando-o no disco do computador. No Dev-cpp, o programaexecutável é armazenado no mesmo diretório que tiver armazenado 
o código fonte. Na Figura 2.3, temos um diretório contendo o arquivo 
do código objeto (.c – C source file) e o programa executável (.exe – 
application). O arquivo do programa executável não pode ser editado, 
o que nós podemos editar é o arquivo do código fonte. 
Figura 2.3: Diretório contendo código objeto e o programa executável
As fases 5 e 6 consistem na execução do programa executável. 
Para dar início a execução de um programa, é necessário que o mesmo 
esteja na memória principal do computador. Isto é feito na fase 5, pelo 
carregador do programa. O carregador pega o programa executável 
que está armazenado no disco e o transfere para memória principal. 
Assim que o programa está na memória principal do computador, ele 
está pronto para ser executado. A execução de um programa é feita 
pela CPU12, que executa as instruções do programa, uma após a 
outra, até o seu término.
Saiba Mais
12 CPU é a sigla 
para Central 
Processing 
Unit, em Inglês, 
ou Unidade 
Central de 
Processamento. 
A CPU é a parte 
do computador 
que processa 
as instruções 
contidas em um 
programa.
34
Programação 2
Na próxima seção, vamos conhecer o Dev-Cpp, que possibilitará a 
criação, compilação e execução dos nossos programas. Com o Dev-
cpp poderemos observar as fases aqui descritas.
2.5. Conhecendo o Dev-cpp
O Dev-Cpp é um ambiente de programação que edita, compila 
e executa programas C e C++13. Sabem porque iremos usar o Dev-
cpp para desenvolver nossos programas? O Dev-cpp é gratuito 
(muito importante!) e possui uma interface bastante amigável (mais 
importante ainda!). A Figura 2.4 apresenta a tela principal do Dev-
cpp.
Figura 2.4: Tela principal do Dev-cpp
Como mencionado no início deste capítulo, vocês deverão baixar 
o Dev-cpp e instalar no seu computador, para que possamos fazer 
os nossos programas. O processo de instalação não apresenta 
dificuldades. Vocês só devem ficar atentos no momento que for 
questionado sobre qual idioma deseja utilizar, para que faça a escolha 
do idioma correto (Português), certo? Assim, a interface do Dev-cpp 
ficará toda em Português, facilitando os seus estudos.
Vamos analisar a tela principal do Dev-cpp, apresentada na figura 
2.4. Na parte 1 temos o menu principal do Dev-cpp, que disponibiliza 
Saiba Mais
13 C++ é uma 
linguagem de 
programação que 
surgiu a partir 
do C. 
35
Programação 2
as seguintes opções:
• Arquivo: o menu arquivo disponibiliza, basicamente, as opções 
para criar, salvar, imprimir e fechar arquivos. 
• Editar: neste menu encontraremos as opções: copiar, colar, 
selecionar, refazer e desfazer.
• Localizar: as opções deste menu nos possibilita localizar alguma 
palavra no programa fonte, além de permitir substituições de 
uma palavra por outra.
• Exibir: neste menu temos as opções que nos permite exibir ou 
esconder itens da interface do ambiente, como por exemplo: 
barra de ferramenta e barra de status. 
• Projeto: permite a adição ou remoção de arquivos em um 
projeto.
• Executar: é através deste menu que iremos chamar as opções 
para a compilação e execução do nosso programa. 
• Debug: o debugador auxilia o programador a encontrar erros 
no programa, tornando possível acompanhar passo a passo a 
execução dos comandos do programa. Neste menu teremos as 
opções para utilização do debugador. 
• Ferramentas: no menu ferramentas temos as opções para 
configurar o ambiente (mudar cores, tipo de letra, dentre outros) 
e também a opção para atualização do Dev-cpp.
• CVS14: este menu é utilizado por quem faz o controle de 
versões dos programas. Apesar de ser uma função bastante 
interessante, é mais utilizado quando trabalhamos em grupo ou 
com programas grandes. 
• Janela: neste menu estão disponíveis as opções que nos 
permitem escolher qual janela de edição deve ficar visível 
no momento. Utilizamos esta opção quando temos vários 
programas abertos ao mesmo tempo.
• Ajuda: neste menu encontramos o help do Dev-cpp.
Na parte 2, da Figura 2.4, temos os ícones de atalhos para as 
opções mais utilizadas no Dev-Cpp. Se vocês deixarem o mouse 
sobre o ícone, aparecerá um texto, que informa o que ele faz. Na parte 
3 temos a área de edição do programa. Para a área de edição ficar 
Saiba Mais
14O CVS, ou 
Concurrent 
Version System 
(Sistema 
de Versões 
Concorrentes) 
é um sistema 
de controle de 
versões que 
permite que 
se trabalhe 
com diversas 
versões do 
mesmo arquivo. 
Este sistema 
mantém as 
versões antigas 
do seu arquivo 
e os logs de 
quem e quando 
manipulou os 
arquivos.
É especialmente 
útil para se 
controlar versões 
de um software 
durante seu 
desenvolvimento, 
ou para 
composição 
colaborativa de 
um documento.
36
Programação 2
disponível, vocês deverão escolher a opção Arquivo/Novo/Arquivo 
Fonte. É nesta área que digitaremos os nosso programas (código 
fonte). A parte 4 fica visível quando nosso programa apresenta algum 
erro de compilação. O compilador indicará em qual linha foi encontrado 
um erro, e fornece uma dica do que pode ser o erro. Mesmo que 
vocês tenham instalado o Dev-cpp em Português, as mensagens de 
erro são apresentadas em Inglês. Por isso, é importante que vocês 
comecem a se familiarizar com estas mensagens, para que consigam 
tirar mais rapidamente os erros dos programas. 
Segue abaixo um roteiro do que vocês precisam fazer para editar, 
compilar e executar seus programas no Dev-cpp:
1. Crie um arquivo fonte novo na opção: Arquivo/Novo/Arquivo 
Fonte;
2. Digite o programa fonte na área de edição. Ao terminar de editá-
lo, salve o arquivo;
3. Compile o programa na opção: Executar/Compilar;
4. Se der algum erro no programa, vejam as indicações de 
erro fornecidas pelo compilador15. Conserte os erros, salve o 
arquivo e compile novamente. Isto deve ser feito até que seja 
apresentada uma mensagem indicando que o programa não 
tem erros de compilação.
5. Se vocês acessarem o diretório que o arquivo do código fonte 
foi armazenado, notarão que foi criado um arquivo com a 
extensão .exe (com o mesmo nome do arquivo do código fonte). 
Este é programa executável. Para executá-lo, escolha a opção 
Executar/Executar no Dev-cpp. Imediatamente, aparecerá a 
janela de execução do programa, como mostra a Figura 2.5.
Figura 2.5: Janela do programa em execução
É nesta janela que o programa será executado. Aqui o usuário 
Saiba Mais
15 O erro de 
compilação pode 
não estar na linha 
que o complilador 
está indicando. O 
erro poderá estar: 
na linha que ele 
está indicando, 
na linha 
imediatamente 
acima, ou ainda, 
em linhas mais 
acima (menos 
comum de 
acontecer).
37
Programação 2
deverá fornecer os dados solicitados pelo programa, neste caso o 
programa está solicitando que seja digitado um número. Além disso, 
também receberá os resultados fornecidos pelo programa. Quando 
a execução de um programa é finalizada, esta janela será fechada 
automaticamente. 
Agora que já conhecemos o ambiente de desenvolvimento de 
programa C, precisamos aprender os comandos para fazer um 
programa completo. Nos próximos capítulos iremos ver tais comandos, 
para podermos começar a programar. Não fiquem ansiosos(as), a 
nossa hora de programar está chegando!
Atividades e Orientações de Estudo
Vamos resolver mais uma lista de exercícios? Note que estamos 
conhecendo, ao poucos, os detalhes que envolve a programação de 
computadores. A resolução das atividades propostas fará com que 
estes conceitos sejam assimilados de forma mais natural. É sempre 
importante complementar o nosso conhecimento com a leitura de 
livros e materiais disponíveis na Internet, indicados na seção “Conheça 
Mais”. Será que vocês estão lembrados (as) das respostas para as 
questões abaixo?
1. Quandoé que precisamos incluir uma biblioteca em um 
programa C?
2. O que é diretiva de compilação?
3. O que deve ter no corpo do programa principal?
4. O que é uma palavra reservada?
5. Porque devemos comentar nossos programas?
6. Qual a função do pré-processador no momento da compilação 
de um programa?
7. Qual o papel do linker no processo de compilação?
8. Qual elemento do computador é responsável pela execução do 
programa?
38
Programação 2
Conheça Mais
Vocês poderão aprender mais sobre boas práticas de programação 
nos sites:
 http://www.ibm.com/developerworks/aix/library/au-hook_
duttaC.html
 ht tp: / /www2.eletronica.org/ar t igos/eletronica-dig i ta l /
programando-em-c-boas-praticas
Para conhecer mais detalhes do ambiente de programação que 
iremos utilizar, acessem os sites:
 http://www.bloodshed.net/dev/index.html
 http://www.uniqueness-template.com/devcpp/
Vamos revisar?
Nesta seção iremos revisar os principais tópicos vistos neste 
capítulo. Vale a pena dar uma lida para verificar como está o nosso 
aprendizado. Observem o resumo a seguir:
• A estrutura básica de um programa C deve seguir a seguinte ordem: 
inclusão de bibliotecas, declaração das constantes e programa 
principal. No corpo de programa principal temos: declaração de 
variáveis e seqüência de comandos.
• Uma biblioteca é um arquivo que contém comandos 
complementares, que são utilizados pelo programa. Para a inclusão 
de uma biblioteca devemos usar um comando que é chamado de 
diretiva de compilação. 
• As palavras reservadas de uma linguagem definem o que pode ser 
feito e como pode ser feito. O programador não pode utilizar uma 
palavra reservada da linguagem para dar nome as suas variáveis, 
constantes e funções. 
• O uso de comentário nos programas é uma boa prática de 
programação, e facilita o entendimento do código fonte.
39
Programação 2
• Passos para o desenvolvimento de um programa: edição, pré-
processamento, compilação, ligação (linking), carregamento e 
execução.
• O compilador traduz o código fonte para o código em linguagem 
de máquina. O pré-processador analisa o código fonte, executando 
as diretivas de compilação.
• O linker faz a ligação do código objeto, gerado pelo compilador, 
com o código das funções que estão disponíveis nas bibliotecas 
que incluímos no programa. 
• Ao ser executado, um programa deve ser carregado na memória. 
O carregador, também conhecido por loader, e responsável por 
acessar o programa armazenado no disco e carregá-lo para a 
memória principal do computador.
• Os programas são executados passo a passo pelo processador 
do computador.
40
Programação 2
Capítulo 3 – Tipos de Dados, 
Variáveis e Constantes
Vamos conversar sobre o assunto?
Programas são feitos para manipular dados. Armazenar notas, 
calcular médias, alterar um endereço, etc. Os dados são a essência 
de um programa. Dados precisam ser armazenados e modificados 
ao longo da execução do programa. Neste capítulo, iremos conhecer 
os tipos de dados suportados pela linguagem C e aprender a definir 
constantes e variáveis.
Inicialmente, os comandos serão apresentados em separado. Mas, 
logo em seguida, veremos o ponto em que cada comando deve ser 
colocado na estrutura do programa, certo? Tenham paciência! Vocês 
irão notar que muito dos conceitos estudados nos capítulos anteriores 
serão referenciados neste capítulo. Mas isto não é problema, não é 
mesmo? Vamos continuar os nossos estudos, conhecendo mais um 
pouco da linguagem C.
3.1. Tipos de dados
Nesta seção, vamos aprender um conceito importante em 
programação, que é: tipo de dados. De maneira geral, os programas 
manipulam dados, armazenando-os e, muitas vezes, modificando seus 
valores. Primeiramente, vamos conhecer quais os tipos de dados são 
manipulados na linguagem C. Basicamente, a linguagem C, manipula 
quatro tipos de dados: inteiro, real, caractere e void16. Para cada tipo 
de dado, é necessária uma quantidade de bits17 para armazená-lo. 
Além disso, cada tipo de dado possui um conjunto de operações 
que pode ser executada sobre ele. Nas subseções seguintes, vamos 
detalhar cada tipo de dado separadamente.
3.1.1. Inteiro
Os dados do tipo inteiro são toda e qualquer informação numérica 
que pertença ao conjunto dos números inteiros relativos (negativo, 
nulo ou positivo). Os números inteiros, em C, se dividem em três tipos, 
como mostra a tabela a seguir.
Saiba Mais
16A linguagem 
C não possui 
o tipo lógico, 
que armazena 
verdadeiro ou 
falso.
Saiba Mais
17Bit é uma 
abreviatura de 
“Binary Digit” 
(dígito binário). 
Este termo foi 
criado pelo 
engenheiro belga 
Claude Shannon 
que em 1949 
para simbolizar 
uma unidade de 
informação. Tudo 
na informática é 
medido em bits, 
desde o tamanho 
de um número 
até a velocidade 
de transferência 
de dados em uma 
rede. Por ser uma 
unidade binária, 
pode ter apenas 
dois valores, zero 
ou um. 
A partir do bit, 
surgiu o byte, que 
nada mais é do 
que um conjunto 
de 8 bits. 
Existem diversos 
múltiplos dos 
bytes: um kilobyte 
(KB), equivalente 
a 1.024 bytes; 
um megabyte 
(MB), equivalente 
a 1.024 KB; e 
um gigabyte, 
equivalente a 
1.024 MB. 
41
Programação 2
Tipo Tamanho Intervalo Suportado
Short 16 bits -32.768 a +32.767
Int 32 bits -2.147.483.648 a + 2.147.483.647
 
Long
 
64 bits
-9.223.372.036.854.775.808 
a 
+9.223.372.036.854.775.807
Qual a diferença entre cada um deles? A diferença entre os tipos 
short, int e long é a quantidade de memória18 que é reservada para 
armazená-los. Veja como é simples: à medida que se utiliza mais 
memória, aumenta o intervalo do valor que pode ser armazenado. Por 
exemplo, para armazenar um dado do tipo short, são reservados 16 
bits de memória. Com isso, o tipo short pode suportar um número 
inteiro no intervalo de -32.768 a +32.767, como apresentado na 
tabela. Portanto, dependendo do valor que será armazenado, deve 
ser escolhido um tipo (short, int ou long) que comporte tal valor. Por 
exemplo, para armazenar a idade de um funcionário, o tipo short 
é o mais adequado (já que a idade de uma pessoa é um valor que 
raramente ultrapassa 100). No entanto, para armazenar a quantidade 
de eleitores de uma cidade, deve-se usar o tipo int (note que em 
muitas cidades, a quantidade de eleitores ultrapassará o maior valor 
suportado pelo tipo short: 32.767). Para facilitar nosso estudo, neste 
material, sempre será usado o tipo int para armazenar os dados 
inteiros.
3.1.2. Real
Os dados do tipo real são toda e qualquer informação numérica 
que pertença ao conjunto de números reais (negativo, positivo ou 
nulo). Os números reais, em C, podem ser de dois tipos, como mostra 
a tabela abaixo:
Tipo Tamanho Intervalo Suportado
float 32 bits 3.4E-38 a 3.4E+38
double 64 bits 1.7E-308 a 1.7E+308
Para o tipo float são reservados 32 bits de memória, o que 
possibilita armazenar um valor no intervalo 3.4–38 a 3.438. Como o tipo 
float suporta valores bem altos, neste material, sempre será usado o 
tipo float para armazenar os dados reais.
Atenção
18A memória 
é a parte do 
computador que 
tem como função 
o armazenamento 
de dados. Quando 
um dado vai ser 
armazenado, 
precisamos 
reservar uma 
quantidade de 
memória para 
isto. 
42
Programação 2
3.1.3. Caractere
Na linguagem C, os caracteres são do tipo char, representados 
por toda e qualquer informação composta por um único caractere 
alfa numérico (a, b, c,...z, A, B, C,...Z, 0...9) ou especial (como por 
exemplo: ; # ? @ ! < ?). O tipo char armazena um único caractere. 
Quando se deseja armazenar vários caracteres, é necessário definir 
um vetor de caractere (mais detalhes na seção 3.2.2). Por exemplo, 
o nome de um aluno é formado por uma cadeia de caracteres, 
assim,será necessário usar um vetor de caracteres. Cada caractere 
armazenado ocupa o espaço de 8 bits de memória. Um caractere 
deve ser representado entre apóstrofo, por exemplo: ‘a’. Mas, quando 
temos uma cadeia de caracteres, esta deve ser representada entre 
aspas dupla, por exemplo: “Pedro Goncalves”.
3.1.4. Void
Em Inglês, void quer dizer vazio e é isto mesmo que o void é. Void 
é um tipo que não armazena nada (um tanto esquisito, não é?). Este 
tipo serve para indicar que um resultado não tem um tipo definido. Ele 
é utilizado quando estamos definindo funções nos nossos programas. 
Permiti-nos desenvolver funções que não retornam nada e funções 
que não têm parâmetros. Voltaremos a falar do tipo void no Volume 2, 
no capítulo que aborda modularização.
3.2. Variáveis e Constantes
Agora que já sabemos os tipos de dados manipulados pela 
linguagem C, vamos aprender como reservar espaços de memória 
para o armazenamento dos nossos dados.
Qualquer dado que seja manipulado pelo programa deve ficar 
armazenado na memória principal do computador. Para que o 
armazenamento seja possível, precisaremos reservar espaços na 
memória principal do computador. As variáveis e constantes são 
unidades básicas de armazenamento dos dados em programação. 
Elas são um espaço de memória reservado para armazenar um certo 
tipo de dado e possuem um identificador (nome) para referenciar o 
seu conteúdo. Dessa forma, nossos dados ficam armazenados em 
constantes ou variáveis.
Uma variável pode conter, a cada instante, valores diferentes. No 
43
Programação 2
entanto, as constantes referem-se a valores fixos que não podem 
ser alterados durante a execução do programa. O modo como cada 
constante é representada depende do seu tipo (este assunto será 
detalhado um pouco mais a frente).
Para entender o conceito de variáveis e constantes, vamos fazer 
a seguinte analogia: um armário cheio de gavetas de tamanhos 
diferentes. Acompanhem o raciocínio: Pedro tem um armário e 
decide que em cada gaveta será guardado um tipo de roupa: camisa, 
bermuda, calça, etc.
Figura 3.1: Armário cheio de gavetas
Em uma dada gaveta, só podem ser armazenadas camisas. Não 
será permitido o armazenamento de calças nesta gaveta. Para facilitar 
a identificação, Pedro coloca uma etiqueta informando o que cada 
gaveta guarda. Com isso, Pedro poderá identificar, rapidamente, em 
qual a gaveta estão guardadas suas camisas. 
Agora vamos associar a ideia das gavetas com a ideia de variáveis, 
constantes e tipo. As gavetas que guardam as roupas são como os 
espaços de memória que armazenam nossos dados. Assim como uma 
gaveta só pode armazenar um tipo de roupa, os espaços de memória 
são especificados para armazenar um tipo de dado. Dependendo do 
tipo de roupa, a gaveta precisa ser maior ou menor. Da mesma forma, 
dependendo do tipo de dado, é feito uma reserva de mais ou menos 
memória para armazená-lo (de acordo com as tabelas da seção 3.1).
As etiquetas das gavetas são os identificadores dos nossos 
44
Programação 2
espaços de memória. Assim, iremos encontrar, facilmente, um dado 
armazenado nos nossos espaços de memória. Quando temos uma 
variável, o conteúdo da nossa gaveta pode mudar ao longo do 
tempo. Mas, no caso de uma constante, seu conteúdo será sempre o 
mesmo.
Nas próximas seções, vamos aprender as regras para dar nomes 
às nossas variáveis e constantes e como criar as nossas gavetas – 
espaços de memória (variáveis e constantes).
3.2.1. Identificadores
Para que o compilador saiba quais dados estamos querendo 
manipular, eles precisam ter um nome. É como nós, todos temos um 
nome. Sabemos quando alguém está nos chamando quando falam 
o nosso nome. Vai acontecer a mesma coisa com os espaços de 
memória dos nossos programas, precisamos identificá-los, de alguma 
forma. Os identificadores são os nomes que damos as nossas 
variáveis, constantes, funções e procedimentos usados no programa. 
Para criar um identificador é necessário respeitar as regras a seguir:
• O primeiro caractere deve ser uma letra ou _ (underscore);
• O restante do nome deve ser formado por caracteres 
pertencentes ao seguinte conjunto: a,b,c,..z, A,B,C,...Z, 
0,1,2,...,9, _ (ou seja: letras, números e underscore);
• Não deve haver espaço em branco (ou seja, não existe 
identificadores compostos, formados por dois ou mais nomes);
• Não utilizar acentos, nem cedilha;
• Os identificadores podem ter até 32 caracteres;
• Não deve haver identificadores repetidos (Se dermos o mesmo 
nome para duas variáveis do nosso programa, o compilador 
não vai saber qual delas será chamada, e isso não pode 
acontecer).
A linguagem C faz distinção de maiúsculas e minúsculas. Assim, 
os identificadores: Media, MEDIA, MediA e media, são diferentes. 
O fato de termos uma única letra de forma diferente (maiúscula ou 
minúscula), já faz com que os identificadores se diferenciem. Esta 
propriedade é chamada de case sensibility (sensibilidade a letras 
maiúsculas e minúsculas).
45
Programação 2
DICA: Boa Prática de Programação
Escolham bem os nomes das variáveis e constantes do 
programa. Os identificadores escolhidos devem ser claros, a fim 
de explicitar o conteúdo que será armazenado, mas também 
não devem ser extensos para não dificultar a escrita.
A seguir, vamos verificar exemplos de identificadores corretos e 
incorretos:
• Identificadores corretos: a, x2, Nome_Aluno, Media, 
SalarioFuncionario. Note que, quando queremos usar 
identificadores com mais de uma palavra, que foi o caso de 
Nome_Aluno, usamos o _ para ligar uma palavra a outra. Ou 
usamos as palavras juntas, como o exemplo SalarioFuncionario. 
Lembrando que não podemos usar espaço em branco.
• Identificadores incorretos: 2m (começou com número), 
media* (caractere * não é permitido), Nome disciplina (não pode 
haver espaço em branco), funcionário (não pode acentuar).
Até este momento, vimos os conceitos de tipos de dados, variáveis, 
constantes e identificadores. Na próxima seção, estes conceitos 
serão utilizados em conjunto, para que possamos declarar as nossas 
variáveis, ou seja, criar espaços de memória para armazenar os dados 
manipulados pelo nosso programa. Continuemos a nossa leitura.
3.2.2. Declaração de Variáveis
Para que se possa usar uma variável em um programa, 
primeiramente, é necessário fazer a declaração dela. A declaração 
de uma variável informa ao processador duas coisas: o identificador 
(nome) da variável e o seu tipo de dado. As variáveis precisam de 
um nome para que o processador saiba onde desejamos armazenar 
o nosso dado. Além disso, toda variável precisa ser associada a um 
tipo de dado, para que o processador reserve o espaço de memória 
necessário para o seu armazenamento. Como visto na seção 3.1, cada 
tipo de variável, ocupa uma quantidade de bits diferente. Resumindo, 
toda variável possui um nome, um tipo e um conteúdo (ou valor que é 
armazenado na variável).
46
Programação 2
A declaração de variáveis deve obedecer a seguinte sintaxe:
Sintaxe
tipo [variavel_1, variavel_2, ...];
Onde tipo é o tipo de dado (int, float, char) e variavel_1 é o nome 
da variável a ser declarada. O nome da variável deve seguir a regra 
dos identificadores (mencionadas na seção 3.2.1). Se houver mais de 
uma variável do mesmo tipo, seus nomes são separados por vírgulas. 
Notem que, no final do comando, aparece um ponto e virgula (;), 
indicando ao compilador que o comando terminou.
Exemplo 3.1: Declaração de Variáveis
1
2
3
int idade, matricula;
float media, total;
char letra, nome_aluno[20];
As variáveis idade e matricula são espaços de memória que 
armazenam números inteiros. As variáveis media e total armazenam 
números reais. Note que na linha 3, temos as variáveis letra e 
nome_aluno. Quando uma variável caractere tem apenas um único 
caractere, nasua declaração, é necessário apenas dar um nome a 
esta variável. 
Quando houver necessidade de armazenar vários caracteres, 
temos o que é chamado de cadeia de caracteres, vetor de caracteres 
ou string. Uma cadeia de caracteres forma uma palavra ou frases. Para 
declarar uma variável capaz de armazenar uma cadeia de caracteres, 
devemos colocar ao lado do nome da variável, entre colchetes, um 
valor inteiro, que significa quantos caracteres podem ser armazenados 
nesta cadeia. Assim, a variável nome_aluno, declarada na linha 3, tem 
capacidade de armazenar uma palavra/frase com até 20 caracteres.
A figura 3.2 representa a memória do computador, após a declaração 
das variáveis do exemplo. Cada caixa representa uma variável. E, 
cada variável possui o seu identificador. Assim, esta declaração de 
variáveis resultou na reserva de seis espaços na memória. Toda vez 
que precisarmos acessar ou armazenar o conteúdo de uma variável, 
utilizaremos o seu identificador.
47
Programação 2
Figura 3.2: Representação da memória do computador 
após a declaração de um conjunto de variáveis
Atenção
Como dito anteriormente, o C difere as letras minúsculas 
das maiúsculas. Assim, os tipos de dados e comandos que 
iremos aprender ao longo da disciplina, DEVEM ser escritos em 
minúsculo. Se vocês fizerem a seguinte declaração : Int x,y; Vai 
ocorrer um erro no momento da compilação do seu programa, 
já que o C não conhece o tipo Int com “I” maiúsculo. Fiquem 
atentos, pois esse é um erro comum para quem está começando 
a programar em C.
 
De acordo com o que foi visto, quando estudamos a estrutura 
da um programa C, as variáveis devem ser declaradas logo quando 
inicia o corpo do programa principal. Vamos estudar, a seguir, como 
fazemos para declarar as nossas constantes.
3.2.3. Declaração de Constantes
Diferente das variáveis, as constantes mantêm seu valor ao 
longo do programa. Para indicar ao compilador que se trata de uma 
constante, a diretiva de compilação #define é utilizada. Segue a 
sintaxe da declaração de uma constante.
Sintaxe
#define <identificador> <valor>
48
Programação 2
Não é necessário colocar o ponto e vírgula no final da linha e 
também não precisa informar o tipo de dado da constante. O valor 
de uma constante não pode ser modificado, de maneira alguma, ao 
longo da execução do programa.
O modo como cada constante é representada depende do seu 
tipo. Constantes do tipo inteiro são representadas por números sem 
o componente fracionário, por exemplo, 123 e 2009. Constantes reais 
precisam do uso de ponto decimal seguido do componente fracionário 
do número, por exemplo, 302.54. Constantes caractere são colocadas 
entre apóstrofos, por exemplo, ‘a’. Constantes cadeia de caractere 
são colocadas entre aspas duplas, por exemplo, “Casa” e “Maria”. A 
seguir são apresentadas as declarações de quatro constantes:
Exemplo 3.2: Declaração de Constantes
1
2
3
4
#define DIAS 7
#define PI 3.1416 
#define RESPOSTA ‘s’ 
#define DISCIPLINA “Matemática”
De acordo com o exemplo, a constante DIAS irá armazenar sempre 
7. Como o valor que esta constante recebeu foi um valor inteiro, o 
compilador entende, automaticamente, que esta é uma constante 
inteira. Da mesma forma, como a constante PI recebeu 3.1416 (um 
número real), o compilador saberá que se trata de uma constante do 
tipo real. A constante RESPOSTA armazena um char e DISCIPLINA 
uma cadeia de caracteres.
É interessante declarar uma constante quando sabemos que um 
valor não será modificado ao longo da execução do programa. Por 
questões de padronização, declare as suas constantes com todas as 
letras em maiúsculo, como apresentado nos exemplos. Assim você 
estará diferenciando-as das variáveis.
De acordo com a estrutura de um programa C, as nossas 
constantes são declaradas no início do programa, logo após incluirmos 
as bibliotecas que serão utilizadas. Estão lembrados(as) disso? Se 
não estão, deem uma revisada na seção 2.1, certo?
Ao serem criadas, as constantes já recebem o valor que elas vão 
armazenar ao longo do programa. Isto não acontece com as variáveis. 
49
Programação 2
Mas como fazemos para armazenar um valor em uma variável? Esta 
resposta vocês encontrarão na próxima seção.
3.3. Operador de Atribuição (=)
Esse operador é utilizado para armazenar um valor em uma dada 
variável. Assim, o operador de atribuição nos possibilita armazenar 
um dado em um espaço de memória, que foi previamente declarado. 
É importante que o dado que será armazenado seja compatível com 
o tipo da variável que receberá a atribuição. Por exemplo, as variáveis 
reais podem receber valores reais e inteiros. No entanto, uma variável 
inteira, não pode receber um valor real. Segue a sintaxe do operador 
de atribuição.
Sintaxe
Variavel = Valor;
Variavel_1 = Variavel_2;
Variavel = Expressão Aritmética;
Variavel = função;
Variavel_1 = variavel_2 = variavel_3 = valor;
O operador de atribuição é representado pelo símbolo =. No lado 
esquerdo do operador da atribuição, temos a variável que vai receber 
o valor. No lado direito do operador, temos o valor que será atribuído 
à variável. Ao final da linha de atribuição deve ter um ponto e vírgula.
Notem que o operador de atribuição permite várias possibilidades. 
Para um melhor entendimento, o exemplo 3.3 apresenta cada uma 
das possibilidades do operador de atribuição. 
50
Programação 2
Exemplo 3.3: Comando de atribuição 
1
2
3
4
5
6
7
8
9
float Media, X, Y, Z;
int J, L, M, K, A, B;
char Letra;
Media = 7.5;
Letra = ’D’;
X = Y;
K = A + B;
Z = sqrt(4);
J = L = M = 10;
Nas linhas 1, 2 e 3, temos a declaração das variáveis. Lembrem 
que só podemos armazenar algum valor, caso tenhamos declarado 
as variáveis. Uma vez que é necessário ter reservado espaços de 
memória para nossos dados, entendido?
Na linha 4, a variável Media recebeu 7.5 (para números reais, 
devemos utilizar ponto ao invés de virgula, para separar a parte inteira 
da parte fracionária do número)19.
Na linha 5, temos uma atribuição para uma variável char com um 
único caractere. Note que, neste caso, o valor que a variável receberá 
vem entre apóstrofo. Assim, a variável Letra está recebendo D.
Atenção
 O operador de atribuição não é usado para variáveis do tipo 
char com vários caracteres. Este tipo de atribuição será visto no 
capítulo “Comandos de Manipulação de Caracteres”, do Volume 
4.
Na linha 6, a variável X receberá o valor que está armazenado 
na variável Y. Na linha 7, a variável K irá receber o resultado da 
Saiba Mais
19Onde aparece o 
= do comando de 
atribuição, nos 
lemos: “recebe”. 
Assim, o 
comando da linha 
4 do exemplo 3.3, 
seria lido: “Media 
recebe 7.5”.
51
Programação 2
expressão A + B, ou seja, será obtido o valor armazenado na variável 
A, depois o valor da variável B, os valores são somados e o resultado é 
atribuído a variável K. Uma variável sempre recebe um valor. Quando 
a atribuição tem uma expressão matemática, a expressão é resolvida 
e o resultado é atribuído a variável. 
Na linha 8, a variável Z receberá o resultado da chamada da função 
sqrt (que faz o cálculo da raiz quadrada de um número). Veremos 
mais detalhes sobre estas funções no capítulo 5.
Na linha 9, aparece o que chamamos de atribuição em cadeia. 
Quando várias variáveis vão receber o mesmo valor, ao invés de 
ser feita uma atribuição de cada vez, podemos dizer: variavel1 = 
variavel2 = variavel3 = valor. Nós podemos atribuir o mesmo valor a 
quantas variáveis quisermos. Coloquei um exemplo com três, certo? 
No exemplo da linha 9, as variáveis K, L e M vão receber 10. Mas 
tem um detalhe, nós só podemos usar a atribuição em cadeia quando 
todas as variáveis que irão receber o valor são do mesmo tipo. Assim, 
nesta atribuição