ALGORITMOS E PROGRAMAÇÃO APLICADA

Prévia do material em texto

ALGORITMOS E 
PROGRAMAÇÃO APLICADA
PROF. FÁBIO ATAIDE DE LIMA
PROFA MA. CLAUDIA HEIDEMANN DE SANTANA
Reitor: 
Prof. Me. Ricardo Benedito de 
Oliveira
Pró-Reitoria Acadêmica
Maria Albertina Ferreira do 
Nascimento
Diretoria EAD:
Prof.a Dra. Gisele Caroline
Novakowski
PRODUÇÃO DE MATERIAIS
Diagramação:
Edson Dias Vieira
Thiago Bruno Peraro
Revisão Textual:
Fernando Sachetti Bomfim
Marta Yumi Ando
Simone Barbosa
Produção Audiovisual:
Adriano Vieira Marques
Márcio Alexandre Júnior Lara
Osmar da Conceição Calisto
Gestão de Produção: 
Cristiane Alves
© Direitos reservados à UNINGÁ - Reprodução Proibida. - Rodovia PR 317 (Av. Morangueira), n° 6114
 Prezado (a) Acadêmico (a), bem-vindo 
(a) à UNINGÁ – Centro Universitário Ingá.
 Primeiramente, deixo uma frase de 
Sócrates para reflexão: “a vida sem desafios 
não vale a pena ser vivida.”
 Cada um de nós tem uma grande 
responsabilidade sobre as escolhas que 
fazemos, e essas nos guiarão por toda a vida 
acadêmica e profissional, refletindo diretamente 
em nossa vida pessoal e em nossas relações 
com a sociedade. Hoje em dia, essa sociedade 
é exigente e busca por tecnologia, informação 
e conhecimento advindos de profissionais que 
possuam novas habilidades para liderança e 
sobrevivência no mercado de trabalho.
 De fato, a tecnologia e a comunicação 
têm nos aproximado cada vez mais de pessoas, 
diminuindo distâncias, rompendo fronteiras e 
nos proporcionando momentos inesquecíveis. 
Assim, a UNINGÁ se dispõe, através do Ensino a 
Distância, a proporcionar um ensino de qualidade, 
capaz de formar cidadãos integrantes de uma 
sociedade justa, preparados para o mercado de 
trabalho, como planejadores e líderes atuantes.
 Que esta nova caminhada lhes traga 
muita experiência, conhecimento e sucesso. 
Prof. Me. Ricardo Benedito de Oliveira
REITOR
33WWW.UNINGA.BR
U N I D A D E
INTRODUTÓRIA
U N I D A D E
SUMÁRIO DA UNIDADE
INTRODUÇÃO ................................................................................................................................................................4
1 ORGANIZAÇÃO BÁSICA DE UM SISTEMA COMPUTACIONAL ..............................................................................5
1.1 EVOLUÇÃO DOS SISTEMAS COMPUTACIONAIS .................................................................................................5
1.2 COMPONENTES DE UM SISTEMA COMPUTACIONAL ....................................................................................... 7
1.2.1 HARDWARE .......................................................................................................................................................... 7
1.2.2 SOFTWARE ...........................................................................................................................................................9
1.3 SISTEMAS DE NUMERAÇÃO UTILIZADOS NOS SISTEMAS COMPUTACIONAIS ............................................ 11
1.3.1 SISTEMA DECIMAL ............................................................................................................................................. 12
1.3.2 SISTEMA BINÁRIO ............................................................................................................................................. 13
1.3.3 SISTEMAS OCTAL E HEXADECIMAL ................................................................................................................ 13
CONSIDERAÇÕES FINAIS ........................................................................................................................................... 15
ORGANIZAÇÃO BÁSICA DE UM
SISTEMA COMPUTACIONAL
PROFA MA. CLAUDIA HEIDEMANN DE SANTANA
ENSINO A DISTÂNCIA
DISCIPLINA:
ALGORITMOS E PROGRAMAÇÃO APLICADA
4WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 IN
TR
OD
UT
ÓR
IA
EDUCAÇÃO A DISTÂNCIA
INTRODUÇÃO
Você está pronto(a) para iniciar seus estudos introdutórios sobre Algoritmos e 
Programação Aplicada? Especificamente nesta unidade introdutória, vamos trabalhar sobre a 
organização básica de um sistema computacional. Pronto(a) para o início da aprendizagem?
Caro(a) aluno(a), esta unidade procura explicar algumas definições, conceitos e 
curiosidades sobre os Sistemas Computacionais e seus principais componentes. Você também 
aprenderá a categorizar as principais partes de um computador e as diferenças entre elas.
Ao final desta unidade, você deve apresentar os seguintes aprendizados:
• Reconhecer processamento de dados e sistemas de computação; 
• Identificar a evolução dos computadores;
• Descrever a diferença entre hardware e software;
• Conhecer sobre os Sistemas de Numeração utilizados nos sistemas digitais.
Em um mundo cada vez mais digital, é necessário conhecer os termos básicos relacionados 
à informática. Seja qual for a sua área, a tecnologia e os sistemas digitais estão cada vez mais 
presentes no nosso dia a dia, no celular, na TV, no carro, no ar-condicionado e até mesmo no seu 
grill.
5WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 IN
TR
OD
UT
ÓR
IA
EDUCAÇÃO A DISTÂNCIA
1 ORGANIZAÇÃO BÁSICA DE UM SISTEMA COMPUTACIONAL
“O software tornou-se o elemento-chave da evolução e produtos baseados em 
computador” (PRESSMAN, 1995).
Um Sistema Computacional é um tipo especializado de sistema, que tem como finalidade 
processar e armazenar informações. O que torna os sistemas computacionais tão essenciais hoje? 
O que você está fazendo agora? Utilizando o computador, não é verdade? Mas o que está por trás 
deste monitor? O que torna possível você acessar este curso?
No computador, existem componentes envolvidos no processo, vale dizer, o sistema 
computacional. Esse sistema possui dois componentes principais: o Software e o Hardware.
Um sistema computacional refere-se ao conjunto de dispositivos eletrônicos (hardware) 
que processam informações através de um programa (software). Ele é uma combinação de 
hardware, software e inteligência humana.
Vou explicar melhor os componentes de um Sistema Computacional:
Hardware: é o equipamento físico, computadores e periféricos. Juntos, processam dados 
e informações e permitem sua visualização.
Software: consiste nas instruções, conjunto de programas que permitem que o hardware 
processe os dados. São divididos em duas principais categorias: Sistema Operacional - controla 
e coordena o uso do hardware entre os vários programas de aplicação de vários usuários; e 
Programas de Aplicação - definem como os recursos do sistema serão utilizados pelos usuários 
(gerenciadores de bancos de dados, antivírus, editores de texto, planilhas eletrônicas etc.). 
Veremos mais adiante, com mais detalhes, sobre software e seus diferentes tipos.
Para completar este sistema, temos ainda os usuários, que são os indivíduos que trabalham 
com o sistema ou utilizam a sua saída. São usuários e operadores de hardware e software.
Assim, já temos os elementos para um sistema computacional, mas, no caso da pergunta 
inicial, que envolvia como você está tendo acesso a este curso, temos ainda:
- Tecnologia de redes: sistema de ligação, que permite o compartilhamento de recursos 
entre computadores.
- Tecnologia de dados: softwares e hardwares que comandam a organização dos dados 
em meios físicos de armazenagem.
1.1 Evolução dos Sistemas Computacionais
Os sistemas computacionais evoluíram com o passar do tempo (assim como a tecnologia), 
passando da operacionalização das tarefas rotineiras à integração entre os diferentes sistemas, 
com recursos e usos diferenciados.
Dos primeiros computadores à Internet: nesse vídeo, você verá 
sobre a evolução dos computadores, sua utilização, primeiros 
games, interfaces, surgimento da Internet no mundo e primeiras 
experiências no Brasil.
Acesse-o em https://www.youtube.com/watch?v=Sx1Z_
MGwDS8&t=28s.
https://www.youtube.com/watch?v=Sx1Z_MGwDS8&t=28s
https://www.youtube.com/watch?v=Sx1Z_MGwDS8&t=28s
6WWW.UNINGA.BR
AL
GO
RI
TM
OSE
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 IN
TR
OD
UT
ÓR
IA
EDUCAÇÃO A DISTÂNCIA
Cronologicamente, a evolução dos sistemas computacionais se deu em cinco gerações, 
que são: computadores à válvula, computadores a transistor, circuitos integrados, circuitos VLSI 
e tecnologia ULSI (Ultra Large Scale Integration). O primeiro computador, segundo pesquisas, foi 
desenvolvido pelo engenheiro mecânico Charles Babbage, que inventou o primeiro equipamento 
considerado um computador mecânico, ainda no século XIX. Já na década de 1940, os 
computadores de uso geral, que usavam algoritmos simples para perfurar cartões, substituíram 
os computadores mecânicos, sendo o ENIAC (Electronic Numerical Integrator and Computer) o 
primeiro computador digital eletrônico programável e principal representante dessa primeira 
geração.
Da segunda geração, marcada pelos transistores (e com eles a possibilidade de 
comercialização do computador), podemos destacar o UNIVAC ERA 1101, que foi o primeiro 
programa de computador armazenado nos EUA. Os transistores eram também mais rápidos que 
as válvulas e, portanto, eles também contribuíram para aumentar a velocidade computacional.
Figura 1 - UNIVAC/ERA 1101: primeiro computador da história que rodava um programa da memória.
Fonte: Dibble (2021).
Portanto, os computadores da era dos transistores (ou da segunda geração) eram não só 
mais pequenos, mas também mais rápidos que os das válvulas eletrônicas.
Com a terceira geração (no início da década de 1960, surgimento dos circuitos integrados 
(CHIP)), viu-se a diminuição do tamanho, maior capacidade de processamento e início da 
utilização dos computadores pessoais. Surgiram os softwares integrados, como processadores de 
texto, planilhas eletrônicas e outros.
 
