MATERIAL_LINGUAGEM_PROGRAM_I_V1_NZENZU_091517_073337

INSTITUTO SUPERIOR PRIVADO NZENZO ESTRELA
ISPNE - UÍGE
CURSO DE INFORMÁTICA DE GESTÃO
Introdução à Programação I
Luzizila Salambiaku
2022
Ver. 1.0
Introdução à Programação Iº Ano Informática de Gestão – ESPU
Sumário
PREFÁCIO .................................................................................................................................. 5
NA SALA DE AULA DO CURSO............................................................................................. 6
CAPÍTULO 1: ALGORITMOS .................................................................................................. 7
1.1. Algoritmos ......................................................................................................................... 7
1.1.1. Introdução.................................................................................................................... 7
1.2. O que é um algoritmo?..................................................................................................... 8
1.2.1. Definição de Algorítimo .............................................................................................. 8
ALGORITMO PARA FRITAR UM OVO ........................................................................... 9
ALGORITMO PARA ENCHER VASILHAS...................................................................... 9
1.3. Características de um algoritmo ................................................................................... 10
1.4. A Criação de Algoritmos ............................................................................................... 10
1.5. Formas de representação de algoritmos ....................................................................... 11
1.5.1. Descrição Narrativa ................................................................................................... 11
1.5.2. Fluxograma................................................................................................................ 12
1.5.3. Linguagem Algorítmica ............................................................................................ 13
1.6. Recapitulando ................................................................................................................. 14
EXERCÍCIOS PROPOSTOS .............................................................................................. 14
CAPITULO 2: LINGUAGENS DE PROGRAMAÇÃO ....................................................... 15
2.1. Interpretação e compilação ........................................................................................... 15
2.2. Paradigma de programação .......................................................................................... 16
2.2.1. Paradigma imperativo ............................................................................................... 16
2.2.2. Paradigma estruturado ............................................................................................... 16
2.2.3. Paradigma declarativo ............................................................................................... 17
2.2.4. Paradigma orientado a objectos................................................................................. 17
2.3. Escolha da linguagem C para este curso ...................................................................... 17
CAPITULO 3: A LINGUAGEM DE PROGRAMAÇÃO C ................................................ 18
3.1. Breve histórico ................................................................................................................ 18
3.2. Núcleo de um programa ................................................................................................ 18
3.3. Algumas características do C ........................................................................................ 19
3.4. Linguagem de programação C vs C++ ......................................................................... 21
3.5. Forma de um programa em C ....................................................................................... 22
3.5.1. Forma geral de um programa em C ........................................................................... 23
CAPITULO 4: MEMÓRIA E VARIÁVEIS ........................................................................... 27
Elaborado por: Luzizila Salambiaku

E-mail: luzizila2009@gmail.com Página 1 de 73
4.1. Identificadores ................................................................................................................ 27

4.1.1. As regras básicas para formação de identificadores são:........................................... 28
4.2. OS Tipos básicos de dados ............................................................................................. 28
4.3. Variáveis.......................................................................................................................... 31
4.3.1. Declaração de variáveis ............................................................................................. 31
4.4. Constantes ....................................................................................................................... 33
4.4.1. Constantes string ....................................................................................................... 34
4.4.2. Impressões de códigos especiais ............................................................................... 34
CAPITULO 5: MATEMÁTICA BÁSICA (OPERADORES) .............................................. 36
5.1. Operadores Aritméticos ................................................................................................. 36
5.2. Operadores Relacionais e Lógicos ................................................................................ 37
5.2.1. Operadores Relacionais ............................................................................................. 37
5.2.2. Operadores Lógicos................................................................................................... 37
5.3. Operador de Atribuição................................................................................................. 39
5.3.1. Atribuições Múltiplas ................................................................................................ 39
5.4. Outros Operadores......................................................................................................... 39
5.4.1. Operadores Bit a Bit .................................................................................................. 39
5.4.2. O Operador ? ............................................................................................................. 40
5.5. Expressões ....................................................................................................................... 40
5.6. Modeladores (CASTS) ................................................................................................... 41
CAPITULO 6: FUNÇÕES DE ENTRADA E SAÍDA DE DADOS...................................... 43
6.1. Função de saída .............................................................................................................. 43
6.2. Função de entrada .......................................................................................................... 45
CAPITULO 7: COMANDOS DE CONTROLE OU ESTRUTURAS DE CONTROLE DO
PROGRAMA ............................................................................................................................. 48
7.1. Introdução ....................................................................................................................... 48
7.2. Estrutura Sequencial...................................................................................................... 48
7.3. Verdadeiro e Falso em C ............................................................................................... 49
7.4. Comandos de Selecção ou decisão................................................................................. 49
7.4.1. Decisão simples (if) ................................................................................................... 49
7.4.2. Estrutura de decisão composta .................................................................................. 53
7.4.3. A Expressão Condicional .......................................................................................... 55
7.4.4. O Operador ? ............................................................................................................. 56
7.4.5. Comando de decisão múltipla ................................................................................... 57


7.5. Estrutura de Repetição .................................................................................................. 59
7.5.1. Comando while ......................................................................................................... 59
7.5.2. Comando do-while .................................................................................................... 60
7.5.3. Comando for.............................................................................................................. 61
7.5.4. Comandos de Desvio ................................................................................................. 63
CAPITULO 8: FUNÇÕES ....................................................................................................... 67
8.1. Conceitos ......................................................................................................................... 67
8.2. Local de declaração de uma função .............................................................................. 67
8.3. Funcionamento de uma função ..................................................................................... 69
8.4. Parâmetros de uma função ............................................................................................ 69
8.4.1. Declaraçã de parâmetros de uma função ................................................................... 69
8.5. Funções sem lista de parâmetros .................................................................................. 70
REFERÊNCIAS BIBLIOGRÁFICAS .................................................................................... 72

Lista de Figuras
Figura 1: Ilustra dois passos possíveis envolvendo as operações de encher e esvaziar as vasilhas.
Em (a) apenas aprimeira vasilha está cheia. Já em (b) os nove litros da primeira vasilha são
colocados nas outras duas. ............................................................................................................ 9
Figura 2: Formas geométricas utilizadas em fluxogramas .......................................................... 12
Figura 3: Fluxograma para calcular a média aritmética de um estudante ................................... 12
Figura 4: Passos no processo de compilação............................................................................... 16
Figura 5:Processo de Interpretação ............................................................................................. 16
Figura 6: Origem da linguagem C ............................................................................................... 18
Figura 7: Memória RAM .............................................................................................................. 27
Figura 8:Representação da memória em função dos endereços, das posições de memória e das
variáveis....................................................................................................................................... 27
Figura 9: Resultado do programa ................................................................................................ 35
Figura 10: Programa com e sem cast .......................................................................................... 41
Figura 11:Estrutura sequencial na linguagem C.......................................................................... 48
Lista de Tabelas
Tabela 1: Dicas para aprender algoritmos ................................................................................... 11
Tabela 2: Palavras reservadas da linguagem C ........................................................................... 22
Tabela 3:Tipos básicos definidos no padrão ANSI ..................................................................... 29
Tabela 4: Alguns exemplos de constantes................................................................................... 33
Tabela 5: Caractere de barra invertida ........................................................................................ 34
Tabela 6:Operadore aritméticos .................................................................................................. 36
Tabela 7: Operadores aritméticos de atribuição e operadores de incremento. ............................ 37
Tabela 8:Operadores relacionais ................................................................................................. 37
Tabela 9:Operadores lógicos ....................................................................................................... 38
Tabela 10:Operador unário ! ....................................................................................................... 38
Tabela 11: Avaliação de expressões lógicas ............................................................................... 38
Tabela 12: Outros operadores ..................................................................................................... 40
Tabela 13: Especificadores de formatos mais utilizados na função printf() ................................ 44
Tabela 14: Especificadores de formatos mais utilizados da função scanf() ................................ 46
Tabela 15: Tabela de verdade ..................................................................................................... 51
Tabela 16: Teste de expressões .................................................................................................. 52
Tabela 17:Exemplo: comando while ........................................................................................... 60
Tabela 18:Exemplo do-while ...................................................................................................... 61
Tabela 19: Exemplo for ............................................................................................................... 62
Tabela 20: Exemplos for versus while ........................................................................................ 62

PREFÁCIO
Este material é destinado aos estudantes de cursos como Ciência da Computação,
Sistemas de Informação e, sobretudo, Licenciatura em Engenharia Informática do
Instituto Politécnica da UNIKIVI e Informática de Gestão do Instituto Superior Privado
Nzenzo Estrela ISPNE/ Uíge do Uíge. Ele tem o objectivo de apresentar os principais
conceitos da programação de computadores, de modo que sua utilização é mais
adequado a disciplinas introdutórias como a de Introdução à Programação. De forma
alguma o presente material tem a pretensão de cobrir todos os assuntos relacionados à
área de programação. Sua principal finalidade é a de servir como guia para os alunos
que estão dando os primeiros passos nessa área que é tão importante para a engenharia
informática. A disciplina de Introdução à Programação é a primeira de uma sequência
de disciplinas que têm o objectivo de tornar os estudantes capazes de dominar os
fundamentos e as técnicas relacionadas à programação de computadores. Durante o
curso de Licenciatura em Engenaria Informática, especificamente, os estudantes terão a
chance de conhecer em detalhes algumas das linguagens de programação mais
utilizadas actualmente e estarão habilitados a ministrar cursos de programação para
diversos públicos.
Recomendamos ao estudante, iniciante na programação de computadores, que não se

limite à leitura e ao conteúdo deste material. Pesquise na internet outros materiais, leia
outros livros e faça todos os exercícios propostos. Programação, assim como
matemática, requer muito exercício, muita prática. Como mencionado anteriormente, a
programação de computadores é uma das sub áreas mais importantes da carreira que
você escolheu seguir. Boa parte das disciplinas do seu curso depende do conhecimento
adquirido em Introdução à Programação. Portanto, dedique o máximo que puder ao
aprendizado de uma área que vai permiti-lo transformar sonhos em realidade.

NA SALA DE AULA DO CURSO

 Tire dúvidas e discuta sobre as actividades do material com outros integrantes
do curso.
 Leia materiais complementares eventualmente disponibilizados.
 Realize as actividades propostas pelo professor da disciplina.

CAPÍTULO 1: ALGORITMOS
Objectivos do capítulo
Ao final deste capítulo você deverá ser capaz de:
 Definir algoritmo
 Descrever suas principais características
 Criar algoritmos utilizando diferentes formas de representação
É comum pensarmos em uma estratégia para executar uma tarefa do nosso dia a dia,
mesmo que ela seja muito simples. Ao escovar os dentes, por exemplo, nós seguimos
diferentes estratégias. Uns começam com a escovação dos molares e depois partem para
os dentes da frente, outros fazem o inverso. Enfim, existem várias formas de
escovarmos os dentes, assim como existem várias maneiras de realizarmos diversas
atividades. Você sabia que o conjunto de passos para resolver um certo problema ou
realizar determinada tarefa chama-se algoritmo? E que eles são importantíssimos para a
programação de computadores?
Neste capítulo estudaremos as características dos algoritmos, suas formas de

representação e, sobretudo, a relação entre eles e a programação de computadores.
1.1. Algoritmos
1.1.1. Introdução
Fonte inspiradora de livros e filmes, o americano Monty Roberts, conhecido como o

“encantador de cavalos”, revolucionou a forma de domar cavalos. Ao estudar o
comportamento de cavalos selvagens, percebeu que existe entre eles uma linguagem
corporal compartilhada. Entendendo tal linguagem, conseguiu rapidamente ganhar a
confiança de cavalos arredios e instruí-los a se comportarem como desejava. Além de
não usar de violência, essencial no emprego dos métodos convencionais, seu método é
capaz de domar cavalos em poucos dias, ao contrário da maioria, que normalmente
necessita de várias semanas.
Assim como os cavalos, os computadores também são instruídos por meio de uma
linguagem particular. Para que eles se comportem como desejamos, basta que sejam
comandados a partir de uma linguagem que sejam capazes de entender. Diferentemente
do que ensina o senso o comum, os computadores não possuem inteligência. Seu único
trabalho é processar dados, conforme uma sequência de instruções que fazem parte do
vocabulário da linguagem que eles conseguem compreender. A ilusão de que eles
realizam tarefas de forma inteligente é proporcionada através desse conjunto ordenado
de instruções, que é denominado de algoritmo. Neste caso, o “domador” do
computador, responsável por elaborar o algoritmo que vai orientá-lo na execução de
uma determinada tarefa, é chamado de programador de computadores.

1.2. O que é um algoritmo?
A palavra “algoritmo” é derivada do nome Mohammed ibn Musa Al-Khowarizmique,

que foi um matemático, astrólogo, astrônomo e autor persa. Ele fez parte de um centro
acadêmico conhecido como a Casa da Sabedoria, em Bagdá, por volta de 800 d.C. Seus
trabalhos introduziram o cálculo hindu aos árabes e, a partir daí, ao resto da Europa.
Não obstante os algoritmos representam um conceito central na Ciência da Computação,
sua atuação não se limita a essa área do conhecimento. Rotineiramente, lidamos com
algoritmos na realização das mais variadas tarefas. Eles podem ser utilizados para lavar
um carro, preparar um bolo, tomar banho, montar um guarda-roupa, etc. Perceba que os
algoritmos não devem ser confundidos com as actividades. Eles se referem aos passos
seguidos para que estas sejam realizadas. Como exemplo de algoritmos, podemos citar
as instruções para montagem de equipamentos, para utilização de cosméticos como
shampoos e condicionadores, para saída de emergência em meios de transporte, receitas
culinárias, manuais de uso, entre outros. A partir do que foi exposto, podemos definir
algoritmo como uma sequência finita, ordenada e não ambígua de passos para
solucionar determinado problema ou realizar uma tarefa. Na Engenharia Informática,
esse conceito foi formalizado em 1936, por AlanTuring e Alonzo Church.
1.2.1. Definição de Algorítimo
Um algoritmo é um conjunto não ambíguo e ordenado de passos executáveis que

definem um processo finito.
O conceito de algoritmo é frequentemente ilustrado pelo exemplo de uma receita,

embora muitos algoritmos sejam mais complexos. Eles podem repetir passos (fazer
iterações) ou necessitar de decisões (tais como comparações ou lógica) até que a tarefa
seja completada. Um algoritmo correctamente executado não irá resolver um problema
se estiver implementado incorretamente ou se não for apropriado ao problema. Um
algoritmo não representa, necessariamente, um programa de computador, e sim os
passos necessários para realizar uma tarefa. Sua implementação pode ser feita por um
computador, por outro tipo de autômato ou mesmo por um ser humano. Diferentes
algoritmos podem realizar a mesma tarefa usando um conjunto diferenciado de
instruções em mais ou menos tempo, espaço ou esforço do que outros. Tal diferença
pode ser reflexo da complexidade computacional aplicada, que depende de estruturas de
dados adequadas ao algoritmo. Por exemplo, um algoritmo para se vestir pode
especificar que você vista primeiro as meias e os sapatos antes de vestir a calça
enquanto outro algoritmo especifica que você deve primeiro vestir a calça e depois as
meias e os sapatos. Fica claro que o primeiro algoritmo é mais difícil de executar que o
segundo apesar de ambos levarem ao mesmo resultado.
O exemplo a seguir mostra como pode ser elaborado um algoritmo para realizar uma
actividade com a qual lidamos corriqueiramente:

ALGORITMO PARA FRITAR UM OVO

1. Retire o ovo da geladeira.
2. Coloque a frigideira no fogo.
3. Coloque óleo na frigideira.
4. Quebre ovo, separando a casca.
5. Ponha a clara e a gema na frigideira.
6. Espere um minuto.
7. Apague o fogo.
8. Retire o ovo da frigideira.
Agora considere o seguinte problema. Suponha que você dispõe de duas vasilhas de
nove e quatro litros respectivamente. Como elas não possuem marcação, não é possível
ter medidas intermediárias sobre o volume ocupado. O problema consiste, então, em
elaborar uma sequência de passos, por meio da utilização das vasilhas de nove e quatro
litros, a fim de encher uma terceira vasilha com seis litros de água. A figura abaixo
ilustra dois possíveis passos de um algoritmo para resolver o problema.
Figura 1: Ilustra dois passos possíveis envolvendo as operações de encher e esvaziar as

vasilhas. Em (a) apenas aprimeira vasilha está cheia. Já em (b) os nove litros da
primeira vasilha são colocados nas outras duas.
Uma solução para o problema pode ser alcançada a partir do seguinte algoritmo:
ALGORITMO PARA ENCHER VASILHAS
1. Encha a vasilha de nove litros.

2. Usando a vasilha de nove litros, encha a de quatro.
3. Coloque a quantidade que sobrou (cinco litros) na terceira vasilha (v3=5).
4. Esvazie a vasilha de quatro litros.
5. Encha novamente a vasilha de nove litros.
6. Usando a vasilha de nove litros, encha a de quatro.
7. Esvazie a de quatro litros.

8. Usando a sobra da de nove litros (cinco litros), encha novamente a de quatro

litros.
9. Coloque a sobra da de nove litros (agora um litro) na terceira vasilha
(v3=5+1=6).
1.3. Características de um algoritmo
Todo algoritmo, seja ele computacional ou não, recebe uma entrada, processa-a e gera
uma saída segundo seu conjunto de passos. No caso do algoritmo para fritar ovo, a
entrada corresponde à frigideira, ao ovo e ao óleo. O processamento ocorre com a
execução de seus passos, gerando como saída o ovo frito.
Os algoritmos computacionais, especificamente, possuem as seguintes características:
Definição: Os passos de um algoritmo devem ser bem definidos, objectivando a clareza

e evitando ambiguidades.
Finitude: Um algoritmo deve chegar ao seu fim após um número finito de passos.
Efectividade: Um algoritmo deve ser efectivo, ou seja, suas operações devem ser
básicas o suficiente para que possam, em princípio, serem executadas de maneira exata
e em um tempo finito.
Entradas: Um algoritmo deve possuir zero ou mais entradas. Estas são insumos ou
quantidades que são processados pelos algoritmos durante a execução de seus passos.
Saídas: Um algoritmo deve possuir uma ou mais saídas. Elas representam o resultado
do trabalhado realizado pelos algoritmos.
1.4. A Criação de Algoritmos
A noção de algoritmo é central para toda a computação. A criação de algoritmos para

resolver os problemas é uma das maiores dificuldades dos iniciantes em programação
em computadores. Isto porque não existe um conjunto de regras, ou seja, um algoritmo,
que nos permita criar algoritmos. Caso isto fosse possível, a função de criador de
algoritmos desapareceria. Claro que existem linhas mestras e estruturas básicas, a partir
das quais podemos criar algoritmos, mas a solução completa depende em grande parte
do criador do algoritmo. Geralmente existem diversos algoritmos para resolver o
mesmo problema, cada um segundo o ponto de vista do seu criador. Um algoritmo não é
a solução de um problema, pois, se assim fosse, cada problema teria um único
algoritmo. Um algoritmo é um “caminho” para a solução de um problema e, em geral,
existem muitos caminhos que levam a uma solução satisfatória, ou seja, para resolver o
mesmo problema podem-se obter vários algoritmos diferentes. Para resolver um
problema no computador é necessário que seja primeiramente encontrada uma maneira
de descrever este problema de uma forma clara e precisa. É preciso que encontremos
uma sequência de passos que permitam que o problema possa ser resolvido de maneira
automática e repetitiva. Esta sequência de passos é chamada de algoritmo. Sem dúvida

alguma, uma das formas mais eficazes de aprender algoritmos é através de muitos
exercícios. Poderíamos resumir com as seguintes dicas:
Tabela 1: Dicas para aprender algoritmos
Algoritmos não se aprende... Algoritmos se aprende...

Copiando algoritmos Construindo algoritmos
Estudando algoritmos prontos Testando algoritmos
O aprendizado da Lógica é essencial para a formação de um bom programador, servindo

como base para o aprendizado de todas as Linguagens de Programação, estruturadas ou
não. De um modo geral esses conhecimentos serão de supra importância, pois ajudarão
no cotidiano, desenvolvendo um raciocínio rápido.
Ao logo de todo este curso, os conceitos básicos de Lógica necessários à programação

de computadores estarão diluídos entre os capítulos.
1.5. Formas de representação de algoritmos
As formas mais comumente utilizadas para representar algoritmos são as seguintes:
 Descrição narrativa
 Gráficas (fluxograma, diagrama, etc.)
 Linguagem Algorítmica (linguagem de programação e pseudo-
linguagem/portugol)
Todas elas apresentam pontos fortes e fracos, não existindo consenso entre os
especialistas sobre a melhor forma de representação. Apresentaremos as nuances de
cada uma nas próximas seções.
1.5.1. Descrição Narrativa
Os algoritmos são expressos em linguagem natural (português, inglês, francês,

espanhol, kikongo, lingala, nganguela, fioti, etc.). Sua principal desvantagem se
encontra no fato da linguagem natural estar bem distante da linguagem utilizada pelos
computadores. Logo, a tradução de uma para a outra se torna uma atividade bastante
dispendiosa. Além disso, linguagens naturais são mais propensas a ambiguidades.
Muitas vezes uma palavra pode ter vários significados, dependendo do contexto no qual
são utilizadas. Em contra partida, é bem mais fácil elaborar um algoritmo por meio de
uma linguagem com a qual já temos uma certa familiaridade, do que através de
linguagens que não são utilizadas com frequência no dia a dia. Os exemplos de
algoritmos mostrados anteriormente (Algoritmo para fritar um ovo e Algoritmo para
encher vasilhas ) refletem esta forma de representação.

1.5.2. Fluxograma
Consisteemusarformasgeométricaspadronizadasparadescreverospassosaseremexecutado
spelos algoritmos. As formas apresentadas na Figura 2 são as mais comumente
utilizadas em fluxogramas.
Figura 2: Formas geométricas utilizadas em fluxogramas
A vantagem de se fazer uso dos fluxogramas está na facilidade de compreendê-los.

Descrições de algoritmos mediante formas gráficas são mais facilmente compreendidas
do que descrições que envolvem apenas textos. Além do mais, os fluxogramas possuem
um padrão mundial no que se refere à sua simbologia, tornando sua utilização
independente das peculiaridades das linguagens naturais.
A figura abaixo mostra um algoritmo para calcular a média final de um aluno com base
em suas notas e classificá-lo como aprovado ou reprovado, como exemplo do uso de
fluxograms. Analisando-a com mais cuidado, é possível perceber que os fluxogramas
tendem a crescer bastante quando descrevem algoritmos constituídos de muitos passos,
o que dificulta tanto sua construção como sua visualização. Além dessa desvantagem,
por impor regras para sua utilização de acordo com cada forma geométrica, há uma
limitação no seu poder de expressão, se comparado com a descrição narrativa.
Figura 3: Fluxograma para calcular a média aritmética de um estudante

1.5.3. Linguagem Algorítmica
A linguagem que o computador é capaz de compreender tem grande influência na

elaboração de algoritmos projetados para ele. Seus passos não podem conter instruções
desconhecidas ou fazer referência a símbolos ou expressões que os computadores não
conseguem decifrar. Tal linguagem, tantas vezes mencionada neste capítulo, se baseia
em conceitos e em arquiteturas de hardware que determinam o funcionamento básico de
um computador. Dentre as existentes, a mais utilizada nos computadores atuais é a
arquitetura de Von Neumann. Seu autor, JohnVon Neumann, propôs um modelo em que
as instruções e os dados ficam juntos na memória.
O processador busca as instruções na memória e as executa uma de cada vez, segundo o

seguinte ciclo de execução:
1. Busca instrução;
2. Decodifica instrução;
3. Executa instrução;
4. Volta para o passo 1 para buscar a instrução seguinte na memória.
A linguagem algorítmica, também chamada de pseudocódigo ou pseudo-linguagem, por

sua vez, consiste no emprego de uma linguagem intermediária entre a linguagem natural
e uma linguagem de programação. Esse meio termo resulta em uma linguagem que se
aproxima das construções de uma linguagem de programação, sem exigir, no entanto,
rigidez na definição das regras para utilização de suas instruções. Geralmente, essa
forma de representação de algoritmos é uma versão reduzida de linguagens de alto nível
como C e Pascal. Segue abaixo o algoritmo em pseudocódigo:
1 ALGORITMO
2 DECLARE nota1, nota2, M : NUMERICO
3 LEIA nota1
4 LEIA nota2
5 M ← (nota1 + nota2) / 2
6 SE M >= 9.5 ENTÃO
7 ESCREVA "Aprovado"
8 SENÃO
9 ESCREVA "Reprovado"
10 FIM-SE
11 FIM_ALGORITMO
As palavras em letras maiúsculas correspondem a palavras reservadas/chaves que fazem

parte do conjunto de regras que a linguagem algorítmica deve seguir. Embora sejam
mais flexíveis do que as linguagens de programação em relação ao seu uso (a instrução
LEIA, por exemplo, muitas vezes é substituída por LER, OBTER, etc.), algumas
palavras são necessárias, pois facilitam o entendimento e aproximam o pseudocódigo de
um programa de computador. As palavras INÍCIO e FIM, por exemplo, indicam onde
começa e termina o algoritmo. Já as instruções LEIA e ESCREVA referem-se a

operações de entrada e saída de dados (ex.: ler dados do teclado ou exibir uma frase no
monitor), presentes na maioria das linguagens de programação. Seguindo com a
explicação do algoritmo, perceba que a linha com a instrução M ← (nota1 + nota2) / 2
contém dois símbolos ainda não apresentados. O símbolo / diz respeito à operação
aritmética da divisão, ao passo que o símbolo←expressa uma operação de atribuição,
que pode ser lida da seguinte forma: A posição de memória, representada
simbolicamente por M, recebe o valor da soma de nota1 e nota2, dividido por dois. Para
finalizar, a linha 6 apresenta uma estrutura de controle condicional essencial para as
linguagens de programação. Operações de atribuição, expressões e estruturas de
controle fazem parte do núcleo das linguagens de programação imperativa se são,
portanto, fundamentais para o aprendizado da programação. Todos esses assuntos serão
abordados de forma mais aprofundada em capítulos posteriores. A principal vantagem
da forma de representação em linguagem algorítmica está na facilidade com a qual um
pseudocódigo pode ser transcrito para uma linguagem de programação. Assim como os
fluxogramas, a desvantagem fica por conta da limitação do seu poder de expressão,
devido às regras impostas para a elaboração das instruções.
1.6. Recapitulando
Neste capítulo você estudou algoritmos, suas principais características e suas formas de
representação. Apesar de ser um tema mais abordado na ciência da computação,
algoritmos estão presentes nas mais diversas áreas e em várias atividades do cotidiano.
Lidamos com eles, por exemplo, quando tomamos banho, cozinhamos, planejamos uma
rota para fugirmos do trânsito, consultamos um manual de montagem, enfim, sempre
que nos deparamos com um conjunto lógico de passos para realizarmos uma tarefa ou
solucionarmos um problema, estamos em contato com algoritmos. É por meio deles que
os computadores passam a ilusão de que são inteligentes, realizando tarefas capazes de
impressionar qualquer ser humano. No entanto, sabemos que eles apenas processam
dados, segundo um conjunto de instruções que lhe são passadas-os algoritmos.
EXERCÍCIOS PROPOSTOS
1. Explique, com suas próprias palavras, o que é algoritmo.

2. Rotineiramente, usamos algoritmos para as mais diversas tarefas. Cite três algoritmos
que podemos encontrar no dia a dia.
3. Em que consiste a característica de efectividade de um algoritmo?
4. Suponha que o quarto passo de um determinado algoritmo ordene que a execução
retorne ao primeiro. Qual característica não está sendo satisfeita por esse algoritmo?
5. Escreva um algoritmo, em pseudocódigo, que receba como entrada a base e a altura
de um triângulo, calcule e exiba sua área.

CAPITULO 2: LINGUAGENS DE PROGRAMAÇÃO

Linguagens de programação são conjuntos de códicos, comandos, regras e padrões
predefinidos com os quais criamos linhas de instruções que, em conjunto, formam
programa (Miyagusku, 2009, p. 94).
Uma linguagem de programação é um conjunto de regras sintáticas e semânticas usadas

para definir um programa de computador. Uma linguagem permite que um programador
especifique precisamente sobre quais dados um computador vai atuar, como estes dados
serão armazenados ou transmitidos e quais ações devem ser tomadas sob várias
circunstâncias.
Linguagens de programação também tornam os programas menos dependentes de

computadores ou ambientes computacionais específicos (propriedade chamada de
portabilidade). Isto acontece porque programas escritos em linguagens de programação
são traduzidos para o código de máquina do computador no qual será executado em vez
de ser diretamente executado.
2.1. Interpretação e compilação
Uma linguagem de programação pode ser convertida, ou traduzida, em código de

máquina por compilação ou interpretação, que juntas podem ser chamadas de tradução.
Se o método utilizado traduz todo o texto do programa (também chamado de código),
para só depois executar (ou “rodar”, como se diz no jargão da computação) o programa,
então diz-se que o programa foi compilado e que o mecanismo utilizado para a tradução
é um compilador (que por sua vez nada mais é do que um programa). A versão
compilada do programa tipicamente é armazenada, de forma que o programa pode ser
executado um número indefinido de vezes sem que seja necessária nova compilação, o
que compensa o tempo gasto na compilação. Isso acontece com linguagens como Pascal
e C. Se o texto do programa é traduzido à medida que vai sendo executado, como em
Javascript, Python ou Perl, num processo de tradução de trechos seguidos de sua
execução imediata, então diz-se que o programa foi interpretado e que o mecanismo
utilizado para a tradução é um interpretador. Programas interpretados são geralmente
mais lentos do que os compilados, mas são também geralmente mais flexíveis, já que
podem interagir com o ambiente mais facilmente.
Embora haja essa distinção entre linguagens interpretadas e compiladas, as coisas nem
sempre são tão simples. Há linguagens compiladas para um código de máquina de uma
máquina virtual (sendo esta máquina virtual apenas mais um software, que emula a
máquina virtual sendo executado em uma máquina real), como o Java e a plataforma
MS.NET.