Figura 2 - Intel 8008, 1972 - primeiro microprocessador de 8 bits.
Fonte: Wikiwand (2021).
7WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 IN
TR
OD
UT
ÓR
IA
EDUCAÇÃO A DISTÂNCIA
Já a quarta geração, iniciada nos anos 1970, ficou conhecida pela grande massa de 
microcomputadores pessoais, com circuitos integrados VLSI – Very Large Scale Integration – e 
integração em escala muito alta. Em 1977, houve uma explosão no mercado de microcomputadores, 
sendo fabricados em escala comercial, e, a partir daí, a evolução foi sendo cada vez maior, até 
chegar aos micros atuais, os microprocessadores de ULSI (Ultra Large Scale of Integration), 
utilizados a partir de 1980. Nessa geração, começa a utilização das linguagens de altíssimo nível, 
orientadas para um problema.
A quinta geração é baseada em hardware de processamento paralelo (que é uma forma 
de computação em que vários cálculos são realizados ao mesmo tempo) e na IA (Inteligência 
Artificial) do software. A inteligência artificial é um “novo” ramo da ciência da computação, 
que interpreta meios e métodos de fazer computadores pensar como seres humanos. Todas 
as linguagens de alto nível, robótica, desenvolvimento de sistemas especialistas e a era online, 
comunicação através da Internet, fazem parte desta geração.
Figura 3 - Exemplo de um computador de quinta geração. Fonte: Gerações de Computadores (2021).
Assim, vimos como os computadores vêm evoluindo e acompanhando os avanços nos 
campos da matemática, engenharia e eletrônica. Os computadores passaram por muitas mudanças 
e foram continuamente aprimorados ao longo do tempo. Continuam seguindo a tendência de 
miniaturização de seus componentes, tornando-se cada vez mais práticos para as tarefas diárias.
1.2 Componentes de um Sistema Computacional
Um sistema de computação é composto por três (3) componentes principais: hardware, 
software e peopleware.
O peopleware são todos os usuários, as pessoas que, de alguma forma, trabalham e/ou 
interagem com o computador, como digitadores, programadores, analistas ou simplesmente 
usuários finais. Veremos agora, mais detalhadamente, os componentes de hardware e software.
1.2.1 Hardware
A parte física de um sistema computacional é o que chamamos de hardware. São todos 
os componentes de entrada e saída, componentes eletrônicos, circuitos integrados e placas. 
O “hardware” não se refere apenas aos computadores pessoais, mas também aos equipamentos 
embarcados em produtos que precisam de processamento computacional, como os dispositivos 
encontrados em equipamentos como micro-ondas, automóveis, máquinas, aparelho celular e outros.
8WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 IN
TR
OD
UT
ÓR
IA
EDUCAÇÃO A DISTÂNCIA
Para esta disciplina, é interessante entender que os componentes de hardware são divididos 
em sistema central (composto pela CPU - Unidade Central de Processamento (ou processador) 
-, Memória Principal e as suas interconexões) e os periféricos (que podem ser de Entrada, Saída 
e/ou Armazenamento e as suas interconexões).
De acordo com a arquitetura de von Neumann, a CPU (do inglês Central Processing 
Unit), que é Unidade Central de Processamento, armazena informações, controla as operações 
aritméticas e lógicas e efetua o processamento de entradas e saídas.
Figura 4 - Tráfego das informações na CPU. Fonte: Adaptado de Manzano e Manzano (2009).
A memória principal (ou memória primária) tem por finalidade o armazenamento de 
instruções e dados de programas que serão e/ou estão sendo executados pela CPU. É considerada 
como uma memória de trabalho, sendo organizada em células com tamanho fixo e igual, cada 
uma identificada por um número denominado endereço.
A memória principal pode ser acessada por meio de duas operações: leitura (ler da 
memória significa requisitar à memória principal o conteúdo de uma determinada célula) e 
escrita (escrever na memória significa escrever uma informação em uma célula da MP).
É classificada em dois grupos:
- RAM (do inglês Random Access Memory – Memória de Acesso Aleatório) dinâmica 
ou estática - esta memória volátil retém as instruções e dados de programas que estão sendo 
executados, tornando o tempo de leitura e escrita bastante rápido.
- ROM (do inglês Read Only Memory – Memória Somente de Leitura) - as informações são 
gravadas no momento da fabricação e não mais são alteradas. Contém basicamente informações 
necessárias para o funcionamento do computador, como rotinas que verificam se os meios físicos 
(hardware) estão aptos para o funcionamento. Outras versões de ROMs são PROM, EPROM, 
EEPROM ou EAPROM e memória flash.
A memória cache é uma memória (RAM estática) volátil de alta velocidade, localizada 
entre a CPU e a memória principal, usada com a finalidade de acelerar o processamento, 
funcionando como um buffer da memória.
As memórias secundárias são um tipo de memória não volátil de grande capacidade de 
armazenamento, usadas para guardar informações (instruções e dados de programas) que não 
são perdidas quando o computador for desligado. Como exemplos, podemos citar: disco rígido 
(HD) e mídias removíveis, como o CD-ROM, o DVD e o pendrive.
9WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 IN
TR
OD
UT
ÓR
IA
EDUCAÇÃO A DISTÂNCIA
- Dispositivos de Entrada e Saída de Dados:
No sistema computacional, todos os dispositivos que realizam as funções de receber e/
ou enviar as informações do usuário são considerados dispositivos de entrada e saída de dados.
Esses dispositivos externos são conectados em um computador e podem ser classificados 
em três categorias:
1. Os que transmitem/recebem informações inteligíveis para o ser humano - são 
adequados para estabelecimento de comunicação com o usuário. É o caso das 
impressoras, monitores de vídeo, plotters, multimídia etc.
2. Os que transmitem/recebem informações inteligíveis apenas para a máquina - são 
adequados para comunicação máquina a máquina ou internamente a uma máquina. 
É o caso dos teclados, mouses, scanners, discos magnéticos, fitas magnéticas, discos 
óticos, sensores e atuadores em aplicação robótica.
3. Os quetransmitem/recebem de/para outros dispositivos remotamente instalados, 
tais como os modems e regeneradores digitais.
1.2.2 Software
Já sabemos que vamos agora entender brevemente como os softwares são feitos.
As etapas para a execução de uma tarefa, elaboradas e executadas passo a passo, constituem 
o que se chama programa, ou também chamadas de software. Cada um dos passos mencionados 
é uma diferente instrução, ou ordem de comando, dada ao hardware com o objetivo de realização 
de uma determinada tarefa e/ou ação (por exemplo: uma operação aritmética, uma transferência 
de informação). O programa (software) é o conjunto dessas instruções.
Córdova et al. (2018) nos dizem que o computador é uma máquina que resolve problemas 
por meio da execução de instruções que são passadas a ele. Essas instruções são chamadas de 
programas de computador. O programa é um conjunto de instruções lógicas e finitas (também 
chamado de algoritmo), que executam uma tarefa específica.
Um programa de computador é a formalização de um algoritmo, em linguagem inteligível 
pelo computador.
Figura 5 - Fases do processamento de um software. Fonte: A autora.
Assim, o computador precisa entender cada instrução de modo a executar corretamente 
a operação que se pretende. O usuário entende Português, sua linguagem de comunicação com 
outras pessoas. Os computadores têm uma linguagem própria, a linguagem binária. Nela, os 
caracteres inteligíveis são apenas zero (0) e um (1), presença ou ausência de corrente elétrica. Todo 
dado coletado pelos computadores, as instruções por eles executadas, bem como os resultados de 
um processamento são sempre constituídos de conjuntos ordenados de zeros e uns. 
10WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 IN
TR
OD
UT
ÓR
IA
EDUCAÇÃO A DISTÂNCIA
Como o computador não entende nossa linguagem, ela deve ser compilada. Esse processo 
de compilação, em termos gerais, consiste em transformar uma linguagem em outra, neste caso, 
as nossas instruções para a linguagem binária (0 e 1), que é a linguagem que o computador 
compreende. Isso é feito por um tipo de software/sistema chamado Linguagem de Programação.
Assim, podemos entender que o conceito de software refere-se a todos os elementos de 
programação de um sistema de computação, isto é, a todos os programas, sejam eles de softwares 
de aplicação sejam softwares básicos.
a) Software básico: são os programas que definem o padrão do equipamento, sendo 
necessários para o seu funcionamento. Os tipos de software básico são: sistema operacional, 
linguagens de programação, tradutores e utilitários.
b) Software aplicativos: são programas para as mais variadas finalidades e situações, são 
utilizados pelos usuários para realizar trabalhos rotineiros. Exemplos: editores de texto, 
calculadoras, aplicativos para ouvir músicas, aplicativos para contabilidade e de recursos 
humanos.
Vamos dar destaque a dois tipos de softwares, importantes para o nosso domínio de 
conhecimento na disciplina de Algoritmos e Programação Aplicada. São eles:
Sistema Operacional: segundo Manzano e Manzano (2009), o sistema operacional (SO) 
é responsável pelo gerenciamento, funcionamento e execução de todos os programas e todos os 
periféricos do sistema computacional. Sem o SO, o computador não tem “vida”, é um software 
que se encontra na categoria dos programas de sistema. Ele é o mais importante entre todos, 
pois representa o papel de tradutor e intérprete entre a máquina e o homem (e vice-versa) e 
gerencia todos os periféricos e softwares, pois trabalha juntamente com a CPU. Entre os sistemas 
operacionais, citem-se: Microsoft Windows; OS/2; Unix; Mac/OS.
Figura 6 - Posicionamento de um Sistema Operacional num Sistema Computacional. Fonte: A autora.
Linguagens de Programação: é um conjunto de símbolos (vocabulário) e regras 
(gramática) que especificam como transmitir informações entre usuários e computador. As 
linguagens de programação estão divididas em: linguagem de máquina, linguagem de baixo nível 
e linguagem de alto nível.
11WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 IN
TR
OD
UT
ÓR
IA
EDUCAÇÃO A DISTÂNCIA
A linguagem de máquina é baseada em código binário, em 0s e 1s. É utilizada diretamente 
pelo computador. A linguagem de baixo nível é uma simplificação da linguagem de máquina. 
Faz uso de códigos mnemônicos para expressar as instruções. Exemplo: Assembly. A linguagem 
de alto nível utiliza a combinação de um conjunto de símbolos de acordo com certas regras de 
sintaxe para expressar uma sequência de operações de máquina. É uma linguagem que não exige 
conhecimento do código binário. Exemplo: C, JAVA, Python.
1.3 Sistemas de Numeração Utilizados nos Sistemas Computacionais
A história da matemática conta sobre a necessidade de contar do ser humano desde 
que ele deixou de ser nômade. A necessidade de contagem foi impulsionada por atividades de 
agricultura e pastoreio, pela representação da quantidade de cabeças em um rebanho, fases da 
Lua e estações do ano para o plantio etc. Dessa forma, a representação numérica foi ganhando 
forma por meio dos algarismos.
O sistema de numeração é um conjunto de regras para a representação dos números. 
O sistema numérico decimal é o mais utilizado pela humanidade. Acredita-se que o número 
de dedos que o homem tem nas mãos foi um fato decisivo, nos primórdios, para a criação e 
disseminação desse sistema.
Um sistema de numeração é definido principalmente pela BASE, que indica a quantidade 
de símbolos e o valor de cada símbolo. Exemplos: Sistema Decimal (base 10): 0, 1, 2, 3, 4, 5, 6, 
7, 8, 9; Sistema Binário (base 2): 0, 1; Sistema Octal (base 8): 0, 1, 2, 3, 4, 5, 6, 7, 8; e Sistema 
Hexadecimal (base 16): 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
Com o advento da eletrônica digital e, principalmente, do computador, surgem outras 
necessidades, como a de representar os números utilizando a eletricidade. Como você já sabe, 
um computador funciona movido à energia elétrica. A ausência ou presença de energia (0v ou 
+5v) é representada por 0’s e 1’s, ou seja, o Sistema Binário. O matemático indiano Pingala 
apresentou a primeira descrição conhecida de um sistema numérico binário no século III a.C., 
representando os números de 1 a 8 com a sequência (usando símbolos modernos) 000, 001, 010, 
011, 100, 101,110 e 111.
Nesse contexto computacional, o computador opera valores utilizando a lógica binária 
que trabalha com o sistema binário que contém somente dois algarismos: 0 e 1. Para simplificar 
a codificação de instruções em nível de máquina, são utilizadas conversões para outros tipos de 
sistemas de numeração a fim de tornar a definição das instruções mais inteligível ao ser humano.
Veja uma linha do tempo da história do software e das linguagens de 
programação. Acesse: https://www.computerhistory.org/timeline/
software-languages/.
https://www.computerhistory.org/timeline/software-languages/
https://www.computerhistory.org/timeline/software-languages/
12WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 IN
TR
OD
UT
ÓR
IA
EDUCAÇÃO A DISTÂNCIA
Figura 7 - Representação dos dados. Fonte: A autora.
Por fim, como a representação de números binários de alto valor torna os dígitos quase 
ilegíveis para nós, é comum utilizar o sistema hexadecimal para abreviá-los, pois cada dígito 
hexadecimal guarda 4 dígitos binários.
A seguir, vamos detalhar alguns sistemas numéricos presentes na nossa vivência com os 
sistemas computacionais.
1.3.1 Sistema decimal
É o nosso sistema mais familiar. Sua base numérica é de dez, ou seja, a quantidade de 
símbolos é 10. De zero a nove, utilizam-se dez algarismos diferentes para representar todos os 
números - 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. É um sistema posicional, ou seja, a posição do algarismo no 
número modifica o seu valor. Ou seja, cada número em uma sequência de algarismos tem valor 
diferente, dependendode sua posição.
Veja um exemplo: no número decimal 777, cada cinco tem um valor diferente. O primeiro 
vale sete centenas (700); o segundo, sete dezenas (70); e o terceiro, sete unidades (7). O valor 
final é fornecido por 777 = 700 + 70 + 7 = 7 * 102 + 7 * 101 + 7 * 100. Os pesos das posições são 
potências de dez, no caso do sistema decimal.
Veremos em seguida os sistemas binário, octal e hexadecimal, que também são sistemas 
posicionais, mas, no sistema binário são potências de dois, no octal são potências de oito e no 
sistema hexadecimal são potências de 16.
Você sabe o que é Código ASCII?
O Código ASCII - American Standard Code for Information Interchange (Código 
Padrão Americano para o Intercâmbio de Informação) - é baseado no alfabeto 
romano, e sua função é padronizar a forma como os computadores representam 
letras, números, acentos, sinais diversos e alguns códigos de controle. Foi proposto 
por Robert W. Bemer, visando a padronizar os códigos. Assim, foi possível que 
computadores de diferentes fabricantes conseguissem entender os códigos. Ele 
é um padrão de codificação de letras e símbolos bastante antigo e usado até hoje.
13WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 IN
TR
OD
UT
ÓR
IA
EDUCAÇÃO A DISTÂNCIA
1.3.2 Sistema binário
Representação binária ou de base 2, este sistema usa apenas dois símbolos básicos: o 0 e o 
1. É um sistema de numeração posicional em que todas as quantidades se representam com base 
nos algarismos zero e um. Da mesma forma que no sistema decimal discutido antes, cada dígito 
pode ser representado pela sua potência ou peso.
Palavras binárias com certas quantidades de dígitos podem adquirir nomes especiais, por 
exemplo, um dígito binário é chamado de BIT, proveniente das palavras inglesas BInary digiT.
O bit, do inglês BInary digiT, é um símbolo ou elemento que pode representar dois 
estados possíveis, como uma luz que está ligada (1) ou desligada (0). Em computadores, o valor 
0 é usualmente associado a alguma voltagem baixa, e o valor 1, a uma voltagem mais alta. No 
momento atual, um grande número de tecnologias tem convergido para o uso da representação 
binária, usando diferentes meios para a representação física do bit.
1.3.3 Sistemas octal e hexadecimal
Até o momento, foi discutido que os computadores digitais usam o sistema de numeração 
binária (base 2) por sua facilidade em associar seus dois possíveis valores, 0 e 1, a fenômenos 
físicos que ocorrem internamente no computador. Outros sistemas numéricos utilizados na 
computação são os sistemas de numeração octal e hexadecimal, que compactam significativamente 
a representação de números binários, ou seja, a principal utilização para números hexadecimal e 
octal em computação é abreviar longas representações binárias. 
A Tabela 1 representa números binários longos e como eles podem ser expressos 
brevemente em sistemas de numeração com bases mais altas.
Tabela 1 - Equivalentes decimais, binários, octais e hexadecimais.
Número Decimal Representação Binária Representação Octal Representação Hexadecimal
0 0 0 0
1 1 1 1
2 10 2 2
3 11 3 3
4 100 4 4
5 101 5 5
6 110 6 6
7 111 7 7
8 1000 10 8
9 1001 11 9
10 1010 12 A
11 1011 13 B
12 1100 14 C
13 1101 15 D
14 1110 16 E
15 1111 17 F
16 100000 20 10
Fonte: A autora.
14WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 IN
TR
OD
UT
ÓR
IA
EDUCAÇÃO A DISTÂNCIA
Um relacionamento importante que os sistemas de numeração octal (como o hexadecimal) 
têm com o binário é que as bases octal e hexadecimal são potências da base do sistema de 
numeração binário.
Considere o número binário de 12 algarismos 100011010001. Para ver como o número 
binário é facilmente convertido em octal, divida o número binário de 12 dígitos em grupos de três 
bits consecutivos cada e escreva esses grupos sobre os dígitos correspondentes do número octal 
como a seguir, de acordo com o seu correspondente na Tabela 1.
Binário 100 011 010 001 
Otal 4 3 2 1 
O mesmo tipo de relacionamento pode ser observado ao se converter de binário para 
hexadecimal. Divida o número binário de 12 algarismos em grupos de quatro bits consecutivos 
cada e escreva esses grupos sobre os dígitos correspondentes do número hexadecimal como a 
seguir:
Binário 1000 1101 0001 
Hexa 8 D 1
O sistema hexadecimal está vinculado aos sistemas computacionais, pois os computadores 
costumam utilizar o byte como unidade básica da memória, 1 byte = 8 bits e, então, um byte pode 
ser representado por 8 algarismos do sistema binário ou por 2 algarismos do sistema hexadecimal. 
Por exemplo: 1110 0110 [binário] = E6 [hexadecimal].
Para mais informações sobre os sistemas de numeração e suas 
conversões, ler o capítulo 4 do livro:
CARVALHO, A. C. P. L. F.; LORENA, A. C. Introdução à Computação - 
Hardware, Software e Dados. LTC, 2016.
O material está disponível em:
 https://integrada.minhabiblioteca.com.br/#/books/9788521633167/.
https://integrada.minhabiblioteca.com.br/#/books/9788521633167/
15WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 IN
TR
OD
UT
ÓR
IA
EDUCAÇÃO A DISTÂNCIA
CONSIDERAÇÕES FINAIS
Assim, finalizamos nossa unidade introdutória sobre sistemas computacionais, este tema 
tão importante quanto a como são organizados estes sistemas, para que você consiga aprofundar 
seus estudos sobre algoritmos e a programação propriamente dita, produzindo seus códigos e 
comandos (software) para o hardware executar as operações que você necessita automatizar.
Esta é uma das intenções desta unidade introdutória: chamar a atenção para assuntos que 
vão além do “para que isto me servirá?”, que domina o senso-comum. Esta unidade de estudo 
trouxe a essência e os fundamentos dos sistemas computacionais.
1616WWW.UNINGA.BR
U N I D A D E
01
SUMÁRIO DA UNIDADE
INTRODUÇÃO ............................................................................................................................................................... 18
1 ALGORITMOS ............................................................................................................................................................ 19
1.1 DESCRIÇÃO NARRATIVA .......................................................................................................................................20
1.2 FLUXOGRAMA ........................................................................................................................................................ 21
1.3 PSEUDOCÓDIGO ....................................................................................................................................................22
2 PROGRAMAS E LINGUAGENS DE PROGRAMAÇÃO..............................................................................................23
2.1 COMPILADORES ....................................................................................................................................................24
2.2 INTERPRETADORES .............................................................................................................................................25
2.3 LINGUAGENS DE PROGRAMAÇÃO ......................................................................................................................25
2.4 LINGUAGEM C .......................................................................................................................................................26
3 TIPOS DE DADOS ..................................................................................................................................................... 31
3.1 TIPOS DE DADOS BÁSICOS .................................................................................................................................. 31
ALGORITMOS E ELEMENTOS
BÁSICOS DE PROGRAMAÇÃO
PROF. FÁBIO ATAIDE DE LIMA
ENSINO A DISTÂNCIA
DISCIPLINA:
ALGORITMOSE PROGRAMAÇÃO APLICADA
17WWW.UNINGA.BR
EDUCAÇÃO A DISTÂNCIA
3.2 ENUMERADORES ..................................................................................................................................................33
3.3 PONTEIROS ...........................................................................................................................................................33
4 CONSTANTES E VARIÁVEIS ....................................................................................................................................34
4.1 CONSTANTES .........................................................................................................................................................34
4.1.1 CONSTANTES LITERAIS .....................................................................................................................................35
4.1.2 CONSTANTES MANIFESTAS .............................................................................................................................35
4.2 VARIÁVEIS .............................................................................................................................................................36
5 EXPRESSÕES E OPERADORES ...............................................................................................................................37
5.1 EXPRESSÕES ARITMÉTICAS ...............................................................................................................................37
5.2 EXPRESSÕES RELACIONAIS ...............................................................................................................................38
5.3 EXPRESSÕES LÓGICAS ........................................................................................................................................39
5.4 PRECEDÊNCIA DE OPERADORES .......................................................................................................................40
5.5 CONVERSÕES DE TIPOS ...................................................................................................................................... 41
6 ENTRADA E SAÍDA DE DADOS ................................................................................................................................42
6.1 ENTRADA DE DADOS .............................................................................................................................................43
6.2 SAÍDA DE DADOS ..................................................................................................................................................46
CONSIDERAÇÕES FINAIS ...........................................................................................................................................50
18WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
INTRODUÇÃO
Caro(a) aluno(a), seja bem-vindo(a) à disciplina de Algoritmos e Programação Aplicada. 
Nesta disciplina, serão apresentados os princípios básicos de lógica de programação e os principais 
comandos necessários para o desenvolvimento de algoritmos.
A lógica está relacionada ao processo de raciocínio, à capacidade de ordenar os 
pensamentos e à busca de soluções através de ideias coerentes. Por exemplo, para pegar uma 
caneta que está dentro de uma caixa, deve-se primeiro abrir a caixa para depois pegar a caneta; 
não é possível atravessar a caixa sem abri-la.
A utilização da lógica é fundamental para a criação de algoritmos, primeiro assunto 
abordado nesta unidade, onde descrevemos a sua definição e as suas formas de representação. Em 
seguida, é abordado o conceito de programa, seus componentes básicos e o fluxo de transformação 
de um código escrito a um programa executável.
Prosseguimos abordando as linguagens de programação, ferramenta utilizada na 
codificação de programas, e introduzimos o aluno à linguagem C, adotada neste livro para o 
aprendizado da lógica de programação.
Em seguida, já com base na linguagem C, apresentamos os tipos de dados existentes, a 
definição de constantes e variáveis, esta última um recurso importante para o armazenamento e a 
recuperação de informações da memória RAM. Prosseguimos abordando os tipos de operadores 
e as expressões que podem ser formadas para cálculos e processamentos diversos.
Concluímos a unidade descrevendo os processos de como o usuário informa dados ao 
programa, e como o programa retorna esses dados em forma de resultados para o usuário.
19WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
1 ALGORITMOS
Segundo Manzano e Oliveira (2012), a palavra algoritmo pode ser empregada na 
matemática e na ciência da computação:
O termo algoritmo, do ponto de vista computacional, pode ser entendido 
como regras formais, sequenciais e bem definidas a partir do entendimento 
lógico de um problema a ser resolvido por um programador com o objetivo de 
transformá-lo em um programa que seja possível de ser tratado e executado por 
um computador, em que dados de entrada são transformados em dados de saída 
(MANZANO; OLIVEIRA, 2012, p. 28).
De acordo com o problema a ser resolvido, são vários os caminhos que podem ser 
utilizados para encontrar a sua solução. O algoritmo é um conjunto de passos que define um 
desses caminhos. Cada passo é chamado de instrução; assim, um algoritmo pode também ser 
definido como um conjunto de instruções (LOPES; GARCIA, 2002).
O Quadro 1 a seguir apresenta dois exemplos de algoritmos para ir ao trabalho, desde o 
momento em que o indivíduo acorda até a chegada ao escritório.
1. Desligar o despertador
2. Ir para o banheiro
3. Lavar o rosto
4. Escovar os dentes
5. Tirar o pijama
6. Colocar uma roupa
7. Tomar café da manhã
8. Pegar o carro
9. Estacionar o carro
10. Entrar no escritório
1. Desligar o despertador
2. Ir para o banheiro
3. Escovar os dentes
4. Tomar banho
5. Colocar uma roupa
6. Se estiver chovendo, pegar 
guarda-chuva
7. Pegar ônibus
8. Descer do ônibus
9. Entrar no escritório
Quadro 1 – Algoritmos de ida ao trabalho. Fonte: O autor.
Os dois algoritmos do Quadro 1 resolvem o problema de “ida ao trabalho” de formas 
diferentes. Cada linha numerada representa uma instrução a ser executada e pode ser detalhada 
se necessário. Por exemplo, a instrução “escovar os dentes” poderia ser subdividida nos seguintes 
passos:
• Pegar a pasta e a escova de dentes;
• Aplicar a pasta de dentes na escova;
• Molhar a escova com um pouco de água;
• Escovar os dentes;
• Enxaguar a boca;
• Guardar a pasta e a escova de dentes.
Qualquer outra instrução poderia ser igualmente detalhada, estruturando o algoritmo 
de forma lógica e organizada. Como a essência do algoritmo está em resolver um determinado 
problema em passos, podemos dizer que conhecemos diversos algoritmos de forma empírica, 
já que na realidade lidamos com vários tipos de “problemas” cotidianos que demandam uma 
solução.
20WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
Apesar de a lógica de programação ser considerada por alguns como um “dom” que 
já nasce com o afortunado, qualquer pessoa pode desenvolver sua própria lógica, por meio de 
muita prática e exercício. É como aprender a dirigir: a pessoa recebe os ensinamentos teóricos 
e práticos, mas somente com a experiência contínua de dirigir nas ruas é que ela irá adquirir 
prática e experiência.
E nessa jornada de aprendizado, por quanto mais situações complexas e difíceis passamos, 
mais maduros e experientes ficamos. É normal que o aspirante a programador venha a se deparar 
com muitos erros e falhas durante o desenvolvimento de seus algoritmos (programas), mas são 
exatamente esses obstáculos que formarão uma lógica de programação robusta e consistente nele.
De acordo com Ascencio e Campos (2012), existem três formas de representação de 
algoritmos:descrição narrativa, fluxograma e pseudocódigo. Detalhamos cada um desses tipos 
nas seções seguintes.
1.1 Descrição Narrativa
A descrição narrativa consiste em escrever as instruções na linguagem natural, em 
sequência (ASCENCIO; CAMPOS, 2012). O Quadro 2 a seguir ilustra um algoritmo para somar 
dois números em descrição narrativa.
1. Obter dois números
2. Somar os dois números
3. Mostrar o resultado da soma
Quadro 2 – Algoritmo no formato de descrição narrativa. Fonte: O autor.
Segundo Ascencio e Campos (2012), a descrição narrativa possui a vantagem de ser de 
fácil aprendizado, uma vez que as instruções são escritas na língua natural. Por outro lado, como 
desvantagem ela é ambígua, ou seja, pode gerar diversas interpretações e isso dificulta a conversão 
do algoritmo em um programa.
21WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
1.2 Fluxograma
O fluxograma consiste em escrever as instruções do algoritmo utilizando os símbolos 
gráficos descritos no Quadro 3 a seguir (ASCENCIO; CAMPOS, 2012).
Quadro 3 – Conjunto de símbolos utilizados do fluxograma. Fonte: Ascencio e Campos (2012).
Na Figura 1 a seguir, temos a representação do algoritmo de somar dois números em 
forma de fluxograma.
Figura 1 – Algoritmo no formato de fluxograma. Fonte: O autor.
Segundo Ascencio e Campos (2012), a vantagem do fluxograma está nos símbolos gráficos, 
que são universais e podem ser interpretados independente do idioma. Como desvantagem, é 
necessário aprender a simbologia apresentada no Quadro 3; além disso, ele não apresenta muitos 
detalhes e, por isso, dificulta a conversão do algoritmo em um programa.
22WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
1.3 Pseudocódigo
O pseudocódigo, também conhecido como Portugol ou português estruturado, consiste 
em escrever as instruções com regras de sintaxe predefinidas, sendo uma linguagem restrita que 
descreve o significado dos termos utilizados (ASCENCIO; CAMPOS, 2012).
O Quadro 4 a seguir ilustra o algoritmo de somar dois números representado em 
pseudocódigo.
Algoritmo "soma"
Var
 n1, n2, s: inteiro