Figura 4: Passos no processo de compilação
Figura 5:Processo de Interpretação
2.2. Paradigma de programação
Um paradigma de programação fornece e determina a visão que o programador possui

sobre a estruturação e execução do programa. Por exemplo, em programação orientada a
objectos, programadores podem abstrair um programa como uma coleção de objectos
que interagem entre si, enquanto em programação funcional os programadores abstraem
o programa como uma sequência de funções executadas de modo empilhado.
Um paradigma de programação está relacionado com a forma de pensar do programador

na construção de soluções para os problemas com os quais se depara. Programar
seguindo um determinado paradigma de programação significa representar soluções a
partir de uma forma particular de raciocinar na elaboração dos algoritmos. Como os
paradigmas mencionados sustentam a atividade de programas, eles influenciam todo o
processo de desenvolvimento de software. Alguns dos paradigmas de programação mais
utilizados estão relacionados abaixo:
2.2.1. Paradigma imperativo
Representa a computação como ações, enunciados ou comandos que alteram o estado

(variáveis) de um programa. Consiste na elaboração de programa a partir de comandos
que dizem o que o computador deve fazer a cada momento.
2.2.2. Paradigma estruturado
Soluciona problemas apartir de sua quebra em problemas menores, de mais fácil

solução, denominados desub-rotinas ou subprogramas. Normalmente, o trabalho de
cada sub-rotina consiste em receber dados como entrada, processar esses dados e
retornar o resultado do processamento para o módulo de software que o executou. Este

paradigma ainda defende que todo processamento pode ser realizado pelo uso de três
tipos de estruturas: sequencial, condicional e de repetição. É o paradigma adotado neste
manual.
2.2.3. Paradigma declarativo
Descreve as características da solução desejada sem especificar como o algoritmo em si

deve agir. Em contraste como paradigma imperativo, que informa ao computador como
as instruções devem ser executadas, o paradigma declarativo preocupa-se apenas em
definir o que deve ser feito, deixando a cargo de outros softwares decidirem como
alcançar a solução descrita. É bastante utilizado no desenvolvimento das páginas web
(linguagem html) e na descrição de documentos multimídia através da linguagem
Nested Context Language – NCL, adotada pelo padrão brasileiro de TV Digital.
2.2.4. Paradigma orientado a objectos
Enxerga o problema como uma colecção de objectos que se comunicam por meio da
troca de mensagens. Os objectos são estruturas de dados que possuem estado (variáveis)
e comportamento (lógica).
2.3. Escolha da linguagem C para este curso
O capítulo seguinte introduzirá a linguagem de programação C, que será adotada de

maneira exclusiva ao longo de todo esse ano academico. Os motivos que motivam a
escolha da linguagem C são vários, muitos dos quais serão vistos no capítulo seguinte.
Porém, podemos citar:
 É uma linguagem muito usada no contexto de programação de
microprocessadores e microcontroladores, especialmente de sistemas
embarcados, comuns à área de controle e automação.
 É a linguagem que serviu de base para as principais linguagens usadas
comercialmente, hoje, no mundo, como C++, Java e C#. Assim sendo, uma vez
familiarizado com a linguagem C, o aprendizado das demais torna-se mais fácil.

CAPITULO 3: A LINGUAGEM DE PROGRAMAÇÃO C

3.1. Breve histórico
A linguagem C foi desenvolvida e implementada por Dennis Ritchie, entre os anos

1970 e 1973, nos laboratórios da AT&T. O objectivo de Ritchie era criar uma
linguagem para a implementação de sistemas operacionais e softwares básicos que
combinasse a eficiência das linguagens de baixo nível com características das
linguagens de alto nível, como legibilidade, portabilidade e manutenibilidade.
A criação da linguagem C é resultado de um processo evolutivo de linguagens, iniciado

com uma linguagem chamada BCPL, desenvolvida por Martin Richards. Essa
linguagem influenciou a linguagem B, inventada por Ken Thompson, que por sua vez
levou ao desenvolvimento de C. Em 1973, Dennis Ritch não deixou dúvidas que seu
objectivo foi alcançado, desenvolvendo eficientemente parte do sistema Unix na
linguagem C.
A partir de meados dos anos 80, C começou a ganhar popularidade e, devido à sua
flexibilidade em actuar com características de linguagens de alto e baixo nível, foi
reconhecida como uma linguagem de propósito geral, sendo utilizada na implementação
de uma grande variedade de sistemas.
Figura 6: Origem da linguagem C
Devido à importância auferida na área da programação de computadores, C é hoje uma

das linguagens mais utilizadas em cursos de programação do mundo inteiro. Sendo
assim, ela é a linguagem que lhe guiará na compreensão das nuances da arte de
programar e servirá como ferramenta para elaboração dos seus primeiros programas.
A linguagem C será apresentada, de forma conveniente, a partir do próximo ponto.
3.2. Núcleo de um programa
A organização da sequência de instruções em um programa obedece a um conjunto de

regras estabelecidas pela linguagem de programação. Um programa em C é estruturado
em funções, que são, basicamente, trechos de código que podem ser chamados várias
vezes para realizar uma certa tarefa. Assim, todas as instruções pertencentes a um
programa em C devem estar contidas em uma função.
Além de ser um meio de agrupar trechos de um código, uma função em programação

tem características semelhantes a uma função matemática, no sentido de que recebe
parâmetros como entrada (seria o domínio da função) e retorna um valor como saída
(imagem).

Em C existe uma função especial, denominadade main (principal), que determina o

início e o fim da execução de um programa. De forma mais específica, a execução de
um programa tem seu início com a execução da primeira instrução da função main e
termina com a execução da sua última instrução. Dessa maneira, todo programa em C
deve possuir tal função.
3.3. Algumas características do C
Dentre as várias características da linguagem C, poderíamos citar:

C é uma linguagem de médio nível
C é frequentemente chamada de linguagem de médio nível para computadores. Isso não

significa que C seja menos poderosa, difícil de usar ou menos desenvolvida que uma
linguagem de alto nível como BASIC e Pascal, tampouco implica que C seja similar a
linguagem assembly e seus problemas correlatos aos usuários.
C é tratada como uma linguagem de médio nível porque combina elementos de

linguagens de alto nível com a funcionalidade da linguagem assembly.
Como uma linguagem de médio nível, C permite a manipulação de bits, bytes e

endereços – os elementos básicos com os quais o computador funciona.
Um código escrito em C é muito portável.
Portabilidade significa que é possível adaptar um software escrito para um tipo de

computador (e/ou sistema operacional) para outro. Por exemplo, se você pode com
relativa facilmente converter um programa escrito para Windows de tal forma a
executar sob o Linux, então esse programa é portável.
Outro aspecto importante de C é que ele tem apenas 32 palavras reservadas ou chaves
(27 do padrão de fato estabelecido por Kernighan e Ritchie, mais 5 adicionadas pelo
comitê ANSI de padronização), que são os comandos que compõem a linguagem C. As
linguagens de alto nível tipicamente tem várias vezes esse número de palavras
reservadas. Como comparação, considere que a maioria das versões de BASIC possuem
bem mais de 100 palavras reservadas!
C é uma linguagem estruturada

Embora o termo linguagem estruturada em blocos não seja rigorosamente aplicável a C,
ela é normalmente referida simplesmente como linguagem estruturada. C tem muitas
semelhanças com outras linguagens estruturadas, como o Pascal.
A característica especial de uma linguagem estruturada é a compartimentalização do

código e dos dados. Trata-se da habilidade de uma linguagem seccionar e esconder do
resto do programa todas as informações necessárias para se realizar uma tarefa
especifica.

Uma das maneiras de conseguir essa compartimentalização é pelo uso de sub-rotinas

que empregam variáveis locais (temporárias). Com o uso de variáveis locais é possível
escrever sub-rotinas de forma que os eventos que ocorrem dentro delas não causem
nenhum efeito inesperado nas outras partes do programa.
Essa capacidade permite que seus programas em C compartilhem facilmente seções de

código. Se você desenvolve funções compartimentalizadas, só precisa saber o que uma
função faz, não como ela faz. O uso excessivo de variáveis globais (variáveis
conhecidas por todo o programa) pode trazer muitos erros, por permitir efeitos
colaterais indesejados.
O principal componente estrutural de C é a função, a sub-rotina isolada de C. Em C,

funções são os blocos de construção em que toda a atividade do programa ocorre. Elas
admitem que você defina e codifique separadamente as diferentes tarefas de um
programa, permitindo, então, que seu programa seja modular. Após uma função ter sido
criada, você pode esperar que ela trabalhe adequadamente em varias situações, sem criar
efeitos inesperados em outras partes do programa. O fato de você poder criar funções
isoladas é extremamente importante em projetos maiores nos quais um código de um
programador não deve afetar acidentalmente o de outro.
Outra forma de estruturar e compartimentalizar o código em C é pelo uso de blocos de
código. Um bloco de código é um grupo de comandos de programa conectado
logicamente que é tratado como uma unidade. Em C, um bloco de código é criado
colocando-se uma sequência de comandos entre chaves.
C é uma linguagem para programadores.

Surpreendentemente, nem todas as linguagens de computador são para programadores.
Considere os exemplos clássicos de linguagens para não-programadores: COBOL e
BASIC. COBOL não foi destinada para facilitar a vida do programador, aumentar a
segurança do código produzido ou a velocidade em que o código pode ser escrito. Ao
contrário, COBOL foi concebida, em parte, para permitir que não-programadores leiam
e presumivelmente (embora isso seja improvável) entendam o programa. BASIC foi
criada essencialmente para permitir que não-programadores programem um computador
para resolver problemas relativamente simples.
Em contraposição, C foi criada, influenciada e testada em campo por programadores
profissionais.
O resultado final é que C dá ao programador o que ele quer: poucas restrições, poucas
reclamações, estruturas de bloco, funções isoladas e um conjunto compacto de palavras-
chave. Usando C, um programador pode conseguir aproximadamente a eficiência de
código assembly combinada com a estrutura de uma linguagem de alto nível. Não é de
admirar que C seja tranquilamente a linguagem mais popular entre excelentes
programadores profissionais.

Em virtude da sua portabilidade e eficiência, a medida que C cresceu em popularidade,

muitos programadores começaram a usá-la para programar todas as tarefas. Por haver
compiladores C para quase todos os computadores, é possível tomar um código escrito
para uma máquina, compilá-lo e rodá-lo em outra com pouca ou nenhuma modificação.
Esta portabilidade economiza tempo e dinheiro.
Alem disso, os programadores usam C em vários tipos de trabalho de programação

porque eles gostam de C! Ela oferece a velocidade da linguagem assembly, mas poucas
das restrições presentes em outras linguagens. Cada programador C pode, de acordo
com sua própria personalidade, criar e manter uma biblioteca única de funções
customizadas, para ser usada em muitos programas diferentes. Por admitir — na
verdade encorajar — a compilação separada, C permite que os programadores
gerenciem facilmente grandes projetos com mínima duplicação de esforço.
3.4. Linguagem de programação C vs C++
Algumas vezes os novatos confundem o que é C e como difere de C++. Para ser breve,
C++ é uma versão estendida e melhorada de C que é projectada para suportar POO -
programação orientada a objectos (OOP, derivado do inglês Object Oriented
Programming). C++ contém e suporta toda a linguagem C e mais um conjunto de
extensões orientadas a objectos. (Ou seja, C++ é um superconjunto de C.) Como C++ é
construída sobre os fundamentos de C, você não pode programar em C++ se não
entender C. Portanto, virtualmente tudo que é aprendido sobre C, aplica-se também a
C++.
Actualmente, e por muitos anos ainda, muitos programadores ainda escreverão,

manterão e utilizarão programas C, e não C++. Como mencionado, C suporta
programação estruturada. A programação estruturada tem-se mostrado eficaz ao longo
dos muitos anos em que tem sido usada largamente. C++ é projetada principalmente
para suportar POO, que incorpora os princípios da programação estruturada, mas inclui
objectos.
Embora a POO seja muito eficaz para uma certa classe de tarefas de programação,
muitos programas não se beneficiam da sua aplicação. Por isso, “código direto em C”
estará em uso por muito tempo ainda, a depender da classe de problema em que é
aplicado.
Durante a experiência com o ensino de linguagem C, pude, como professor, observar

alguns alunos que tinham algum conhecimento prévio da linguagem. No entanto, apesar
de haver uma clara distinção entre C e C++, alguns deles tinham um conhecimento
“misto” das duas linguagens. Vamos deixar algo claro: Se você não usará os recursos de
POO (classes, herança, polimorfismo, etc.) não faz sentido escrever um código que
poderia ser muito mais simples, em C, nos moldes de C++. O exemplo mais claro disso
talvez seja o uso dos objectos cin e cout (que obrigam o uso dos operadores

sobrecarregados >> e <<) sem nem mesmo saber o que são objectos. Não é muito mais
simples e compreensível usar as funções printf() e scanf() da biblioteca padrão do C?
O ponto chave a ser enfatizado neste sentido é: Cada linguagem carrega consigo uma
filosofia, que orienta a forma de pensar do programador. Cada uma dessas filosofias
(também chamadas de paradigmas) tem seus próprios conceitos e definições, que devem
ser plenamente entendidos pelo programador.
A programação orientada a objectos torna uma categoria de projetos mais simples de ser
desenvolvida e mantida. No entanto, incorporam diversos conceitos complexos para um
programador iniciante que, se não compreendidos plenamente, podem muito mais
complicar que ajudar. De longe o paradigma estruturado é mais simples e direto que o
orientado a objectos. Portanto, o conselho é: Se não precisa dos recursos da POO e
ainda por cima é um programador com pouca ou nenhuma experiência, não use C++.
Seja simples. Adote primeiramente o C. Migre para o C++ apenas depois de dominar
plenamente o C.
3.5. Forma de um programa em C
A tabela abaixo lista as 32 palavras-chave (ou palavras reservadas) que, combinadas

com a sintaxe formal de C, formam a linguagem de programação C. Destas, 27 foram
definidas pela versão original de C. As cinco restantes foram adicionadas pelo comitê
ANSI: enum, const, signed, void e volatile.
Tabela 2: Palavras reservadas da linguagem C
auto double int struct

break else long switch
case enum register typedef
char extern return union
const float short unsigned
continue for signed void
default goto sizeof volatile
do if static while
O compilador pode também suportar outras extensões que ajudem a aproveitar melhor
seu ambiente especifico.
Todas as palavras reservadas (palavras-chave) de C são minúsculas. Em C, maiúsculas

e minúsculas são diferentes: else é uma palavra-chave, mas ELSE não. Uma palavra-
chave não pode ser usada para nenhum outro propósito em um programa em C, ou seja,
ela não pode servir como uma variável ou nome de uma função. É preciso ressaltar esse

ponto de suma importância: o C é “Case Sensitive”, isto é, MAIÚSCULAS e

minúsculas fazem diferença. Se se declarar uma variável com o nome luzizila ela será
diferente de Luzizila, LUZIZILA, LuziZila ou luZizilA. Da mesma maneira, os
comandos do C if e for, por exemplo, só podem ser escritos em minúsculas pois senão o
compilador não irá interpretá-los como sendo comandos, mas sim como variáveis.
Todo programa em C consiste em uma ou mais funções. A única função que

necessariamente precisa estar presente é a denominada main(), que é a primeira função a
ser chamada quando a execução do programa começa. Em um código de C bem escrito,
main() contém, em essência, um esboço do que o programa faz. O esboço é composto
de chamadas de funções. Embora main() não seja tecnicamente parte da linguagem C,
trate-a como se fosse. Não tente usar main() como nome de uma variável porque
provavelmente confundirá o compilador.
3.5.1. Forma geral de um programa em C
A forma geral de um programa em C é ilustrada abaixo, onde f1() até fN() representam
funções definidas pelo usuário.
declarações globais.
tipo_devolvido main(lista_de_parâmetros)
sequência de comandos
}
tipo devolvido f1(lista de parâmetros)
{
}
tipo devolvido f2(lista de parâmetros)
{
}
.
.
.
tipo devolvido fN(lista de parâmetros)
{
}

Iniciaremos nosso estudo com um programa extremamente simples, que apenas

imprime uma mensagem na tela:
#include <stdio.h>
/* Um Primeiro Programa */
int main() {
printf("Meu primeiro programa!\n");
system ("pause");
return 0;
Analisando o que ocorre em cada linha de código:

#include <stdio.h>
Esta linha de código solicita ao compilador que inclua no programa a biblioteca padrão
para comandos de entrada e saída da linguagem C. Uma biblioteca consiste em um
conjunto de arquivos que contém funções que podem ser incorporadas a outros
programas. Neste caso, a inclusão da biblioteca stdio.h permite que o programa utilize
suas funções para ler dados da entrada padrão (teclado) e para escrever dados na saída
padrão (tela).
Quando fazemos um programa, uma boa ideia é usar comentários que ajudem a
elucidar o funcionamento do mesmo. Um comentário pode, inclusive, ter mais de uma
linha. No exemplo apresentado temos um comentário:
/*Primeiro Programa em C*/

int main(){
Com esta linha de código definimos a função main (função principal – inicio do
programa) e demarcamos o seu início com o caractere { (abre-chaves/chavetas). Todo
conteúdo de uma função em C fica delimitado por chaves/chavetas ( {} ).
printf("Meu primeiro programa!\n");

O programa tem seu início com a execução desta instrução, uma vez que ela é a
primeira instrução da função main. A função printf tem a finalidade de escrever na tela
os dados recebidos por parâmetro. Como resultado de sua execução, neste caso, será
exibida a frase "Meu primeiro programa!" no canto superior esquerdo do monitor do
nosso computador.
O ponto-e-vírgula no fim da instrução serve para separar esta instrução da próxima,

dessa maneira, cada instrução deve terminar com sua utilização.

return 0;
Essa instrução encerra a execução do programa, de modo que deve ser sempre a última
da função main (antes do fecha-chaves, é claro). O número 0 (zero) serve para indicar
ao sistema operacional que o programa terminou com sucesso (números diferentes de
zero indicariam um erro). Entenderemos melhor como isso funciona quando
abordarmos detalhadamente as funções, mais adiante.
Podemos agora tentar um programa mais complicado:
#include <stdio.h>
int main()
{
int dias; /* Declaração de Variáveis */
float anos;
printf("Entre com o numero de dias: "); /* Entrada de Dados */
scanf("%d", &dias);
anos = dias/365.25; /* Conversão dias->anos */
printf("\n\n%d dias equivalem a %f anos.\n", dias, anos);
system ("pause");
return(0);
}
Vamos entender como o programa acima funciona. São declaradas duas variáveis
chamadas dias e anos. A primeira é tipo int (inteiro) e a segunda um float (ponto
flutuante). As variáveis declaradas como ponto flutuante existem para armazenar
números que possuem casas decimais, como 5,1497.
É feita então uma chamada à função printf(), que coloca uma mensagem na tela.
Queremos agora ler um dado que será fornecido pelo usuário e colocá-lo na variável
inteira dias. Para tanto usamos a função scanf(). A string “%d” diz à função que iremos
ler um inteiro. O segundo parâmetro passado à função diz que o dado lido deverá ser
armazenado na variável dias.
É importante ressaltar a necessidade de se colocar um & antes do nome da variável a ser

lida quando se usa a função scanf(). O motivo disto só ficará claro mais tarde. Observe
que, no C, quando temos mais de um parâmetro para uma função, eles serão separados
por vírgula.
Temos então uma expressão matemática simples que atribui a anos o valor de dias
dividido por 365.25 (365.25 é uma constante ponto flutuante 365,25). Como anos é uma
variável float o compilador fará uma conversão automática entre os tipos das variáveis
(veremos isto com detalhes mais tarde).
A segunda chamada à função printf() tem três argumentos. A string “\n\n%d dias
equivalem a %f anos.\n” diz à função para pular duas linhas, colocar um inteiro na tela,

colocar a mensagem “dias equivalem a”, colocar um valor float na tela, colocar a
mensagem “ anos.” e pular outra linha. Os outros parâmetros são as variáveis, dias e
anos, das quais devem ser lidos os valores do int e do float, respectivamente.

CAPITULO 4: MEMÓRIA E VARIÁVEIS

A memória principal do computador ou memória RAM é constituída por componentes
electrônicos capazes de armazenar dados. Cada dígito binário (0 ou 1) ocupa uma
porção de memória chamada de bit, e um conjunto de 8 bits é denominado de byte. A
memória é dividida em células de memória de um byte de tamanho, que podem ser
acessadas a partir de um número único que as identifica de forma particular. Esse
número é chamado de endereço e tem a mesma função que os endereços de nossas
casas, que é identificar de forma univoca nossas residências, afim de possibilitar o envio
e o recebimento de correspondências. No caso do computador, as correspondências são
os dados que serão armazenados nas células de memória.
Figura 7: Memória RAM
Uma variável em programação representa, através de símbolos, o conteúdo de uma

célula ou posição de memória. Por exemplo, se uma variável de nome x possuio valor
10, significa dizer que a posição de memória, representada pelo símbolo x, armazena o
valor 10. Em programação, podemos enxergar a memória como um conjunto de
posições que possuem um endereço e uma representação simbólica (variável), como
ilustra a figura abaixo.
Figura 8:Representação da memória em função dos endereços, das posições de memória e das variáveis.
4.1. Identificadores
Os nomes que damos às variáveis, rotinas, constantes e demais componentes num

programa escrito numadadalinguagemdeprogramaçãosãochamadosdeidentificadores. No
ponto anterior, por exemplo, utilizamos os identificadores x, y, z e var para dar nome às
variáveis da figura 4.

4.1.1. As regras básicas para formação de identificadores são:
 Os caracteres utilizadossão os números, letras maiúsculas, minúsculas e o

caractere especial sublinha ( _ );
 O primeiro caractere deve ser uma letra ou o sublinha;
 Não são permitidos espaços em branco;
 Palavras reservadas não podem ser utilizadas como identificadores.
Abaixo, alguns exemplos de identificadores válidos:
B
b
X2
declaracao
DECLARACAO
prova1
prova_2
BI
passaporte
Identificadores inválidos:
4L - Não pode começar com número.
X 2 - Não pode conter espaço em branco.
Declaraçao - Não é permitido utilizar o caractere cedilha.
DECLARAÇÃO - Caracteres especiais como o til (~) não são permitidos.
for - for é uma palavra reservada. function - function também é uma palavra reservada.
Uma boa prática de programação é escolher nomes que indiquem a função de uma
variável, como por exemplo: soma, ano, idade, media, dataNascimento, numero_filhos,
prova1, media, prova2, provaFinal, salario, produto,etc. Também é uma prática bastante
difundida iniciar os identificadores com letras minúsculas e usar letras maiúsculas ou
sublinha para separar palavras. Por exemplo, para escolher um identificador para uma
variável que deve armazenar a data de nascimento de uma pessoa, as duas opções
citadas correspondem à dataNascimento e data_nascimento, respectivamente.
4.2. OS Tipos básicos de dados
O tipo de dado associado a uma variável é o conjunto dos valores que podem ser nela
armazenados. A linguagem C dispõe dos tipos de dados descritos abaixo.

O C possui cinco tipos básicos de dados: char, int, float, double e void. Abaixo,
comentamos cada um deles:
 char: Tipo caractere. Strings, por exemplo, são formadas por uma sequência de
caracteres. Os caracteres são na verdade valores numéricos inteiros, cuja
correspondência entre o valor numérico e o caractere é dada pela tabela ASCII.
 int: Tipo inteiro. Acomoda uma ampla e mais comum faixa de valores inteiros
usados normalmente em programação.
 float e double: Tipos ponto flutuante. Ambos os tipos são usados ao
especificarmos valores com parte inteira e parte decimal. A diferença entre os
dois está na precisão e na faixa de valores que representam, sendo o tipo double
o mais preciso e amplo, consumindo, porém, mais memória (o dobro do float).
 void: Tipo vazio, ou “tipo sem tipo”. A aplicação deste “tipo” é importante,
porém só será vista posteriormente.
Para cada um dos tipos de variáveis existem os modificadores de tipo. Os modificadores

de tipo do C são quatro: signed, unsigned, long e short. Ao float não se pode aplicar
nenhum e ao double pode-se aplicar apenas o long.
Os quatro modificadores podem ser aplicados a inteiros. A intenção é que short e long
devam prover tamanhos diferentes de inteiros onde isto for prático. Inteiros menores
(short) ou maiores (long). int normalmente terá o tamanho natural para uma
determinada máquina. Assim, numa máquina de 16 bits, int provavelmente terá 16 bits.
Numa máquina de 32, int deverá ter 32 bits. Na verdade, cada compilador é livre para
escolher tamanhos adequados para o seu próprio hardware, com a única restrição de que
short int e int devem ocupar pelo menos 16 bits, long int pelo menos 32 bits, e short int
não pode ser maior que int, que não pode ser maior que long int.
O modificador unsigned serve para especificar variáveis sem sinal. Um unsigned int
será um inteiro que assumirá apenas valores positivos (dobrando, assim, a faixa máxima
admissível ao tipo int). A seguir estão listados os tipos de dados permitidos e seu
valores máximos e mínimos em um compilador típico para um hardware de 16 bits.
Também nesta tabela está especificado o formato que deve ser utilizado para ler os tipos
de dados com a função scanf().
Tabela 3:Tipos básicos definidos no padrão ANSI
Formato para Intervalo

Tipo Num de bits leitura com
Início Fim
scanf
char 8 %c -128 127
unsigned char 8 %c 0 255
signed char 8 %c -128 127
Int 16 %d ou %i -32.768 32.767
unsigned int 16 %u 0 65.535
signed int 16 %i -32.768 32.767

short int 16 %hi -32.768 32.767

unsigned short int 16 %hu 0 65.535
signed short int 16 %hi -32.768 32.767
long int 32 %li -2.147.483.648 2.147.483.647
signed long int 32 %li -2.147.483.648 2.147.483.647
unsigned long int 32 %lu 0 4.294.967.295
float 32 %f ±3,4E-38 ±3.4E+38
double 64 %lf ±1,7E-308 ±1,7E+308
long double 80 %Lf ±3,4E-4932 ±3,4E+4932
Conforme comentado, a tabela acima não é uma “verdade absoluta”. O tamanho

(consequentemente a faixa de valores associada) pode variar dependendo do
compilador/hardware/sistema operacional adotado. Tome como referência, por
exemplo, o código abaixo e sua respectiva saída, ao ser compilado pelo Microsoft
Visual C++ 2008 e executado sobre o Windows XP 32bits e Windows 10.
#include <stdio.h>
main()
{
printf("Tipos de Dados e seus Tamanhos\n\n");
printf("char: %d bits\n", sizeof(char)*8);
printf("unsigned char: %d bits\n", sizeof(unsigned char)*8);
printf("signed char: %d bits\n", sizeof(signed char)*8);
printf("int: %d bits\n", sizeof(int)*8);
printf("unsigned int: %d bits\n", sizeof(unsigned int)*8);
printf("signed int: %d bits\n", sizeof(signed int)*8);
printf("short int: %d bits\n", sizeof(short int)*8);
printf("unsigned short int: %d bits\n", sizeof(unsigned short int)*8);
printf("signed short int: %d bits\n", sizeof(signed short int)*8);
printf("long int: %d bits\n", sizeof(long int)*8);
printf("signed long int: %d bits\n", sizeof(signed long int)*8);
printf("unsigned long int: %d bits\n", sizeof(unsigned long int)*8);
printf("float: %d bits\n", sizeof(float)*8);
printf("double: %d bits\n", sizeof(double)*8);
printf("long double: %d bits\n", sizeof(long double)*8);
printf("\n\n");
}

Resultado da execução sobre o Resultado da execução sobre o

Windows XP 32 bits Windows 10 64 bits
Tipos de Dados e seus Tamanhos Tipos de Dados e seus Tamanhos
char: 8 bits char: 8 bits

unsigned char: 8 bits unsigned char: 8 bits
signed char: 8 bits signed char: 8 bits
int: 32 bits int: 32 bits
unsigned int: 32 bits unsigned int: 32 bits
signed int: 32 bits signed int: 32 bits
short int: 16 bits short int: 16 bits
unsigned short int: 16 bits unsigned short int: 16 bits
signed short int: 16 bits signed short int: 16 bits
long int: 32 bits long int: 32 bits
signed long int: 32 bits signed long int: 32 bits
unsigned long int: 32 bits unsigned long int: 32 bits
float: 32 bits float: 32 bits
double: 64 bits double: 64 bits
long double: 64 bits long double: 96 bits
4.3. Variáveis
Variáveis são endereços de memória de trabalho que guardam, temporariamente, um

valor utilizado pelo programa. 1Ou seja, Uma variável é uma posição nomeada de
memória, que é usada para guardar um valor que pode ser modificado pelo programa.
4.3.1. Declaração de variáveis
Cada variável utilizada na elaboração de um programa precisa ser definida com

antecedência. Para isso, o programador precisa definir o identificador da variável e o seu
tipo por meio do que chamamos de declaração de variáveis.
A forma geral de uma declaração é a seguinte:
tipo_da_variável identificador;
Exemplo abaixo declara em C, as variáveis a e b do tipo inteiro (int).
int a, b;
ou ainda
tipo lista_de_variáveis;
1
S. Renato. Algoritmos e programação em linguagem C. 1ª edição, 2013, p. 33

Aqui, tipo deve ser um tipo de dado válido em C mais quaisquer modificadores; e
lista_de_variáveis pode consistir em um ou mais nomes de identificadores (“nomes” das
variáveis) separados por vírgulas. Aqui estão algumas declarações:
int x, y, z;
short int si;
unsigned int ui;
double balance, profit;
int dia, mes, ano;
float altura;
float prova, exame, media;
Lembre-se de que, em C, o nome de uma variável não tem nenhuma relação com seu
tipo. Visto que, a princípio, todos os algoritmos que escreveremos em C estarão restritos
a criação de uma única função (main), lembre-se de declarar todas as variáveis
necessárias no começo da função main, antes de escrever qualquer outro comando. Há
outros lugares possíveis de declarar variáveis, e isto está intimamente relacionado a um
conceito importante que será visto adiante, onde trataremos de modularização e escopo
de variáveis.
Podemos inicializar variáveis no momento de sua declaração. Para fazer isto podemos
usar a forma geral seguinte:
tipo_da_variável nome_da_variável = constante;

Exemplos:
char ch = 'D';
int count = 0;
float pi = 3.141;
Isto é importante, pois quando o C cria uma variável ele não a inicializa. Isto significa
que até que um primeiro valor seja atribuído à nova variável ela tem um valor
indefinido e que não pode ser utilizado para nada. Nunca presuma que uma variável
declarada vale zero ou qualquer outro valor.
Um programa elaborado com base no paradigma estruturado pode ser visto como uma
sequência de transições de estado do início até o fim de sua execução. Se pudéssemos
tirar uma "foto"da execução de um programa em determinado momento, o que
observaríamos seria o conjunto de suas variáveis e os valores nelas armazenados no
momento, isto é, o estado do programa. Se os programas podem
mudardeestado,entãodeveexistirumcomandonaslinguagensdeprogramaçãoquepermitama

lterar o conteúdo de uma variável. Tal comando é denominado de atribuição, e o

exemplo a seguir ilustra como ele é utilizado em pseudocódigo:
Prova1 ← 17
pi ← 3.14
Essas instruções devem ser lidas como"a variável Prova1 recebe o valor 17 (dezassete)"
e a variável pi recebe 3.14. Em C, os comandos correspondentes são:
Prova1 = 17; pi = 3.14;
Importante:
 É sempre recomendável que se inicialize uma variável com um valor adequado

para evitarmos erros de tempo de execução, pois essa variável pode reter valores
anteriores que gerarão surpresas desagradáveis durante a execução do
programa;
 A vírgula em linguagem C é ponto, e vice-versa.
 Quando não se declara o tipo da variável, o compilador assume o tipo int.
4.4. Constantes
O que caracteriza uma constante (e daí sua denominação, emprestada da matemática) é

o facto de que o conteúdo de uma constante não pode ser modificado durante a
execução do programa. Em C podem ser de qualquer um dos cinco tipos de dados
básicos. A maneira como cada constante é representada depende do seu tipo.
Exemplos:
1) const float NumAvogadro = 6.023E+23;

2) const float g = 9.8;
Na maioria dos programas que escreverás, os padrões do compilador são adequados.

Porém, você pode especificar precisamente o tipo da constante numérica que deseja por
meio da utilização de um sufixo. Para tipos em ponto flutuante, se você colocar um F
após o número, ele será tratado como float. Se você colocar um L, ele se tornará um
long double. Para tipos inteiros, o sufixo U representa unsigned e o L representa long.
Aqui estão alguns exemplos:
Tabela 4: Alguns exemplos de constantes
Tipo de dado Exemplos de constantes

Int 1 123 21000 -234
long int 35000L -34L
short int 10 -12 90
unsigned int 10000U 987U 40000
Float 123.23F 4.34e-3F
Double 123.23 12312333 -0.9876324
long double 1001.2L

4.4.1. Constantes string
A linguagem C suporta outro tipo de constante: a string. Uma string é um conjunto de

caracteres colocado entre aspas duplas. Por exemplo, "Universidade Kimpa Vita" é uma
string. Você viu exemplos de strings em alguns dos comandos printf() dos programas de
exemplo. Embora C permita que definas constantes string, ela não possui formalmente
um tipo de dado string. Veremos mais adiante como são implementadas as variáveis do
tipo string em C.
Não se deve confundir strings com caracteres. Uma constante de um único caractere e
colocada entre aspas simples, como em ‘z’. Contudo, “z” é uma string contendo apenas
uma letra.
4.4.2. Impressões de códigos especiais
Colocar entre aspas simples todas as constantes tipo caractere funciona para a maioria
dos caracteres imprimíveis. Uns poucos, porém, como o retorno de carro (CR), são
impossíveis de inserir pelo teclado. Por essa razão, C criou as constantes especiais de
caractere de barra invertida. C suporta diversos códigos de barra invertida (listados na
tabela abaixo) de forma que lhe pode facilmente entrar esses caracteres especiais como
constantes. Você deve usar os códigos de barra invertida em lugar de seus ASCII
equivalentes para aumentar a portabilidade.
Tabela 5: Caractere de barra invertida
Código Significado
\b Retrocesso (backspace (BS))
\f Alimentação de formulário (form feed (FF))
\n Newline (Nova linha (LF))
\r Retorno de carro (carriage return (CR))
\t Tabulação horizontal (HT)
\” Aspas duplas
\’ Aspas simples
\0 Nulo
\\ Barra invertida
\v Tabulação vertical
\a Alerta (beep) ou ASCII beep
\? Interrogação
\xnn Caractere ASCII em hexadecimal (nn)
Constantes simbólicas podem ser utilizadas para tornar valores fixos mais entendíveis e
fáceis de se lembrar:
#define PI 3.14159

#define EU “Luzizila”
#define FALSE 0
Por exemplo, o programa seguinte envia a tela um caractere de nova linha e uma
tabulação e, em seguida, escreve a string Meu primeiro teste.
#include <stdio.h>
main()
printf("\n\tMeu primeiro teste\n");
system ("pause");
return 0;
Figura 9: Resultado do programa

CAPITULO 5: MATEMÁTICA BÁSICA (OPERADORES)

A linguagem C é muito rica em operadores internos. (Na realidade, C dá mais ênfase
aos operadores que a maioria das outras linguagens de computador.) C define quatro
classes de operadores: aritméticos, relacionais, lógicos e bit a bit. Alem disso, C tem
alguns operadores especiais para tarefas particulares.
5.1. Operadores Aritméticos
São as já conhecidas operações que realizamos no dia a dia. Mostramos, a seguir, a

notação sintáctica da linguagem C para cada uma delas:
Tabela 6:Operadore aritméticos
Operador Tipo Acção/Operação

+ Binário Adição
- Binário Subtração (Inversão do sinal)
* Binário Multiplicação
/ Binário Divisão
% Binário Módulo (Resto da divisão)
++ Unário Incremento
-- Unário Decremento
(𝑥+𝑦)−(𝑎+𝑏)
Tomando como base a expressão matemática 2
, em C se tornaria
((x+y)-(a+b))/2
Veja alguns exemplos de como os operadores aritméticos devem ser usados em C (os
resultados são apresentados ao lado de cada operação):
1) x = 4 * 5; // 20
2) x = x / 2; // 10
3) y = x % 4; // 2
4) z = x * y - 5; // 15
5) z = x * (y - 5); // -30
6) z = ((2 + 3) * 4 - 2)/2; // 9
A precedência dos operadores aritméticos, isto é, a ordem em que eles são avaliados,
pode ser alterada do mesmo modo que o fazemos quando tralhamos com expressões na
matemática: utilizamos os parênteses para que algumas operações sejam realizadas
antes que outras. É o que ocorre na expressão acima na expressão z=x*(y-5). Caso os
parênteses fossem omitidos2, a primeira operação a ser realizada seria a que multiplica x
2
Expressão resultante: z=x*y-5