Inicio
 Leia(n1, n2)
 s <- n1 + n2
 Escreva(s)
FimAlgoritmo
Quadro 4 – Algoritmo em forma de pseudocódigo. Fonte: O autor.
Segundo Ascencio e Campos (2012), o pseudocódigo oferece a vantagem de ser muito 
próximo a uma linguagem de programação, tornando a conversão de um algoritmo em um 
programa quase que imediata. A desvantagem está na necessidade de ter que aprender as regras do 
pseudocódigo; muitas vezes isto leva diretamente ao estudo de uma linguagem de programação 
real, embora existam diversos programas no mercado voltados à execução de algoritmos escritos 
em pseudocódigo.
Adotamos em nosso livro o aprendizado da lógica de programação tendo como base a 
linguagem C, abordada com detalhes na seção seguinte.
23WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
2 PROGRAMAS E LINGUAGENS DE PROGRAMAÇÃO
Programas de computador são, em sua essência, algoritmos que dizem ao computador 
os passos específicos para a solução de um problema e em que ordem eles devem ser executados 
(DEITEL, 2011).
O computador, por sua vez, traduz as instruções dos programas em operações primitivas. 
O Quadro 5 a seguir apresenta estas operações, comuns não só aos computadores, mas a todos os 
demais aparelhos digitais eletrônicos.
Operação Tipo de instrução Descrição
Processamento de 
dados Aritmética e lógica
Fornecem a capacidade computacional para processar 
dados numéricos e booleanos
Armazenamento de 
dados Memória Move dados entre a memória e os registradores
Movimentação de 
dados Entrada e saída
Comandos para obtenção e apresentação de dados em 
dispositivos de E/S
Controle Teste e desvio Testa o valor de uma palavra ou desvia a execução do programa para uma nova instrução
Quadro 5 – Operações primitivas realizadas por computadores. Fonte: Tanenbaum (2013).
O computador pode executar programas gerados por meio de duas ferramentas: o 
compilador e o interpretador. Elas são responsáveis por transformar as instruções escritas nos 
programas em linguagem compreensível pelo computador, e são detalhadas nas seções seguintes.
24WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
2.1 Compiladores
Segundo Sebesta (2011), compilação é o processo onde um programa escrito em uma 
linguagem de programação é traduzido para linguagem de máquina. O software responsável por 
esse processo é o compilador, que executa as seguintes tarefas:
• Gera um código intermediário em linguagem de montagem, usado como base para a 
criação de um arquivo binário chamado código-objeto;
• Resolve as chamadas de funções do sistema operacional ou de bibliotecas externas usadas 
no programa, por meio de uma ferramenta auxiliar chamada de ligador (linker) no 
processo conhecido como linkagem ou ligação;
• Gera o código de máquina final, geralmente um arquivo executável ou uma biblioteca de 
funções que podem ser usadas para gerar outros programas.
Este processo é ilustrado com detalhes na Figura 2 a seguir.
Figura 2 – Processo de compilação. Fonte: Tucker e Noonan (2010).
O compilador apresenta como vantagem o desempenho em tempo de execução, uma vez 
que o mapeamento para entradas e saída ocorre muito mais rapidamente. Por outro lado, tem 
a desvantagem de ter que repetir todo o processo de compilação cada vez que o código-fonte é 
alterado (TUCKER; NOONAN, 2010).
25WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
2.2 Interpretadores
A interpretação é caracterizada por efetuar as fases abordadas na compilação, linha por 
linha de instrução do programa. Assim, este é executado junto com as entradas diretamente por 
um programa denominado interpretador, que produz o resultado. Por essa razão, também não há 
arquivos intermediários, como código-objeto ou arquivo executável (SEBESTA, 2011).
Em resumo, cada linha do programa é lida pelo interpretador, convertida e imediatamente 
executada antes que o comando seguinte seja lido. A Figura 3 a seguir ilustra esse processo.
Figura 3 – Processo de interpretação. Fonte: Tucker e Noonan (2010).
A qualidade da interação com o sistema pode ser melhor com um interpretador do 
que com um compilador, pois o primeiro executa o programa instrução por instrução. Já que o 
desenvolvimento de programas é interativo, trechos de programas podem ser testados na medida 
em que são escritos, oferecendo assim um melhor diagnóstico de erro (TUCKER; NOONAN, 
2010).
No entanto, isso acaba por tornar lento o processamento do programa interpretado se 
comparado ao programa compilado. Além dessa desvantagem, geralmente corre-se o risco de 
deixar o código-fonte do programa exposto ao usuário (MANZANO; OLIVEIRA, 2012).
2.3 Linguagens de Programação
As linguagens de programação constituem um vocabulário acompanhado de um conjunto 
de regras gramaticais. Esse conjunto de comandos e regras permite a escrita de um programa 
que pode ser lido e compreendido por um ser humano com certa naturalidade e traduzido sem 
ambiguidade pelo próprio computador para a linguagem de máquina (TUCKER; NOONAN, 
2010).
As linguagens de programação geralmente são divididas em três tipos gerais, segundo 
Deitel (2011):
• Linguagem de máquina, formada por uma sequência de números – em última instância, 
reduzidos a 0s e 1s. É a “linguagem natural” de um computador em particular, definida 
pelo projeto de hardware;
26WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
• Linguagens simbólicas ou de montagem, também conhecida como assembly. Sua finalidade 
é simplificar a escrita e a leitura da linguagem de máquina por meio de declarações que 
produzem instruções correspondentesde máquina;
• Linguagens de alto nível, onde seu conjunto de regras e instruções é mais próximo da 
linguagem humana. Exemplos: Fortran, Basic, C, C++, C#, COBOL, Harbour, Pascal, 
Delphi, Pearl, Phyton, PHP, Java, Javascript, entre muitas outras.
Adotamos em nossa disciplina a C como base para o aprendizado de lógica de programação; 
portanto, apresentamos essa linguagem na próxima seção e usamo-na para exemplificar os demais 
elementos de programação abordados neste livro.
2.4 Linguagem C
A linguagem C foi originada de outras duas linguagens, segundo Schildt (1996):
A linguagem C foi inventada primeiramente por Dennis Ritchie em um DEC 
PDP-11 que utilizava o sistema operacional UNIX. C é o resultado de um 
processo de desenvolvimento que começou com uma linguagem mais antiga, 
chamada BCPL, que ainda está em uso, em sua forma original, na Europa. BCPL 
foi desenvolvida por Martin Richards e influenciou uma linguagem chamada B, 
inventada por Ken Thompson. Na década de 1970, B levou ao desenvolvimento 
de C (SCHILDT, 1996, p. 3).
Ainda de acordo com Schildt (1996), C é frequentemente classificada como linguagem 
de médio nível para computadores porque combina elementos de linguagem de alto nível com a 
funcionalidade da linguagem de montagem. Além disso, um programa escrito em C é portável, 
ou seja, pode ser executado em tipos diferentes de computadores com poucas adaptações.
C é uma linguagem compilada e seus programas percorrem seis passos até que possam 
ser executados (DEITEL, 2011), ilustrados na Figura 4 a seguir.
27WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
 