por y, depois, do seu resultado seria subtraído cinco. Com a inserção dos parênteses,
ocorre primeiro a subtração para depois ser realizada a multiplicação.
A linguagem C possui ainda operadores especiais que resultam da combinação de

operadores aritméticos com operadores de atribuição. São eles:
Tabela 7: Operadores aritméticos de atribuição e operadores de incremento.
Operador Operação equivalente

x-- x=x–1
--x x=x–1
x++ x=x+1
++x x=x+1
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
5.2. Operadores Relacionais e Lógicos
5.2.1. Operadores Relacionais
No termo operador relacional, relacional refere-se às relações que os valores podem ter
uns com os outros.
Na tabela abaixo são listados os operadores relacionais.

Tabela 8:Operadores relacionais
Operador Acção
> Maior que
>= Maior ou igual
< Menor que
<= Menor ou igual
== Igual
!= Diferente
5.2.2. Operadores Lógicos
No termo operador lógico, lógico refere-se às maneiras como essas relações podem ser
conectadas. Uma vez que os operadores lógicos e relacionais frequentemente trabalham
juntos, eles serão discutidos aqui em conjunto.
Na tabela abaixo são listados os operadores lógicos:

Tabela 9:Operadores lógicos
Operador Acção
! NOT (Negação)
&& AND (E) - conjunção
|| OR (OU) - dijunção
Tabela 10:Operador unário !
R1 !R1
1 0
0 1
Nota:
Importa salientar que a ideia de verdadeiro e falso é a base dos conceitos dos operadores
lógicos e relacionais. Em C, verdadeiro é qualquer valor diferente de zero. Falso é zero.
As expressões que usam operadores relacionais ou lógicos devolvem zero para falso e 1
para verdadeiro.
A tabela avaliação de expressões lógicas ou tabela verdade dos operadores lógicos é

mostrada a seguir, usando 1’s e 0’s.
Tabela 11: Avaliação de expressões lógicas
R1 R2 (R1)&&(R2) (R1)||(R2) (R1)^(R2)

1 1 1 1 0
1 0 0 1 1
0 1 0 1 1
0 0 0 0 0
Ambos os operadores são menores em precedência do que os operadores aritméticos.

Isto é, uma expressão como 10 > 1 + 12 é avaliada como se fosse escrita 10 > (1+12). O
resultado é, obviamente, falso. É permitido combinar diversas operações em uma
expressão como mostrado aqui:
10 > 5 && !(10 < 9) || 3 <= 4
Neste caso, o resultado é verdadeiro.

5.3. Operador de Atribuição
Em C, você pode usar o operador de atribuição dentro de qualquer expressão válida de

C. Isso não acontece na maioria das linguagens de computador (incluindo Pascal,
BASIC e FORTRAN), que tratam os operadores de atribuição como um caso especial
de comando. A forma geral do operador de atribuição é
nome_da_variavel = expressão;
onde expressão pode ser tão simples como uma única constante ou tão complexa quanto
você necessite. Como BASIC e FORTRAN, C usa um único sinal de igual para indicar
atribuição (ao contrario de Pascal e Modula-2, que usam a construção :=). O destino, ou
a parte esquerda, da atribuição deve ser uma variável ou um ponteiro (a ser visto
futuramente), não se trata de uma função ou uma constante.
5.3.1. Atribuições Múltiplas
A linguagem C permite que você atribua o mesmo valor a muitas variáveis usando
atribuições múltiplas em um único comando. Por exemplo, esse fragmento de programa
atribui a x, y e z o valor 0:
x = y = z = 0;
Isto se dá porque o comando de atribuição é tratado como um operador, que atribui o

valor da direita à variável à esquerda e retorna (ou seja, tem como “resultado”) o valor
atribuído. Este valor retornado pode então ser atribuído a outra possível variável à
esquerda. Em programas profissionais, valores comuns são atribuídos a variáveis
usando esse método.
5.4. Outros Operadores
C possui ainda outros operadores que serão apenas citados aqui, cabendo explicações
mais detalhadas em capítulos seguintes, uma vez que podem envolver conceitos de
programação mais avançados.
5.4.1. Operadores Bit a Bit
Uma vez que C foi projetada para substituir a linguagem assembly na maioria das
tarefas de programação, era importante que ela tivesse a habilidade de suportar muitas
das operações que podem ser feitas em linguagem assembly. Operação bit a bit refere-se
a testar, atribuir ou deslocar os bits efetivos em um byte ou uma palavra, que
correspondem aos tipos de dados char e int e variantes do padrão C. Operações bit não
podem ser usadas em float, double, long double, void ou outros tipos mais complexos.
A tabela abaixo lista os operadores que se aplicam as operações bit a bit. Essas
operações são aplicadas aos bits individuais dos operandos.

Tabela 12: Outros operadores
Operador Acção
|| OR
&& AND
^ OR exclusivo (XOR)
~ Complemento de um
>> Deslocamento à direita
<< Deslocamento à esquerda
5.4.2. O Operador ?
C contém um operador muito poderoso e conveniente que substitui certas sentenças da

forma if-thenelse. O operador ternário ? tem a forma geral seguinte:
Expl ? Exp2 : Exp3;

onde Exp1, Exp2 e Exp3 são expressões. Note o use e o posicionamento dos dois-
pontos.
O operador ? funciona desta forma: Exp1 é avaliada. Se ela for verdadeira, então Exp2 é
avaliada e se torna o valor da expressão. Se Exp1 é falsa, então Exp3 é avaliada e se
torna o valor da expressão. Por exemplo, em
a = 10;
b = a > 9 ? 100 : 200;
a b é atribuído o valor 100. Se a fosse menor que 9, b teria recebido o valor 200. O
mesmo código, usando o comando if-else, é
a = 10;
if (a > 9) b = 100;
else b = 200;
5.5. Expressões
Operadores, constantes e variáveis são os elementos que constituem as expressões. Uma

expressão em C é qualquer combinação válida desses elementos. Uma vez que a maioria
das expressões tende a seguir as regras gerais da álgebra, elas são frequentemente
tomadas como certas. Contudo, existem uns poucos aspectos de expressões que se
referem especificamente a C.
Exemplos de expressões:
anos = dias/365.25;
i = i+3;

c= a*b + d/e;
c= a*(b+d)/e;
5.6. Modeladores (CASTS)
Um modelador é aplicado a uma expressão. Ele força a mesma a ser de um tipo

especificado. Sua forma geral é:
(tipo) expressão
Exemplo:
#include <stdio.h>
main()
int num;
float f1, f2;
num = 5;
f1 = num/2;
f2 = (float)num/2; /* Uso do cast. Força a transformação de num em float */
printf("f1 = %f (Resultado sem cast)\n", f1);
printf("f2 = %f (Resultado com cast)\n\n", f2);
system ("pause");
return 0;
Figura 10: Programa com e sem cast

Não utilizando o cast, o C considera a expressão f1=num/2; como uma divisão inteira,
já que ambos os operandos são inteiros. Usando o cast, na expressão f2=(float)num/2; a
variável num é convertida para o tipo float, de modo que o operador de divisão passa a
tratar a expressão como uma divisão usando ponto flutuante (resultando no valor
correcto).

CAPITULO 6: FUNÇÕES DE ENTRADA E SAÍDA DE

DADOS
Imagine que desenvolveu um programa para controlar suas finanças pessoais e com ele
intenciona conter seus gastos e ainda guardar uma parte do que ganha na poupança.
Esse programa necessita de interacção? Como informarás suas receitas e despesas?
Como ele apresentará o resultado dos seus cálculos com a finalidade de auxiliá-lo no
controle de suas finanças?
As respostas de todas essas perguntas convergem para a seguinte conclusão: um

programa de computador é praticamente inútil se não apresentar algum tipo de
interacção com o usuário. No cenário anterior, por exemplo, nós precisamos informar ao
programa quais são as suas receitas e despesas. Além disso, é necessário que ele o deixe
a par dos resultados dos seus cálculos, caso contrário ele não terá serventia alguma.
Os mecanismos que as linguagens de programação oferecem para interacção com o

usuário estão presentes em suas bibliotecas de entrada e saída. Em C, as funções
responsáveis pelas operações básicas de entrada e saída se encontram na biblioteca
stdio, que é utilizada por meio da directiva:
#include <stdio.h>
Vimos anteriormente uma forma de exibir na tela uma sequência de caracteres através
da função printf(), que, além de imprimir caracteres, também é capaz de exibir o
conteúdo de variáveis de diversos tipos.
6.1. Função de saída
A função printf( ) é a mais conhecida e usada função de saída-padrão de dados

formatados, que normalmente é a tela do computador. Ela tem a seguinte forma geral:
printf(string_de_controle, lista_de_argumentos);
Teremos, na string de controle, uma descrição de tudo que a função vai colocar na tela.
A string de controle mostra não apenas os caracteres que devem ser colocados na tela,
mas também quais as variáveis e suas respectivas posições. Isto é feito usando-se os
códigos de controle, que usam a notação %. Na string de controle indicamos quais, de
qual tipo e em que posição estão as variáveis a serem apresentadas. É muito importante
que, para cada código de controle, tenhamos um argumento na lista de argumentos.
Apresentamos agora alguns dos códigos %:

Tabela 13: Especificadores de formatos mais utilizados na função printf()
Código Significado
%i ou %d Inteiro (int) decimal
%f Real (ponto flutuante)
%o Inteiro octal
%c Caractere em formato ASCII
%s String de caracteres
%p Valor ponteiro
Vamos ver alguns exemplos de printf() e o que eles exibem:
#include<stdio.h>
int main()
printf("Teste %% %% \n");
printf("%f \n", 40.345);
printf("Um caractere %c eh um inteiro %d \n", 'D', 120);
printf("%s eh um exemplo \n", "Este");
printf("%s%d%% \n", "Juros de ", 10);
printf("\n\n");
system("pause");
return 0;
Saída na tela após a execução do código acima:
Temos, ainda a possibilidade de utilizar os especificadores de comprimento e precisão,

de forma a dizer ao programa quantas casas decimais serão utilizadas na saída.

Exemplo: printf(“%6.2f”, 285978.0025) mostrará 285978.00.
6.2. Função de entrada
A função scanf() é praticamente “casada” com a função printf(), diferindo desta por ser
uma função de entrada de texto. O formato geral da função scanf() é
scanf (string_de_controle,lista_de_argumentos);
Usando a função scanf() podemos pedir dados ao usuário. Por exemplos:
1) #include<stdio.h>
int main()
char ch;
scanf("%c", &ch);
printf("Voce pressionou a tecla %c \n\n", ch);
system("pause");
return 0;
}
2) #include<stdio.h>
int main()
{
int idade; float altura;
printf("Informe sua idade: ");
scanf("%d", &idade);
printf("Informe sua altura: "); scanf("%f", &altura);
printf("\nVoce tem %d anos e %.2f de altura.", idade, altura);
system("pause");
return 0;
}
Ao contrário do exemplo da seção anterior, os dados a serem exibidos não estão pré-
determinados, isto é, as variáveis não possuem valores a priori. As atribuições apenas
ocorrem quando o usuário entra com valores via teclado. No exemplo, depois que a
sequência de caracteres "Informe sua idade: " é exibida, a execução do programa é
interrompida até que o usuário digite um valor. Quando isso ocorre, ele é armazenado
no endereço da variável idade, obtido quando ela é precedida pelo caractere &. Por

conseguinte, o printf() ao final do código irá exibir os dados informados pelo usuário e
não os dados pré-determinados pelo programador.
Mais uma vez, devemos ficar atentos a fim de colocar o mesmo número de argumentos
que o de códigos de controle na string de controle. Outra coisa importante é
lembrarmos-nos de colocar o & antes das variáveis da lista de argumentos. É impossível
justificar isto agora, mas veremos depois a razão para este procedimento futuramente,
quando estivermos a falar de ponteiros.
Em algumas situações o iniciante em programação em C frustra-se com o

comportamento da função scanf(). Quando o scanf é usado para capturar um caracter
sendo que anteriormente a este tenha havido uma entrada de dados qualquer (e
consequentemente um ENTER), este segundo scanf pode “pular”. Este, na verdade, foi
executado. No entanto, como estava programado para capturar um caractere, acabou por
capturar o caracter ‘\n’ do ENTER da entrada de dados anterior, que ficou no buffer de
teclado (uma região de memória temporária).
A função scanf() também pode ler numa mesma linha diversos dados, armazenando-os
em diferentes variáveis. As leituras do código anterior, por exemplo, podem ser
reescritas da seguinte forma:
printf("Informe sua idade e sua altura:");
scanf("%d %.2f", &idade);
Para que esse código funcione como desejado, o usuário precisa digitar um número
inteiro seguido de um espaço e depois um número de ponto-flutuante. O espaço é
requerido por que ele é utilizado na especificação do formato (entre o %d e o %.2f há
um espaço). Assim como printf(), a função scanf() também possui uma lista de
especificadores de formato. Os mais utilizados são:
Tabela 14: Especificadores de formatos mais utilizados da função scanf()
Código Significado
%i ou %d Leitura de um inteiro (int) decimal
%f Leitura de um número de ponto-flutuante
%u Leitura de um inteiro sem sinal
%c Leitura de um único caractere
%s Leitura de uma String de caracteres
1. Diferencie linguagem de programação de alto nível de linguagem de

programação de baixo nível. Dê exemplos de linguagens que se enquadram em
ambos os tipos.

2. Qual é o principal objectivo dos tradutores e interpretadores?

3. Defina montador e compilador, enfatizando suas diferenças.
4. Explique como funcionam os interpretadores.
5. Quais as vantagens da compilação em relação à interpretação?
6. O que é um paradigma de programação? Cite exemplos.
7. Quais dos seguintes itens não podem ser utilizados como identificadores na
linguagem C? Explique por quê?
a. 3x
b. Inflação
c. COMPUTACAO
d. exame_1
e. prova 2
f. prof.
g. $6
h. BI
i. main
j. return
8. Descreva os tipos primitivos de C, destacando os valores que eles podem
armazenar.
9. Qual é a diferença entre os operadores prefixo e sufixo de incremento?
10. Qual é valor de (A1 + A2) após a execução dos grupos de comandos abaixo:
a. y = 6;
b. z = 8;
c. c = 2;
d. A1 = ((y * z) - z)/c;
e. A2 = (z / 2)/ y++;
11. Considerando as atribuições x = 20 e y = 2, calcule o resultado de cada uma das

expressões abaixo:
a. (x-- + x * (x % y))
b. (x-- + x * (x % y))
c. (x-- + x * (x % 3))
d. (--x + x * (x % 3))
e. (--x + x * (x % x))
12. Faça um programa em C que solicite ao usuário que digite o ano de seu
nascimento, armazene o valor digitado em uma variável e em seguida imprima
na saída padrão a sua idade.
13. Escreva um programa que receba um valor em metros e o converte para
milímetros.
14. Escreva um programa que imprima na tela a tabuada do número 5.
15. Desenhe uma árvore de Natal usando “*”, em um programa em C.

CAPITULO 7: COMANDOS DE CONTROLE OU

ESTRUTURAS DE CONTROLE DO
PROGRAMA
7.1. Introdução
As estruturas de controle de fluxo são fundamentais para qualquer linguagem de

programação. Sem elas só haveria uma maneira do programa ser executado: de cima
para baixo comando por comando. Não haveria condições, repetições ou saltos. A
linguagem C possui diversos comandos de controle de fluxo. É possível resolver todos
os problemas sem utilizar todas elas, mas devemos nos lembrar de que a elegância e
facilidade de entendimento de um programa dependem do uso correto das estruturas no
local certo.
7.2. Estrutura Sequencial
Um algoritmo que possui uma estrutura sequencial significa que suas instruções são
executadas na sequência em que elas aparecem, sem nenhuma alteração no seu fluxo, a
não ser, claro, que exista alguma instrução explícita para a mudança deste fluxo.
Vejamos o código em C na figura abaixo:
Figura 11:Estrutura sequencial na linguagem C
Este algoritmo irá ler dois valores e guardá-los, respectivamente, nas variáveis x e y.
Após isso, a variável inteira soma receberá a soma dos valores de x e y. Em seguida,
será mostrada na saída padrão, o resultado desta soma. Perceba que os passos do
algoritmo são executados de cima para baixo.
Entretanto, em alguns momentos os problemas que queremos resolver requerem a

alteração no fluxo normal de execução do algoritmo. Na próxima secção, iremos
aprender como executar um conjunto de instruções de acordo com uma determinada
condição.

7.3. Verdadeiro e Falso em C
Muitos comandos em C contam com um teste condicional que determina o curso da

acção. Uma expressão condicional chega a um valor verdadeiro ou falso. Em C, ao
contrário de muitas outras linguagens, um valor verdadeiro é qualquer valor diferente de
zero, incluindo números negativos. Um valor falso é 0. Esse método para verdadeiro e
falso permite que uma ampla gama de rotinas sejam codificadas de forma extremamente
eficiente.
Portanto, lembre-se sempre:
 Falso = 0 (zero).
 Verdadeiro = Qualquer valor diferente de zero. Frequentemente, por
simplificação, adota-se o valor 1.
7.4. Comandos de Selecção ou decisão
A linguagem C suporta dois tipos de comandos de selecção: if e switch. Há situações

em que ambos os comandos podem ser usados. Contudo, há diversas situações em que o
uso do comando switch facilita o entendimento e a clareza do código. Cabe, portanto,
perspicácia no uso de cada comando.
7.4.1. Decisão simples (if)
O comando condicional if é um dos elementos mais usados da linguagem. Sua forma

geral é:
if (condição) declaração;
A expressão, na condição, será avaliada. Se o resultado dela for zero, a declaração não
será executada. Se a condição for diferente de zero a declaração será executada. Aqui
reapresentamos o exemplo de um uso do comando if:
#include<stdio.h>
int main()
{
int num;
printf("Digite um numero: ");
scanf("%d", &num);
if (num > 10)
printf("\nO numero eh maior que 10.\n\n");
if (num == 10)

{
printf("\nVoce acertou!\n");
printf("O numero eh igual a 10.\n\n");
}
if (num < 10)
printf("\nO numero eh menor que 10.\n\n");
system("pause");
return 0;
}
Vamos analisar outro exemplo a seguir. Este algoritmo lê um valor digitado pelo
usuário e armazena na variávelx. Em seguida, o comando SE verifica se o valor de x é
menor que 10. Caso seja, a instrução ESCREVA é executada, mostrando na tela a frase
"o valor de X é menor que 10".
Exemplos: 1. Algoritmo que comparava valor lido com 10.
LEIA x
SE x < 10 ENTÃO
ESCREVA "O valor de x é menor que 10."
Em outros casos, necessitamos utilizar operadores lógicos nas expressões para avaliar
mais de uma expressão relacional. Por exemplo, digamos que no problema acima
queremos verificar se o valor digitado para a variável x está dentro do intervalo entre 10
e 20. Neste caso, precisamos que a condição verifique as duas expressões relacionais: (x
> 10) e (x < 20). Portanto, precisamos conectar as duas expressões relacionais utilizando
um operador lógico E. A tabela abaixo apresenta os operadores lógicos possíveis:
Operador em C Operador em linguagem algorítmica

&& E
|| OU
! NÃO
Portanto, o algoritmo para resolver o problema acima, na linguagem C, é o seguinte:
#include<stdio.h>
int main()