Figura 4 – Ambiente típico de desenvolvimento em C. Fonte: Deitel (2011).
28WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
Devido ao paradigma procedural da linguagem, todo programa em C é estruturado em 
funções e dentro delas estão contidas as instruções a serem executadas. O Quadro 6 a seguir 
ilustra um esboço desta estrutura.
tipo nome_da_função(parâmetros)
{
 variáveis locais
 instruções
}
Quadro 6 – Estrutura de um programa em C. Fonte: O autor.
Cada item é descrito da seguinte forma:
• tipo: tipo de dado a ser retornado pela função;
• parâmetros (opcional): lista de argumentos a serem passados para a função, devidamente 
tipados;
• {}: delimitam o início e o final da função;
• variáveis locais (opcional): declaração das variáveis locais a serem usadas, devidamente 
tipadas;
• instruções: comandos a serem executados. 
Todo programa em C, após ser escrito, deve ser gravado no formato de arquivo texto – 
cujo nome deve ter a extensão .c – em um dispositivo de armazenamento secundário, como por 
exemplo um disco rígido ou um pendrive (DEITEL, 2011).
Existem vários ambientes de desenvolvimento integrado (IDE) 
disponíveis para a linguagem C em vários sistemas operacionais. 
Deixamos o aluno à vontade para usar o de sua preferência. Para 
Windows, temos: Turbo C, DevC++, Code Blocks etc.; este último 
possui disponível um tutorial de como compilar seu primeiro 
programa.
Linguagem C #02: Primeiro programa em C
Disponível em: https://www.youtube.com/watch?v=VGC-XEj76xI . 
Acesso em: 9 set. 2020.
29WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
Vamos enfim ao nosso primeiro programa em C, o famigerado “Alô Mundo” – sugestão 
de nome de arquivo: AloMundo.c. O Quadro 7 a seguir ilustra como ficaria o código desse 
programa.
#include <stdio.h> // Inclui o cabeçalho de funções de E/S
/* Trecho do programa principal */
int main(void)
{
 printf(“Alo, Mundo!”); // Imprime o texto na tela
 return 0; // Retorna o valor para o SO
}
Quadro 7 – Programa “Alô Mundo”. Fonte: O autor.
Esse programa consiste em 6 linhas, já desconsiderando a linha em branco, mas pode 
ser reduzido ainda mais devido à flexibilidade de estruturar várias instruções em uma só linha. 
Vamos descrever o significado dos comandos linha por linha:
• #include <stdio.h> – todo comando que inicia com # é uma diretiva de pré-processamento 
e é analisado na Fase 2 da Figura 4. #include permite que funções em um determinado 
cabeçalho-padrão sejam chamadas no programa. stdio.h contém o protótipo da função 
printf(), usada umas linhas adiante no programa do Quadro 7;
• /* Trecho do programa principal */ – essa linha é um comentário e será ignorada pelo 
compilador. C oferece dois comandos para fazer comentários em programas: /* */, que 
permitem comentários em múltiplas linhas; e //, que pode ser usado no final de uma linha 
com instruções, e os comentários estendem-se até o final da linha. É uma boa prática fazer 
comentários nos programas, como forma de documentação e de guia para determinadas 
operações realizadas nele, com o objetivo de auxiliar em uma ocasional manutenção;
• int main(void) – todo programa em C deve conter uma função denominada main(), toda 
em minúscula, pois é por meio dela que a execução é iniciada. Geralmente ela retorna um 
valor numérico para o sistema operacional, sendo que 0 indica sucesso de execução e 
outro número indica um erro a ser tratado externamente; por isso, definimos int como 
tipo de retorno. A palavra void entre os parênteses é usada para indicar que a função não 
receberá parâmetros.
• printf(“Alo, Mundo!”); – essa função imprime dados no dispositivo de saída corrente, 
nesse caso, a tela do monitor. Uma lista de parâmetros pode ser passada para a função 
inclusive com a opção de formatar os dados a serem exibidos;
• return 0; – esse comando retorna o valor especificado para a função chamadora. No caso 
da função main(), sempre retornaremos 0, indicando sucesso na execução.
30WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
Com exceção das diretivas de pré-processamento, os demais comandos – incluindo 
as chaves delimitadoras {} – podem ser agrupados em uma linha. O Quadro 8 a seguir ilustra 
algumas formas alternativas para codificar o programa “Alô Mundo”.
int main(void) {
 printf(“Alo, Mundo!”);
 return 0;
}
int main(void)
{ printf(“Alo, Mundo!”);
 return 0;
}
int main(void) { printf("Alo, Mundo!"); return 0; }
Quadro 8 – Variantes do programa “Alô Mundo”. Fonte: O autor.
Todos os exemplos do Quadro 8 fazem exatamente a mesma coisa do programa do 
Quadro 7. A única diferença está na forma em que as instruções foram distribuídas.
C é uma linguagem case-sensitive, isto é, faz distinção entre maiúscula e 
minúscula. Todas as palavras reservadas em C são minúsculas; a função main(), 
como já visto, deve ser declarada em minúscula; a variável valor é diferente de 
Valor ou VALOR, são três variáveis distintas; processa() é diferente de Processa() 
ou PROCESSSA(), são três funções distintas (SCHILDT, 1996).
Além disso, todos os comandos são concluídos com um ponto-e-vírgula (;), 
também chamado de terminador de instruções. Exceções a esta regra são as 
declarações de funções e as diretivas de pré-processamento (DEITEL, 2011).
31WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
3 TIPOS DE DADOS
Na linguagem C, existem cinco tipos de dados básicos e dois tipos de dados especiais, 
abordados nas seções seguintes.
3.1 Tipos de Dados Básicos
Segundo Schildt (1996), os dados podem ser representados por cinco tipos básicos:
• char: caractere;
• int: inteiro;
• float: ponto flutuante;
• double: ponto flutuante de precisão dupla;
• void: nulidade ou ausência de valor.
Com exceção do void, os demais tipos podem ter sua capacidade ou faixa de valores 
alterada com o uso de modificadores. Existem quatro modificadores, segundo Schildt (1996):
• unsigned: utilizado para declarar os tipos como sem sinal, duplicando assim a gama de 
valores que pode ser representado;
• signed: declara tipos contendosinal;
• short: reduz a capacidade de armazenamento;
• long: aumenta a capacidade de armazenamento.
32WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
Na prática, signed e short são redundantes e pouco usados, pois a declaração padrão de 
tipos já considera, respectivamente, o sinal e a menor faixa de valores.
O Quadro 9 a seguir apresenta os tipos de dados com e sem modificadores, seu tamanho 
e sua faixa de dados permitida.
Tipo Faixa de valores Tamanho aproximado
char -128 a 127 8 bits (1 byte)
unsigned char 0 a 255 8 bits (1 byte)
int -32.768 a 32.767 16 bits (2 bytes)
short int -32.768 a 32.767 16 bits (2 bytes)
unsigned int 0 a 65.535 16 bits (2 bytes)
long int -2.147.483.648 a 2.147.489.647 32 bits (4 bytes)
long -2.147.483.648 a 2.147.489.647 32 bits (4 bytes)
unsigned long 0 a 4.294.967.295 32 bits (4 bytes)
float 3.4 x 10-38 a 3.4 x 1038 32 bits (4 bytes)
double 1.7 x 10-308 a 1.7 x 10308 64 bits (8 bytes)
long double 3.4 x 10-49328 a 3.4 x 1049328 128 bits (16 bytes)
Quadro 9 – Todos os tipos dados definidos pelo padrão ANSI. Fonte: adaptado de Schildt (1996).
Alguns tipos de dados podem variar dependendo do hardware, do compilador e do 
sistema operacional. Por exemplo, o tipo int possui 4 bytes nos computadores mais atuais e, 
consequentente, a mesma faixa de valores de um long.
Além dos cinco tipos de dados básicos e seus modificadores, a linguagem C possui dois 
tipos especiais de dados: enumeradores e ponteiros.
Reparamos no Quadro 9 que o tipo char, embora seja para representar caracteres, 
também possui uma faixa de valores. Na verdade, esse tipo armazena o código 
numérico do caractere na tabela ASCII da máquina (DEITEL, 2011). Exemplos:
• ‘z’ representa o código de z, que é 122;
• ‘7’ representa o código no número 7, que é 55;
• ‘\n’ representa o código do caractere de nova linha, que é 10.
33WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
3.2 Enumeradores
De acordo com Deitel (2011, p. 340), “uma enumeração, introduzida pela palavra-chave 
enum, é um conjunto de constantes de enumeração inteiras, representadas por identificadores”.
Os valores em uma enumeração iniciam em 0 e são incrementados por 1 a cada item 
da lista. Por exemplo: enum semana { DOM, SEG, TER, QUA, QUI, SEX, SAB }; cria uma 
lista com os dias da semana enumerados de 0 a 6. Para iniciar a lista com 1, basta atribui-lo no 
primeiro item, desta forma:
enum semana { DOM = 1, SEG, TER, QUA, QUI, SEX, SAB };
Os demais itens serão incrementados com 1 automaticamente, fazendo com que SEG 
valha 2 e SAB valha 7. Depois de declarada, variáveis podem ser criadas usando a enumeração 
como tipo de dado e usando suas constantes como valores.
3.3 Ponteiros
Basicamente, um ponteiro é tipo de dado que armazena um endereço de memória. 
Este endereço de memória, por sua vez, pode conter uma variável ou uma função carregada na 
memória (DEITEL, 2011).
Depois de armazenado um endereço de memória no ponteiro, existe um operador em C 
que permite recuperar:
• o seu valor, no caso do endereço conter uma variável;
• o seu código para ser executado, no caso do endereço conter uma função.
Ponteiros são um dos recursos que tornam a linguagem C mais poderosa em comparação 
a outras linguagens. Por outro lado, é um assunto complexo e que demanda muito entendimento 
e prática para poder ser aplicado com eficiência.
Abordamos ponteiros neste livro porque são necessários na representação de cadeias de 
caracteres e na passagem de parâmetros por referência a funções. Portanto, esse tipo de dado é 
visto com mais detalhes na Unidade IV.
34WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
4 CONSTANTES E VARIÁVEIS
Os tipos de dados apresentados na seção anterior podem ser representados em um 
programa por meio de constantes ou de variáveis. Segundo Schildt (1996, p. 19), “em C, nomes 
de variáveis, funções, rótulos e vários outros objetos definidos pelo usuário são chamados de 
identificadores”. Eles devem ser formados por letras, números ou o caracter sublinhado “_”, sendo 
que não pode ser iniciado com números e nem coincidir com as palavras reservadas da linguagem.
O Quadro 10 a seguir mostra alguns exemplos de identificadores válidos e inválidos.
Válidos Inválidos
A 2ª (começa com número e possui caracter inválido: “ª”)
a b@ (possui caracter inválido: “@”)
Media media idade (possui espaço em branco)
altura2 x*y (possui caracter inválido: “*”)
media_idade #media (“#” é para diretivas de pré-processamento)
x36 1anoComputacao (começa com número)
NomeAluno break (palavra reservada da linguagem C)
Quadro 10 – Identificadores válidos e inválidos. Fonte: O autor.
Vale lembrar que, em C, A não é o mesmo que a: cada um é um identificador distinto. O 
Quadro 11 a seguir lista todas as palavras reservadas – ou palavras-chave – da linguagem, que 
são identificadas pelo compilador para traduzir suas instruções devidamente para a linguagem de 
máquina, e, por isso, não podem ser usadas como identificadores.
auto do goto signed unsigned
break double if sizeof void
case else int static volatile
char enum long struct while
const extern register switch
continue float return typedef
default for short union
Quadro 11 – Palavras-chave da linguagem C. Fonte: Deitel (2011).
4.1 Constantes
De acordo com Manzano e Oliveira (2012, p. 46), “constante é tudo que é fixo, estável, 
inalterável, imutável, contínuo, incessante, invariável, de valor fixo e que é aplicado em diversos 
pontos de vista”. Xavier (2011, p. 37) complementa que “dentro do algoritmo, constantes são os 
valores que permanecem os mesmos do início ao fim”.
Existem dois tipos de constantes em C: constantes literais e constantes manifestas. As 
constantes literais são a representação direta de cada dado, enquanto as constantes manifestas são 
esses mesmos dados atribuídos a um identificador por meio do comando const ou da diretiva 
#define (SCHILDT, 1996).
35WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
4.1.1 Constantes literais
O tipo de dado char é representado literalmente de duas formas:
• Com aspas simples para um caractere, por exemplo: ‘A’, ‘B’, ‘1’, ‘-’, ‘@’ etc.;
• Com aspas duplas para dois ou mais caracteres, por exemplo: “Uningá”, “B+” etc.
O tipo de dado int é representado literalmente por números inteiros sem o ponto decimal, 
por exemplo: 25, -481, 2020, 10022018 etc. Os tipos de dados float e double, por sua vez, são 
representados literalmente por números com o ponto decimal, por exemplo: 8.35, +16.789, 
3.1415, -16.44, 0.222222 etc.
4.1.2 Constantes manifestas
Segundo Deitel (2011), constantes manifestas criadas com a diretiva de pré-processamento 
#define são automaticamente substituídas pelo seu valor correspondente na fase de pré-
compilação – vide Fase 2 da Figura 1. A sintaxe para a criação de uma constante com esta diretiva 
é: #define identificador valor.
Constantes manifestas criadas com o comando const são na verdade variáveis que serão 
instruídas pelo compilador a serem armazenadas no espaço de memória ROM, onde seus valores 
não poderão ser modificados (SCHILDT, 1996).
O Quadro 12 a seguir ilustra alguns exemplos de definição de constantes com #define e 
const.
#define PI 3.1415
#define ANO 2020
#define IE "Uninga"
const int TAMANHO = 10;
const float FATOR = 1.25;
Quadro 12 – Exemplos de criação de constantes. Fonte: O autor.
Embora não seja uma regra, é costume nas linguagens de programação declarar constantes 
em maiúsculas, para diferenciar das variáveis que geralmente são criadas em letra minúscula. O 
importante em relação à linguagem C é lembrar que elas devem ser referenciadas exatamente da 
forma como foram criadas.
Não existe um tipo de dado string em C, como normalmente ocorre em outras linguagens. 
Cadeias de caracteres sãona verdade um vetor de elementos do tipo char e possuem 
operadores e funções específicas para serem manipuladas (DEITEL, 2011). Strings são 
abordadas com mais detalhes na Unidade III.
36WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
4.2 Variáveis
Um programa pode receber dados de entrada fornecidos pelo usuário ou efetuar cálculos 
complexos que requerem o armazenamento desses dados na memória para serem recuperados 
posteriormente e até mesmo serem modificados. As variáveis representam uma posição de 
memória com esse propósito. Além do valor armazenado, elas possuem nome e tipo (ASCENCIO; 
CAMPOS, 2012).
Segundo Schildt (1996, p. 20), “[...] todas as variáveis em C devem ser declaradas antes de 
serem usadas”. A sintaxe para declarar uma variável é:
tipo lista_de_variáveis;
Onde o tipo pode ser qualquer um dos tipos de dados abordados, opcionalmente 
acompanhado de modificadores. O Quadro 13 a seguir ilustra alguns exemplos de declaração de 
variáveis.
int quantidade;
unsigned int populacao;
float valor, desconto;
double total;
long double cod_barras;
char sexo;
char endereco[30];
Quadro 13 – Declaração de variáveis em C. Fonte: O autor.
Para armazenar dados em variáveis, utilizamos o operador de atribuição (=). A sintaxe 
para tal finalidade é:
identificador = expressão;
Onde identificador é o nome da variável previamente declarada, e expressão, o valor de 
acordo com o tipo da variável. O Quadro 14 a seguir ilustra algumas atribuições de valores às 
variáveis declaradas no Quadro 13.
quantidade = 12;
populacao = 35000;
valor = 35.60;
desconto = 10;
total = quantidade * valor;
total = total – (total * desconto / 100);
cod_barras = 7891237791212;
sexo = 'F';
endereço = "Avenida Brasil, 2855";
Quadro 14 – Exemplos de atribuição. Fonte: O autor.
Para atribuir o mesmo valor a várias variáveis de uma vez, utilizamos o recurso da atribuição 
múltipla. Por exemplo, x = y = z = 0; atribuirá o valor zero às variáveis x, y e z (SCHILDT, 1996).
É possível também atribuir um valor no momento da declaração da variável. Por exemplo, 
int opcao = 1; fará com que a variável opcao possua o valor inicial de 1, podendo este ser alterado 
a qualquer momento no programa. Para isso, basta fazer uma nova atribuição e o novo valor 
substituirá o anterior na memória. Variáveis declaradas sem atribuição de valor são inicializadas 
com valores aleatórios, dependendo do compilador C; portanto, é importante sempre atribuir 
valores a elas.
37WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
Alguns exemplos do Quadro 14 utilizam cálculos aritméticos e as próprias variáveis 
criadas como parte da expressão a ser calculada. Abordamos os operadores disponíveis em C na 
seção seguinte.
5 EXPRESSÕES E OPERADORES
Segundo Sebesta (2011, p. 342), “[...] expressões são os meios fundamentais de especificar 
computações em uma linguagem de programação”. São um conjunto de operadores e operandos 
que geram um resultado a ser utilizado no processamento de um programa.
Existem três tipos de expressões em C: aritméticas, relacionais e lógicas. Detalhamos cada 
tipo nas seções seguintes, juntamente com os seus operadores.
5.1 Expressões Aritméticas
Expressões aritméticas são aquelas em que o resultado consiste em um valor numérico. 
Portanto, podem ser utilizados em expressões desse tipo apenas operadores aritméticos, constantes 
numéricas e variáveis numéricas – do tipo int, float, double e derivados.
O Quadro 15 a seguir apresenta os operadores aritméticos fornecidos pela linguagem C.
Operação Operador Exemplo
Soma + vencimento + 30
Subtração - elementos – 1
Multiplicação * quantidade * preco
Divisão / soma_notas / 4
Resto da divisão % número % 2
Quadro 15 – Operadores aritméticos. Fonte: Adaptado de Deitel (2011).
Esses operadores seguem a regra de precedência da matemática. Portanto, em uma 
expressão contendo vários operadores, são calculadas primeiramente as multiplicações, divisões 
e o resto; em seguida, são calculadas as somas e subtrações. Parênteses podem ser usados para 
alterar essa ordem.
De acordo com Deitel (2011, p. 64), “C oferece vários operadores de atribuição que 
abreviam as expressões de atribuição. Por exemplo, a instrução c = c + 3; pode ser abreviada com 
o operador de atribuição com adição += para c += 3;”. Existe um operador de atribuição para 
cada operador aritmético da linguagem C, conforme apresentado no Quadro 16 a seguir.
Operador Exemplo Equivalente a
+= x += y; x = x + y;
-= x -= y; x = x - y;
*= x *= y; x = x * y;
/= x /= y; x = x / y;
%= x %= y; x = x % y;
Quadro 16 – Operadores de atribuição. Fonte: Adaptado de Deitel (2011).
38WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
C também oferece os operadores de incremento (++) e decremento (--), que somam ou 
subtraem 1, respectivamente, do seu operando. Eles são unários e podem ser usados como prefixo 
ou sufixo da variável a ser alterada; contudo, possuem comportamento diferente, segundo Schildt 
(1996):
• Se precederem a variável, alteram-na antes de usá-la na expressão;
• Se estiverem após a variável, usam seu valor atual na expressão antes de alterá-la.
O Quadro 17 a seguir ilustra alguns exemplos dos operadores de atribuição, incremento 
e decremento.
int v1, v2, v3;
v1 = 10;
v2 = 5;
v1 += v2; // v1 = 15
v3 = ++v1 + v2; // v3 = 16 (incrementou v1 antes)
v3 = v1 + v2++; // v3 = 16 (incrementou v2 depois)
v1 -= 7; // v1 = 9
v2 *= 3; // v2 = 18
v3 /= 4; // v3 = 4
Quadro 17 – Operadores de atribuição, incremento e decremento. Fonte: O autor.
5.2 Expressões Relacionais
As expressões relacionais referem-se à comparação entre dois valores de um tipo básico; 
a isso chamamos de condição, e o seu resultado consiste em um valor lógico verdadeiro ou falso. 
Segundo Deitel (2011, p. 32), “[...] em C, uma condição pode ser, realmente, qualquer expressão 
que resulte em um valor zero (falsa) ou diferente de zero (verdadeira)”.
O Quadro 18 a seguir apresenta os operadores relacionais da linguagem C.
Operador Símbolo Exemplo
Igual == a == 1
Diferente != a != b
Maior que > a > 5
Menor que < b < 12
Maior ou igual a >= a >= 6
Menor ou igual a <= b <= 7
Quadro 18 – Operadores relacionais. Fonte: Adaptado de Deitel (2011).
39WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
Todos esses operadores possuem a mesma precedência, sendo avaliados da esquerda para 
a direita; parênteses podem ser usados para alterar a ordem. Diversos exemplos com operadores 
relacionais são apresentados na Unidade II, onde abordamos as estruturas de seleção e repetição.
5.3 Expressões Lógicas
As expressões lógicas permitem que duas ou mais comparações possam ser combinadas 
em uma única avaliação, fazendo com que o seu resultado também seja verdadeiro ou falso. Para 
isso, C oferece três operadores, apresentados no Quadro 19 a seguir.
Operador Símbolo Descrição
Conjunção && Resulta em um valor verdadeiro somente quando todas as expressões são verdadeiras
Disjunção || Resulta em um valor verdadeiro quando pelo menos uma das expressões é verdadeira
Negação ! Inverte o valor de uma expressão: se for verdadeira, torna-se falsa; e se for falsa, torna-se verdadeira
Quadro 19 – Operadores lógicos. Fonte: Adaptado de Schildt (1996).
Se todos esses operadores forem usados em uma única expressão, a ordem de precedência 
é:
4. ! – negação, também chamado de NÃO lógico ou NOT;
5. && – conjunção, também chamado de E lógico ou AND;
6. || – disjunção, também chamado de OU lógico ou OR;
Assim como nas outras expressões, parênteses podem ser usados para alterar essa ordem. 
O Quadro 20 a seguir traz alguns exemplos.
char letra = 'J';
int ok = 1, valor = 10, r;
r = ok || valor != 10; // Resulta: 1 (verdadeiro)r = ok && valor != 10; // Resulta: 0 (falso)
r = ok || valor == 3 || letra == 'A'; // Resulta: 1 (verdadeiro)
r = valor == 10 && !ok; // Resulta: 0 (falso)
r = valor == 2 && ok || letra == 'J'; // Resulta: 1 (verdadeiro)
r = valor == 2 && (ok || letra == 'J'); // Resulta: 0 (falso)
Quadro 20 – Exemplos usando operadores lógicos. Fonte: O autor.
40WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
5.4 Precedência de Operadores
Em uma expressão, como já visto, podemos ter mais de um operador envolvido. Em 
situações que há um único operador, a avaliação da expressão é realizada de forma direta. Quando 
há mais de um operador, porém, é necessária a avaliação da expressão passo a passo, ou seja, um 
operador por vez.
Nesse caso, a precedência de operadores é determinada por parênteses ou pelo Quadro 
21 a seguir, onde apresentamos os operadores abordados até o momento e a forma como os seus 
operandos são associados.
Quadro 21 – Precedência de operadores de diversos tipos. Fonte: Adaptado de Schildt (1996).
O operador de condição ternária é explicado na unidade seguinte, junto com as estruturas 
de seleção; e o operador de expressão de função, na Unidade IV, junto com as sub-rotinas.
41WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
5.5 Conversões de Tipos
Quando constantes e variáveis de tipos diferentes estão envolvidas em uma expressão, o 
compilador deve convertê-las em um mesmo tipo para poder resolver a expressão com os valores 
normalizados; isto se chama promoção de tipo e é feito operação por operação em uma expressão 
seguindo esta ordem do menor para o maior tipo: char → int → long → float → double → long 
double (SCHILDT, 1996).
A Figura 5 a seguir ilustra alguns exemplos de conversões implícitas, aquelas que o 
compilador realiza automaticamente resolvendo a expressão de acordo com o maior operando 
em uma operação.
Figura 5 – Exemplo de conversões implícitas. Fonte: Schildt (1996).
É possível também realizar conversões explícitas, conhecidas como casts, onde passamos 
o tipo final desejado entre parênteses à esquerda do operando, seja uma constante ou uma 
expressão. Sua sintaxe geral é: (tipo) operando (SCHILDT, 1996).
Por exemplo, para garantir que a expressão x / 2 resulte em um valor com decimais, 
podemos usar: (float)x / 2. Mesmo que x seja um inteiro, será convertido em ponto flutuante e 
terá predominância sobre o segundo operando 2, que é um inteiro. Casts são muito utilizados na 
manipulação avançada de ponteiros e estruturas definidas pelo usuário.
42WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
6 ENTRADA E SAÍDA DE DADOS
A maior parte dos programas é estruturada para receber dados de entrada do usuário, 
que serão processados de alguma forma e depois serão apresentados os resultados na forma 
de informações. Esse ciclo, ilustrado na Figura 6 a seguir, pode-se repetir quantas vezes forem 
necessárias dentro de um programa para solucionar um determinado problema.
Figura 6 – Estrutura do fluxo padrão de um programa. Fonte: O autor.
Conforme ilustrado no Quadro 5 desta unidade, a entrada e a saída de dados estão entre 
as operações primitivas que o computador realiza. Toda linguagem de programação deve prover 
recursos para que o usuário possa:
• informar dados usando um dispositivo de entrada – teclado, mouse, scanner etc.
• visualizar os resultados depois de processados em um dispositivo de saída –monitor, 
impressora, projetor etc.
As principais funções fornecidas pela linguagem C com esta finalidade são: scanf(), para 
entrada de dados; e printf(), para saída de dados. Abordamos essas funções com detalhes nas 
seções seguintes.
43WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
6.1 Entrada de Dados
A função scanf() lê dados fornecidos pelo usuário e os armazena em variáveis. Segundo 
Deitel (2011), sua sintaxe é a seguinte:
scanf( string-de-controle-de-formato, outros-argumentos );
Onde string-de-controle-de-formato descreve os formatos da entrada, e outros-
argumentos são ponteiros para as variáveis em que a entrada será armazenada. Cada especificador 
de formato inserido na string deve vir acompanhado de um ponteiro para a variável onde o valor 
será armazenado, e na devida ordem em que foram especificados.
44WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
O Quadro 22 a seguir apresenta os especificadores de formato disponíveis. Eles devem ser 
precedidos na string com o caracter “%”.
Tipo de dado Especificador de conversão Descrição
Argumento 
correspondente
Inteiro
d Lê um inteiro decimal com sinal opcional Ponteiro para um int
i Lê um inteiro decimal, octal ou hexadecimal com sinal opcional Ponteiro para um int
o Lê um inteiro octal Ponteiro para um unsigned int
u Lê um inteiro decimal sem sinal Ponteiro para um unsigned int
x ou X Lê um inteiro hexadecimal sem sinal Ponteiro para um unsigned int
h ou l
Colocados antes de qualquer um dos 
especificadores de conversão de inteiros 
para indicar que um inteiro short ou 
um inteiro long deve ser inserido.
N/A
Ponto 
flutuante
e, E, f, g ou G Lê um valor de ponto flutuante Ponteiro para um float
l ou L
Colocados antes de qualquer um dos 
especificadores de conversão de ponto 
flutuante para indicar que um valor 
double ou um long double deve ser 
inserido
Ponteiro para uma 
variável double ou uma 
variável long double
Caracteres e 
strings
c Lê um caractere Ponteiro para um char
s Lê uma string
Ponteiro para um 
vetor do tipo char com 
tamanho suficiente 
para guardar a string 
e um caractere nulo 
(‘\0’) de término, 
automaticamente 
acrescentado
[caracteres de 
varredura]
Varre uma string em busca de um 
conjunto de caracteres que estão 
armazenados em um vetor
N/A
Diversos
p Lê um endereço de memória
Ponteiro para a variável 
de ponteiro que 
armazenará o endereço
n
Armazena o número de caracteres 
inseridos até esse ponto da chamada a
scanf()
Ponteiro para um int
% Salta o sinal de porcentagem (%) na entrada N/A
Quadro 22 – Especificadores de conversão. Fonte: Deitel (2011).
45WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 1
EDUCAÇÃO A DISTÂNCIA
Para usar a função scanf() em um programa, devemos incluir o arquivo de cabeçalho 
padrão stdio.h, conforme explicado na seção 2.4 desta unidade. O Quadro 23 a seguir apresenta 
um programa completo que ilustra diversos exemplos de entrada de dados usando scanf().
#include <stdio.h>
int main(void) { 
 char nome[30], nota;
 float altura;
 int dia, mes, ano;
 printf(“Digite o seu nome: “);
 scanf(“%s”, nome);
 printf(“Digite a altura: “);
 scanf(“%f”, &altura);
 printf(“Nascimento (DD/MM/AAAA): “);
 scanf(“%d/%d/%d”, &dia, &mes, &ano);
 printf(“Digite a nota (A-E): “);
 fflush(stdin); // Para prevenir o bug de não editar
 scanf(“%c”, &nota);
 return 0;
}
Quadro 23 – Exemplos de entrada de dados. Fonte: O autor.
O endereço de memória de cada variável deve ser passado como parâmetro para a função 
scanf(), para que o valor digitado possa ser armazenado nela. Para isso, utilizamos o operador &; 
a única exceção no exemplo do Quadro 23 é a variável nome, que é um vetor de 30 elementos do 
tipo char – abordamos strings com detalhes na Unidade III. No caso da data de nascimento, temos 
três especificadores %d para a entrada respectiva do dia, mês e ano; por isso temos os endereços 
destas variáveis sendo passados na mesma ordem em que aparecem na string de entrada. Para 
concluir, a instrução fflush(stdin); será colocada antes de cada entrada caractere ou string, para 
prevenir um possível bug no buffer de entrada desses tipos de dados, dependendo do compilador