int x;
scanf("%d", &x);
if (x > 10 && x < 20)
printf("x esta’ entre 10 e 20.");
system("pause");
return 0;
Perceba que agora a condição do comando ‘if` possui duas expressões relacionais
conectadas por um operador lógico E (&&). Nesse caso, se ambas as expressões forem
verdadeiras, será mostrada na saída padrão "x esta’ entre 10 e 20". Caso alguma das
expressões seja falsa, nada será mostrado, pois o resultado da expressão completa é
falso. Vejamos a tabela abaixo, denominada de tabela verdade, que mostra a relação
lógica entre duas expressões e seus respectivos resultados.
Tabela 15: Tabela de verdade
Expressão1 Operador Expressão2 Resultado

Verdadeiro E Verdadeiro Verdadeiro
Verdadeiro E Falso Falso
Falso E Falso Falso
Verdadeiro OU Verdadeiro Verdadeiro
Verdadeiro OU Falso Verdadeiro
Falso OU Falso Falso
Verdadeiro NÃO - Falso
Falso NÃO - Verdadeiro
7.4.1.1. Exercício resolvido
1- Considere quatro variáveis a, b, c e d com valores iniciais de 5, 7, 3 e 9. Dada as

condições abaixo, indique se o resultado final da expressão será verdadeiro ou falso.
a. (a != 3 || b < 10 || c == 5)
b. (d > 8 && c == 3 || a >=10)
c. !(d == 12 && a != 10)
d. (c == 4 || d <= 6) && (a >= 5 && b != 9) || (!(a < 5))
Solução:
a. Neste caso temos três expressões lógicas. A primeira (a != 3) é verdadeira. A

segunda (b < 10) é verdadeira, e a terceira (c == 5) é falsa. Como as expressões

estão conectadas por um operador OU (||), então basta que uma das expressões seja
verdadeira para o resultado da expressão completa ser verdadeira.
b. Temos neste caso três expressões. Para um melhor entendimento, vamos utilizar
uma tabela. As duas primeiras expressões (d > 8 e c == 3) são verdadeiras e estão
conectadas pelo operador lógico &&,logo R1 && R2 éverdadeiro. A terceira
expressão (a >= 10), porsua vez, é falsa. Então, resolvendo R3 || R4, temos o
resultado final como verdadeiro.
Tabela 16: Teste de expressões
Rs Expressão Resultado
R1 d>8 Verdadeiro
R2 c == 3 Verdadeiro
R3 R1 && R2 Verdadeiro
R4 a >= 10 Falso
R5 R3 || R4 Verdadeiro
c. Utilizando novamente a tabela, temos que a primeira expressão (d == 12) é falsa.

A segunda expressão (a != 10) verdadeira. A relação entre R1 && R2 é falsa, pois
apenas R2 é verdadeira. A última expressão é uma negação de R3, ou seja, se R3
é falso, então R4 é verdadeiro.
R Expressão Resultado
R1 d == 12 Falso
R2 a != 10 Verdadeiro
R3 R1 && R2 Falso
R4 !R3 Verdadeiro
d. Vamos utilizar novamente a tabela para nos auxiliar. Temos que prestar bastante
atenção nos parênteses das expressões que podem ser utilizadas para explicitar a
precedência da avaliação.
R Expressão Resultado
R1 c == 4 Falso
R2 d <= 6 Falso
R3 R1 || R2 Falso
R4 a >= 5 Verdadeiro
R5 b != 9 Verdadeiro
R6 R4 && R5 Verdadeiro
R7 a<5 Falso
R8 !R7 Verdadeiro
R9 R3 && R6 Falso
R10 R9 || R8 Verdadeiro

7.4.2. Estrutura de decisão composta
O comando if pode ser complementado com uma cláusula else, a fim de tratar os casos
onde a expressão condicional é falsa (ou seja, tem zero como resultado). Portanto, a
forma geral completa do comando if é:
if (condição)
<sequência de comandos1>
else
<sequência de comandos2>
A expressão da condição será avaliada. Se ela for diferente de zero a sequência de

comandos1 será executada. Se for zero a sequência de comandos2 será executada. É
importante nunca esquecer que, quando usamos a estrutura if-else, estamos garantindo
que uma das duas declarações será executada. Nunca serão executadas as duas ou
nenhuma delas. Abaixo está um exemplo do uso do if-else:
#include <stdio.h>
main() {
int num;
scanf("%d", &num);
if (num == 10) {
printf("\n\nVoce acertou!\n");
printf("O numero eh igual a 10.\n");
else {

printf("\n\nVoce errou!\n");
printf("O numero eh diferente de 10.\n");
É possível também encadear uma série de comandos if, dando origem a uma “escada”
do tipo ifelse-if. Sua síntaxe pode ser escrita como sendo:
if (condição_1) declaração_1;
else if (condição_2) declaração_2;
else if (condição_3) declaração_3;
.
.
.
else if (condição_n) declaração_n;
else declaração_default;
A estrutura acima funciona da seguinte maneira: o programa começa a testar as

condições começando pela 1 e continua a testar até que ele ache uma expressão cujo
resultado dê diferente de zero. Neste caso ele executa a declaração correspondente. Só
uma declaração será executada, ou seja, só será executada a declaração equivalente à
primeira condição que der diferente de zero. A última declaração (default) é a que será
executada no caso de todas as condições darem zero e é opcional. Um exemplo da
estrutura acima:
#include<stdio.h>
int main()
int num;
scanf("%d", &num);
if (num > 10)
printf("\n\nO numero eh maior que 10.");
else if (num == 10)

printf("O numero eh igual a 10.");
else if (num < 10)
printf("\n\nO numero eh menor que 10.");
system("pause");
return 0;
Quando uma sequência de comandos if encadeados (tal qual mostrada acima) está sendo
usada simplesmente para executar um ou mais comandos caso o valor de uma variável
seja igual a uma determinada constante, o uso de um comando switch pode ser
altamente recomendado, conforme veremos adiante.
7.4.3. A Expressão Condicional
Quando o compilador avalia uma condição, ele quer um valor de retorno para poder
tomar a decisão. Mas esta expressão não necessita ser uma expressão no sentido
convencional. Uma variável sozinha pode ser uma “expressão” e esta retorna o seu
próprio valor. Isto quer dizer que teremos as seguintes expressões:
int num;
if (num != 0) ...
if (num == 0) ...
equivalem a
int num;
if (num) ...
if (!num) ...
Isto quer dizer que podemos simplificar algumas expressões simples.

7.4.3.1. If's Aninhados
O if aninhado é simplesmente um if dentro da declaração de um outro if externo. O

único cuidado que devemos ter é o de saber exatamente a qual if um determinado else
está ligado. Vejamos um exemplo:
#include <stdio.h>
main()
int num;
scanf ("%d", &num);
if (num == 10)
printf("O numero eh igual a 10.\n");
else
if (num > 10)
printf("O numero eh maior que 10.");
else
printf("O numero eh menor que 10.");
7.4.4. O Operador ?
Uma expressão como:
if (a > 0)

b = -150;
else
b = 150;
pode ser simplificada usando-se o operador ? da seguinte maneira:
b = (a > 0) ? -150 : 150;
De uma maneira geral expressões do tipo:
if (condição)
expressão_1;
else
expressão_2;
podem ser substituídas por:
condição ? expressão_1 : expressão_2;
7.4.5. Comando de decisão múltipla
O comando if e o comando switch são os dois comandos de tomada de decisão.
Este tipo de estrutura condicional tem a mesma função do if-else-if, coma diferença que
o comando switch não aceita expressões, apenas constantes. A vantagem de se utilizar
este comando é a legibilidade do código quando conhecemos os possíveis valores para
uma determinada variável. Vamos ver o formato de uso do comando switch.
switch (variável)
{
case VALOR1: <Comandos>
break;
case VALOR2: <Comandos>
break;
default: <Comandos>
}
Uma variável do tipo char ou int é colocada entre parênteses após o comando switch. Os
valores desta variável que serão avaliados logo em seguida, através das declarações

case. Para cada possível valor da variável, existe uma declaração case correspondente.
Caso o valor seja aquele que corresponde na declaração case, então as instruções abaixo
dela serão executadas até encontrar o comando break. A declaração default é opcional, e
é executada apenas se a variável não for igual a nenhuma das constantes definidas nas
declarações case.
Para um melhor entendimento, vamos analisar o código semana.c abaixo. A ideia deste
programa é que o usuário digite o valor numérico correspondente ao dia da semana e o
programa mostre por extenso este dia. Uma variável chamada semana do tipo int é
declarada (linha 4) e guardará o valor que o usuário irá digitar (linha 7). Em seguida, o
comando switch foi utilizado (linha 9). Para cada dia da semana existe uma declaração
case correspondente. Isto significa que se o usuário digitou o valor 1, a instrução da
linha 11 será executada, mostrando na saída a string "Domingo". Caso o valor digitado
seja 2, a instrução da linha 14 é executada, mostrando na saída a string "Segunda-feira".
A mesma ideia acontece para os outros 5 dias da semana. Caso o valor digitado pelo
usuário não esteja entre 1 e 7, as instruções da declaração default serão executadas,
mostrando a string "Numero fora do intervalo permitido.".
Código fonte code/estruturas-de-controle/semana.c

1. Escreva um programa que diga qual é o maior de dois números distintos.
2. Escreva um programa que informe a categoria de um jogador de futebol,

considerando sua idade: infantil ( até 13 anos), juvenil ( até 17 anos) ou sénior (acima
de 17 anos).
3. Escreva um programa que receba um número inteiroo do teclado e diga se ele é par.
Dica: Um número é par se o resto da divisão dele por 2 for zero.
4. Escreva um programa que receba um número e diga se ele está no intervalo entre 100
e 200.
5. Escreva um programa que calcule as raízes da equação do 2º grau (ax2 + bx + c); os

valores de a, b e c são fornecidos pelo usuário.
7.5. Estrutura de Repetição
Entretanto, há casos em que é preciso que um bloco de comandos seja executado mais
de uma vez se uma determinada condicão for verdadeira:
enquanto condição faça
sequência de comandos;
fim enquanto
A linguagem define três comandos de loop: for, while e do-while.
7.5.1. Comando while
O comando while equivale ao comando “enquanto” utilizado no pseudo-código

apresentado até agora.
A forma geral de um comando while é:
while (condição){
}
As instruções serão executadas repetidamente enquanto a condição for verdadeira.
Assim que essa condição tornar-se falsa, o laço para. Vejamos o exemplo abaixo, escrito

na linguagem C. Programa que lê dois números inteiros a e b digitados pelo usuário e

imprime na tela todos os números inteiros entre a e b:
Tabela 17:Exemplo: comando while
Exemplo: comando while

1 #include <stdio.h>
2 #include <stdlib.h>
3 int main(){
4 int a,b;
5 printf ( “Digite o valor de a:” );
6 scanf(‘‘%d’’ ,&a) ;
7 printf (‘‘Digite o valor de b: ’’) ;
8 scanf(‘‘%d ’ ’ ,&b) ;
9 while (a < b){
10 a = a + 1;
11 printf (‘‘%d \n ’’, a) ;
12 }
13 system(‘‘pause ’’ ) ;
14 return 0;
15 }
7.5.2. Comando do-while
Ao contrário dos laços for e while, que testam a condição do lago no começo, o laço do-
while verifica a condição ao final do laço. Isso significa que um laço do-while sempre
será executado ao menos uma vez. A forma geral do laço do-while é:
do {
} while(condicao);
Embora as chaves não sejam necessárias quando apenas um comando esta presente, elas
são geralmente usadas para evitar confusão (para você, não para o compilador) com o
while. O ponto-e-vírgula final é obrigatório. O laço do-while repete até que a condição
se torne falsa. Dizemos que o comando dowhile é um loop com teste no final.
Abaixo,tem-se um exemplo de um programa que exibe um menu de opções para o

usuário e espera que ele digite uma das suas opções:

Tabela 18:Exemplo do-while
Exemplo: comando do-while

1 #include <stdio .h>
2 #include <stdlib .h>
3 int main(){
4 int i ;
5 do {
6 printf (‘‘Escolha uma opcao:\n’’);
7 printf (‘‘(1) Opcao 1\n’’);
8 printf (‘‘(2) Opcao 2\n’’);
9 printf(‘‘(3) Opcao 3\n ’’);
10 scanf(‘‘%d ’’, &i);
11 } while (( i < 1) || ( i > 3));
12 printf(‘‘Voce escolheu a Opcao %d.\n’’, i);
13 system(‘‘pause’’);
14 return 0;
15 }
7.5.3. Comando for
O comando for é muito similar ao comando while visto anteriormente. Basicamente, o

comando for é usado para repetir um comando, ou uma sequência de comandos,
diversas vezes. A forma geral de um comando for é:
for (inicialização; condição; incremento){

}
O laço for permite muitas variações. Entretanto, a inicialização é, geralmente, um
comando de atribuição que é usado para colocar um valor na variável de controle do
laço. A condição uma expressão relacional que determina quando o laço acaba. O
incremento define como a variável de controle do laço varia cada vez que o laço é
repetido. Você deve separar essas três seções principais por pontos-e-virgulas.
Por exemplo, o seguinte programa que lê dois números inteiros a e b digitados pelo
utilizador e imprime na tela todos os números inteiros entre a e b (incluindo a e b):

Tabela 19: Exemplo for
Exemplo: comando for

1 #include <stdio.h>
2 #include <stdlib.h>
3 int main(){
4 int a,b,c;
5 printf(“Digite o valor de a:’’);
6 scanf(‘‘%d ’’, &a) ;
7 printf(‘‘Digite o valor de b:’’);
8 scanf(‘‘%d ’ ’ ,&b);
9 for (c = a; c <= b; c++){
10 printf (‘‘%d \n’’, c);
11 }
13 return 0;
14 }
Tabela 20: Exemplos for versus while
7.5.3.1. O Loop Infinito
O loop infinito tem a forma geral:
for (inicialização; ;incremento){

instruções;
}

Este loop chama-se loop infinito porque será executado para sempre (não existindo a
condição, ela será sempre considerada verdadeira), a não ser que ele seja interrompido.
Para interromper um loop como este usamos o comando break. O comando break vai
quebrar o loop infinito e o programa continuará sua execução normalmente.
O exemplo abaixo ilustra esse tipo de laço:
Exemplos: laços infinitos

1 #include <stdio.h> 1 #include <stdio.h>
2 2 #include <stdlib.h>
3 int main() { 3 int main(){
4 int cont; 4 int a, b, c;
5 5 printf (‘‘Digite o valor de a: ’’);
6 for (cont = 1; ; cont++) 6 scanf(‘‘%d’’, &a);
7 printf("Laco infinito.\n"); 7 printf (‘‘Digite o valor de b: ’’);
8 8 scanf(‘‘%d ’’, &b);
9 system(“pause”); 9 //o comando for abaixo é um laço infinito
10 return 0; 10 for (c = a; ; c++){
11 } 11 printf (‘‘%d \n ’’, c);
12 }
14 return 0;
15 }
Nota: Na linguagem C, o operador “,” é um separador de comandos. Ele permite

determinar uma lista de expressões que devem ser executadas sequencialmente,
inclusive dentro do comando for.
7.5.4. Comandos de Desvio
C tem quatro comandos que realizam um desvio incondicional3: return, goto, break e
continue. Os dois primeiros serão vistos em momento apropriado, no futuro. Nesta
seção, abordaremos o break e continue. Estes dois comandos podem usados em
conjunto com qualquer dos comandos de laço. Como discutido anteriormente neste
capítulo, você também pode usar o break com switch.
7.5.4.1. break
O comando break tem dois usos. Você pode usá-lo para terminar um case em um
comando switch (abordado anteriormente na seção sobre o switch, neste capítulo). Você
também pode usá-lo para forçar uma terminação imediata de um laço (for, while ou do-
while), evitando o teste condicional normal do laço.
3
Ou seja, o programa “salta” de um ponto a outro do código sem incondicionalmente, sem que
qualquer condição seja verificada. É uma “ordem”, não estando sujeita a nenhum teste prévio.

O break faz com que a execução do programa continue na primeira linha seguinte ao
loop ou bloco que está sendo interrompido.
Observe que um break causará uma saída somente do laço mais interno. Por exemplo:
for (t=0; t<100; ++t) {
count=1;
for(;;){
printf("%d", count);
count++;
if (count==10) break;
}
O código acima imprimirá os números de 1 a 10 cem vezes na tela. Toda vez que o
break é encontrado, o controle é devolvido para o laço for externo. Outra observação é o
fato de que um break usado dentro de um comando switch somente afetará esse switch.
Ele não afeta qualquer outro loop que por ventura contenha o switch.
7.5.4.2. Continue
O comando continue trabalha de uma forma um pouco parecida com a do comando

break. Em vez de forçar a terminação, porém, continue força que ocorra a próxima
iteração do laço, pulando qualquer código intermediário. Para o laço for, continue faz
com que o teste condicional e a porção de incremento do laço sejam executados. Para os
laços while e do-while, o controle do programa passa para o teste condicional. Observe
o exemplo abaixo:
#include <stdio.h>
main() {
int i;
for (i=-10; i<=10; i++){
if (i == 0) continue;
printf("%f\n", 1.0/i);
}
}
No exemplo acima, são exibidos na tela o inverso dos números inteiros, de -10 a 10.
Contudo, como não existe o inverso de zero, ou seja, 1/0, existe um teste para saber se i

é igual a 0. Caso seja verdadeiro, o comando continue força o loop a ir para a próxima
iteração.
O programa abaixo exemplifica o uso do continue:
#include <stdio.h>
main(){
int opcao;
do {
printf("\n\n Escolha uma opcao entre 1 e 5: ");
scanf("%d", &opcao);
if ((opcao > 5)||(opcao <1)) continue;
switch (opcao){
case 1:
printf("\n --> Primeira opcao..");
break;
case 2:
printf("\n --> Segunda opcao..");
break;
case 3:
printf("\n --> Terceira opcao..");
break;
case 4:
printf("\n --> Quarta opcao..");
break;
case 5:
printf("\n --> Abandonando..");
break;
}
} while (opcao != 5);
}
7.5.4.3. Goto e Label
O comando goto é um salto condicional para um local especificado por uma palavra
chave no código. A forma geral de um comando goto é:
destino:
goto destino;
Na sintaxe acima, o comando goto (do inglês go to, literalmente “ir para”) muda o fluxo
do programa para um local previamente especificado pela expressão destino, onde
destino é uma palavra definida pelo programador.

Exemplo: goto versus for

2 #include <stdlib.h> 2 #include <stdlib.h>
3 int main(){ 3 int main(){
4 int i = 0; 4 int i;
5 inicio : 5 for ( i = 0; i < 5; i ++)
6 if ( i < 5){ 6 printf (‘‘Numero %d\n’’, i);
7 printf (‘‘Numero %d\n ’’, i ); 7
8 i ++; 8 system(‘‘pause ’’);
9 goto inicio; 9 return 0;
10 } 10 }
12 return 0;
13 }

CAPITULO 8: FUNÇÕES
8.1. Conceitos
Funções são trechos (ou blocos) de códigos que diminuem a complexidade de um

programa, ou evitam a repetição execessiva de determinada parte do aplicativo. A isso
chamamos de modularização. O conceito de modularização se aplica às linguagens
estruturadas, em que as funções são elementos fundamentais para a construção de
blocos ordenados e organizados. Em Linguagem C, main(), printf(), scanf() são funções
que apresentam, com forma geral:
<tipo_do_retorno> nome_função(lista_de_parâmetros)
{
corpo_da_função
retorno (não obrigatório)
}
8.2. Local de declaração de uma função
Com relação ao local de declaração de uma função, ela deve ser definida ou declarada
antes de ser utilizada, ou seja, antes da cláusula main().
Vejamos um exemplo. Queremos criar um programa que calcule a média final de um

aluno em uma disciplina com três provas; o programa deve pedir ao usuário que entre
com as notas das três provas, calcular a média aritmética das três notas e apresentar o
resultado. O programador que resolveu o problema decidiu imprimir um separador na
tela entre cada entrada de dados e o resultado final, desta forma, produzindo o seguinte
código:
#include <stdio.h>
void imprime_separador() {
printf("\n");
printf("=============================================\n");
printf("\n");
}
int main(){
float nota1, nota2, nota3, media;
printf("Entre a nota da primeira prova: ");

scanf("%f", &nota1);
imprime_separador();
printf("Entre a nota da segunda prova: ");


printf("Entre a nota da terceira prova: ");

media = (nota1 + nota2 + nota3) / 3.0;
printf("Media: %f\n", media);
system("pause");
return 0;
}
Pode-se também declarar uma função depois da cláusula main. Nesse caso, é preciso
declarar antes o protótipo da função:
Tipo_retornado nome_função (lista_de_ parâmetros);
O protótipo de uma função, é uma declaração de função que omite o corpo mas
especifica o seu nome, tipo de retorno e lista de parâmetros, como mostra o exemplo
abaixo:
Exemplo: função declarada depois da cláusula main.
#include <stdio.h>
#include <stdlib.h>
// protótipo da função
int Square ( int a);
int main (){
int n1, n2;
printf (‘‘Entre com um numero: ’’);
scanf(‘‘%d ’’, &n1) ;
n2 = Square(n1) ;
printf ( ‘‘O seu quadrado vale : %d\n ’’, n2) ;
system( ‘‘pause’’);
return 0;
}
int Square ( int a){

return (a∗a) ;
}
Nota: O protótipo de uma função não precisa incluir os nomes das variáveis passadas
como parâmetros. Apenas os seus tipos já são suficientes.
A inclusão de nome de cada parâmetro no protótipo de uma função é uma tarefa

opcional. Podemos declarar o seu protótipo apenas com os tipos dos parâmetros que
serão passados para a função. Os nomes dos parâmetros são importantes apenas na
implementaçãao da função. Assim, ambos os protótipos abaixo são válidos para uma
mesma função:
int Square (int a);
int Square (int );
8.3. Funcionamento de uma função
Independente de onde uma função seja declarada, seu funcionamento é basicamente o

mesmo:
 o código do programa é executado até encontrar uma chamada de função;
 o programa é então interrompido temporariamente, e o fluxo do programa passa
para a função chamada;
 se houver parâmetros na função, os valores da chamada da função são copiados
para os parâmetros no código da função;
 os comandos da função são executados;
 quando a função termina (seus comandos acabaram ou o comando return foi
encontrado), o programa volta ao ponto onde foi interrompido para continuar sua
execução normal;
 se houver um comando return, o valor dele será copiado para a variável que foi
escolhida para receber o retorno da função.
8.4. Parâmetros de uma função
Os parâmetros de uma função são o que o programador utiliza para passar a informação
de um trecho de código para dentro da função. Basicamente, os parâmetros de uma
função são uma lista de variáveis, separadas por vírgula, onde é especificado o tipo e o
nome de cada variável passada para a função.
Por exemplo, a função sqrt possui a seguinte lista de parâmetros: float sqrt(float x);
8.4.1. Declaraçã de parâmetros de uma função
Em linguagem C, a declaração dos parâmetros de uma função segue a seguinte forma

geral:
tipo_retornado nome_função (tipo nome1, tipo nome2, ... , tipo nomeN){

sequência_de_declarações_e_comandos
}

Diferente do que acontece na declaração de variáveis, onde muitas variáveis podem ser
declaradas como mesmo especificador de tipo, na declaração de parâmetros de uma
função é necessário especificar o tipo de cada variável.
1 // Declaração CORRETA de parâmetros

2 int soma(int x, int y){
3 return x + y;
4 }
5
6 // Declaração ERRADA de parâmetros
7 int soma( int x, y){
8 return x + y;
9 }
8.5. Funções sem lista de parâmetros
Dependendo da função, ela pode possuir nenhum parâmetro. Nesse caso, pode-se optar
por duas soluções:
 Deixar a lista de parâmetros vazia: void imprime ();

 Colocar void entre parênteses: void imprime (void).
Apesar das duas declarações estarem correctas, existe uma diferença entre elas. Na
primeira declaração, não é especificado nenhum parâmetro, portanto a função pode ser
chamada passando-se valores para ela. O o compilador não irá verificar se a função é
realmente chamada sem argumentos e a função não conseguirá ter acesso a esses
parâmetros. Já na segunda declaração, nenhum parâmetro é esperado. Nesse caso, o
programa acusará um erro se o programador tentar passar um valor para essa função.
O exemplo abaixo ilustra bem essa situação:
Exemplo: função sem parâmetros

Sem void Com void
2 #include<stdlib.h> 2 #include <stdlib.h>
3 3
4 void imprime (){ 4 void imprime(void){
5 printf (‘‘Teste de funcao\n 5 printf (‘‘Teste de funcao\n ’’);
’’); 6 }
6 } 7
7 8 int main (){
8 int main(){ 9 imprime ();
9 imprime (); 10 imprime(5); //ERRO
10 imprime(5); 11 imprime(5, ’a’); //ERRO
11 imprime(5, 'a’); 12
12 13 system(‘‘pause ’’);

13 system(‘‘pause’’); 14 return 0;
14 return 0; 15 }
15 }
Os parâmetros das funções também estão sujeitos ao escopo das variáveis. O escopo é o
conjunto de regras que determinam o uso e a validade de variáveis nas diversas partes
do programa.
Os exemplos abaixo ilustram bem essa situação. No primeiro exemplo temos o cálculo
do factorial realizado dentro da função main():
Exemplo 1: cálculo do fatorial dentro da Exemplo 2: cálculo do fatorial em uma função

função main() própria
2 #include <stdlib.h> 2 #include <stdlib.h>
3 3
4 int main(){ 4 int fatorial ( int n){
5 printf (‘‘ Digite um numero inteiro positivo : ’’); 5 int i , f = 1;
6 int x; 6 for ( i =1; i<=n; i ++)
7 scanf(‘‘%d ’’, &x) ; 7 f=f∗i;
8 int i , f = 1; 8
9 for ( i =1; i<=x; i ++) 9 return f ;
10 f=f∗i; 10 }
11 11
12 printf (‘‘O fatorial de %d eh: %d\n ’’ ,x, f ); 12 int main (){
13 system(‘‘pause ’’); 13 printf (‘‘ Digite um numero inteiro positivo : ’’);
14 return 0; 14 int x;
15 } 15 scanf(‘‘%d ’’, &x);
16 int fat = fatorial (x);
17 printf (‘‘O fatorial de %d eh: %d\n ’’ ,x, fat);
18
20 return 0;
21 }
Perceba que no exemplo 1, não foi feito nada de diferente do que temos feito até o
momento. Já no exemplo 2, uma função especifica para o cálculo do factorial foi
construía. E, dentro da função responsável pelo cálculo do factorial, apenas o trecho do
código responsável pelo cálculo do factorial está presente. As operações de entrada e
saída de dados (comandos scanf e printf) são feitos em quem chamou a função
factorial, ou seja, na função main.

REFERÊNCIAS BIBLIOGRÁFICAS
Manzano, J. A. (2005). Algoritmos Lógica para Desenvolvimento de Programação de
Computadores. São Paulo: Érica Ltda.
Miyagusku, R. (2009). Informática para concursos. São Paulo: Universo dos Livros.
Seixas, J. (2005). Introdução à Programação em Ciência e Engenharia. Portugal:
Escolar Editora.
Soffner, R. (2013). Algoritmos e programação em linguagem C. São Paulo: Saraiva.
Programação (I) - Planejamento e Otimização, Edvaldo Silva de Almeida Júnior,
disponível em: www.vivaolinux.com.br.
Modularização: funções e procedimentos, http://iscte.pt/~mms/courses/ip/1998-
1999/teoricas/capitulo


MATERIAL_LINGUAGEM_PROGRAM_I_V1_NZENZU_091517_073337

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

MATERIAL_LINGUAGEM_PROGRAM_I_V1_NZENZU_091517_073337

Enviado por

Direitos autorais:

Formatos disponíveis

INSTITUTO SUPERIOR PRIVADO NZENZO ESTRELA

Elaborado por: Luzizila Salambiaku

4.1. Identiﬁcadores ................................................................................................................ 27

Elaborado por: Luzizila Salambiaku

EXERCÍCIOS PROPOSTOS .............................................................................................. 59

Elaborado por: Luzizila Salambiaku

Elaborado por: Luzizila Salambiaku

Recomendamos ao estudante, iniciante na programação de computadores, que não se

Elaborado por: Luzizila Salambiaku

NA SALA DE AULA DO CURSO

Elaborado por: Luzizila Salambiaku

Neste capítulo estudaremos as características dos algoritmos, suas formas de

Fonte inspiradora de livros e ﬁlmes, o americano Monty Roberts, conhecido como o

Elaborado por: Luzizila Salambiaku

1.2. O que é um algoritmo?

A palavra “algoritmo” é derivada do nome Mohammed ibn Musa Al-Khowarizmique,

1.2.1. Definição de Algorítimo

Um algoritmo é um conjunto não ambíguo e ordenado de passos executáveis que

O conceito de algoritmo é frequentemente ilustrado pelo exemplo de uma receita,

Elaborado por: Luzizila Salambiaku

ALGORITMO PARA FRITAR UM OVO

Figura 1: Ilustra dois passos possíveis envolvendo as operações de encher e esvaziar as

ALGORITMO PARA ENCHER VASILHAS

1. Encha a vasilha de nove litros.

Elaborado por: Luzizila Salambiaku

8. Usando a sobra da de nove litros (cinco litros), encha novamente a de quatro

1.3. Características de um algoritmo

Deﬁnição: Os passos de um algoritmo devem ser bem deﬁnidos, objectivando a clareza

1.4. A Criação de Algoritmos

A noção de algoritmo é central para toda a computação. A criação de algoritmos para

Elaborado por: Luzizila Salambiaku

Tabela 1: Dicas para aprender algoritmos

Algoritmos não se aprende... Algoritmos se aprende...

O aprendizado da Lógica é essencial para a formação de um bom programador, servindo

Ao logo de todo este curso, os conceitos básicos de Lógica necessários à programação

1.5. Formas de representação de algoritmos

As formas mais comumente utilizadas para representar algoritmos são as seguintes:

1.5.1. Descrição Narrativa

Os algoritmos são expressos em linguagem natural (português, inglês, francês,

Elaborado por: Luzizila Salambiaku

Figura 2: Formas geométricas utilizadas em ﬂuxogramas

A vantagem de se fazer uso dos ﬂuxogramas está na facilidade de compreendê-los.

Figura 3: Fluxograma para calcular a média aritmética de um estudante

Elaborado por: Luzizila Salambiaku

1.5.3. Linguagem Algorítmica

A linguagem que o computador é capaz de compreender tem grande inﬂuência na

O processador busca as instruções na memória e as executa uma de cada vez, segundo o

A linguagem algorítmica, também chamada de pseudocódigo ou pseudo-linguagem, por

As palavras em letras maiúsculas correspondem a palavras reservadas/chaves que fazem

Elaborado por: Luzizila Salambiaku

1. Explique, com suas próprias palavras, o que é algoritmo.

Elaborado por: Luzizila Salambiaku

CAPITULO 2: LINGUAGENS DE PROGRAMAÇÃO

Uma linguagem de programação é um conjunto de regras sintáticas e semânticas usadas

Linguagens de programação também tornam os programas menos dependentes de

2.1. Interpretação e compilação

Uma linguagem de programação pode ser convertida, ou traduzida, em código de

Elaborado por: Luzizila Salambiaku

Figura 4: Passos no processo de compilação

Figura 5:Processo de Interpretação

2.2. Paradigma de programação

Um paradigma de programação fornece e determina a visão que o programador possui

Um paradigma de programação está relacionado com a forma de pensar do programador

2.2.1. Paradigma imperativo

/Primeiro Programa em C/