Vamos Programar?

Vamos Programar?
– Introdução à Programação #25 - Pplware 12/11/15, 15:16
Vamos Programar? – Introdução à Programação #25
O mundo está constantemente a evoluir: desde o mais pequeno inseto à espécie

Humana. Dentro das palavras que mais ouvimos atualmente, incluímos “evolução”,
“mudança”, “futuro”.
A tecnologia tem revolucionado o mundo das mais diversas formas: do mais simples
aparelho para medir o tempo ao mais complexo acelerador de partículas. Se quer
entrar no mundo da tecnologia e deixar a sua marca, pode começar aqui.
Este é o último artigo da saga Introdução à Programação. Neste episódio marcamos as

25 semanas que se traduzem em 6 meses e mais 1 semana a escrever sobre C. Gostei
muito de escrever esta saga. Não só ensinei como também aprendi bastante. Os
comentários, na generalidade, foram bastante positivos, tendo aprendido com
diversos deles.
Não é o fim da saga “Vamos Programar?”, pois temos vindo a publicar o questionário
abaixo de forma a conhecermos a sua opinião acerca do que gostava de ver no futuro
da saga.7
Relativamente à saga “Introdução à Programação”, este é o seu fim. Mas, na próxima

semana, poderá vir a ter notícias acerca de algo baseado nesta saga. Fique atento(a).
http://pplware.sapo.pt/tutoriais/vamos-programar-introducao-a-programacao-25/ Página 1 de 89
Vamos Programar? – Introdução à Programação #25 - Pplware 12/11/15, 15:16

Humana. Evolução, mudança, futuro – são das palavras que mais são ouvidas
atualmente.
A tecnologia tem revolucionado o mundo das mais diversas formas. Se quer entrar no
mundo da tecnologia e deixar a sua marca, pode começar aqui.
Na semana passada, começámos a saga Introdução à Programação a falar sobre

Algoritmos, Fluxogramas e Pseudocódigo e hoje vamos continuar e falar sobre dois
métodos de armazenamento de valores: constantes e variáveis.
Atualizámos o artigo da semana passada para conter mais informação. A partir de

agora, colocaremos também uma versão em texto do vídeo que pode ou não conter
mais pormenores do que este.
Visualize este vídeo no YouTube.
Quando declaramos uma variável ou constante, estamos a reservar um endereço da

memória RAM onde poderemos guardar um valor. Por exemplo, se declararmos uma
variável chamada “EMPRESA” (sem aspas), um endereço da memória RAM é
reservado.
O valor desse endereço passará a estar disponível através do nome da variável
declarada – EMPRESA, neste caso. Depois disso, poderemos armazenar valores nesse
endereço.
Constantes
Tal como o próprio nome indica, as constantes permite-nos armazenar

valores constantes ou seja, depois de declararmos uma constante, não podemos
alterar o seu valor. Exemplo:
constante EMPRESA = "Pplware"; //Declaração da constante empresa e atribuição de valor.
EMPRESA = "A Minha Empresa"; //Erro: o valor da constante já foi definido
Tudo o que está depois de “//” (sem aspas) chama-se comentários e não são
interpretados sendo automaticamente ignorados. Como podem ver, a alteração do
valor de uma constante iria gerar erro.
O nome das constantes é, normalmente, escrito em letras maiúsculas. Isto é apenas

uma convenção porém torna-se mais fácil para um terceiro compreender o código
escrito.
Variáveis
Ao contrário das constantes, podemos alterar o valor das variáveis a qualquer

momento da execução de um programa. Aqui está um exemplo:
temaAtual = "Constantes"; //Declaração da variável "temaAtual" e atribuição de um valor

temaAtual = "Variáveis"; //Mudança de valor
Nesse excerto, nenhum erro seria gerado pois podemos mudar o valor as variáveis
quando quisermos. Como podem ter reparado, a nomenclatura é diferente da das
constantes.
Nas variáveis seguimos o padrão CamelCase, mais precisamente, o

lowerCamelCase onde iniciamos a primeira palavra com letra minúscula e todas as
restantes capitalizadas.
Regras de nomeação
Estas regras são muito importantes e são dirigidas tanto às constantes como às
variáveis. Quando damos um nome a uma variável, temos que ter em atenção as
seguintes regras:
Não pode começar com números;

Não pode ser igual a uma palavra reservada;
Não pode conter espaços;
Não pode conter caracteres especiais (alguns são permitidos de acordo com a
linguagem).
Agora deve estar a perguntar-se, o que é uma palavra reservada? Pois bem, as
palavras reservadas são aquelas que constam na “gramática” da linguagem de
programação.
Por exemplo, no pseudocódigo que utilizámos, uma condição começava com “SE”.
Assim, não podemos declarar uma variável ou constante com o nome “SE” pois é
reservada à linguagem de programação.
Tipos de variáveis e constantes
As variáveis e constantes podem ser de diversos tipos. Hoje vamos introduzir apenas
alguns tipos, os mais comuns, visto que estes variam de linguagem para linguagem.
Nas próximas semanas abordaremos os tipos existentes na linguagem que vamos

começar a utilizar (C) e novos conceitos relacionados com “tipagem”.
Como podem ver na imagem acima, os “principais” tipos de constantes e variáveis

existentes são:
int de “integer number” ou número inteiro: 5, -5, 22554, -515984512;

float de “floating-point numer” ou número com ponto flutuante: 3.14059 (sim,
este não é o pi), 1.58596548, -52.2358;
boolean ou booleano: true, false;
string ou conjunto de caracteres: “A minha frase”, “Este site chama-se Pplware”.
Como já referi, existem variações de linguagem para linguagem e quando começarmos

a aprender C, iremos ver que existem variações relativas ao que apresentámos aqui.
A linguagem que será utilizada será, em princípio, C pois é uma linguagem base e
muitas das que nós utilizamos atualmente são baseadas nela. Isto não quer dizer que,
no futuro, não falemos de outras linguagens pois temos algumas coisas em mente –
surpresa!
Sendo assim, para a semana vamos abordar novos conceitos que têm estado ocultos
até agora visto estarmos a utilizar pseudocódigo. Estes conceitos irão abranger
diversas coisas, incluindo o tema de hoje sendo que as próximas semanas irão conter
muito conteúdo.
Mais uma vez, gostávamos de saber a sua opinião. Caso tenha alguma dúvida, podem
sempre utilizar os comentários para colocar a questão. Caso o faça, pedimos que
utilize a keyword [DUVIDA] no início do seu comentário.
Paradigmas de Programação

atualmente.
Antes de começar a aprender C, iremos abordar alguns temas importantes. Hoje vai
aprender o que realmente é uma linguagem de programação e conhecer os
paradigmas de programação mais utilizados.
Visualize este vídeo no Youtube
Linguagem de programação
O conceito linguagem de programação ainda não foi abordado. Antes de continuar, é

fundamental que compreenda o que realmente é uma linguagem de programação.
Uma linguagem de programação é uma forma padronizada para comunicar

instruções a um computador ou seja, através de diversas regras semânticas e
sintáticas, podemos instruir o computador a fazer algo.
Paradigmas de Programação
Todas as linguagens de programação têm várias características dentro delas

os paradigmas de programação. Paradigmas são modelos ou padrões logo,
paradigmas de programação são formas de estruturar o código.
Cada linguagem de programação pode adoptar um ou mais paradigmas de

programação. As que adoptam mais do que um paradigma chamam-se multi-
paradigma.
Paradigma imperativo
O paradigma imperativo concentra-se num estado (que são as variáveis) e ações

(comandos) que modelam o estado.
Pode ser comparado ao modo modo imperativo da linguagem humana visto que é
criado para ordenar a realização de ações.
Exemplos (de linguagens de programação imperativas) : C, Java, C#, Pascal.
Paradigma procedimental
O paradigma procedimental permite a reutilização de código sem o copiar através da

utilização de funções e procedimentos (que falaremos mais à frente na saga). De certa
forma, com este paradigma, podemos “reciclar” código. A maioria das linguagens de
programação são procedimentais.
Paradigma estruturado
Uma linguagem de programação estruturada é aquela em que todos os programas

podem ser reduzidos a três estruturas: sequência, decisão e repetição (iteração).
Sequência
Nesta estrutura as tarefas são executadas de forma linear, ou seja, uma após a outra.
Exemplo:
Acordar;
Vestir;
Tomar o pequeno-almoço;
Ir trabalhar;
Fluxograma correspondente:
Este é um exemplo de uma sequência. Em muitas linguagens de programação, os

comandos/ações terminam com ponto e vírgula pois estas permitem que os comandos
sejam colocados em linha da seguinte forma:
Acordar; Vestir; Tomar o pequeno-almoço; Ir trabalhar;
A utilização do ponto e vírgula é, normalmente, obrigatória quando existem várias

instruções numa única linha. Linguagens de programação como Java, C# e C obrigam
ao uso do ponto e vírgula em todas as instruções independentemente se estão em
linha ou não.
Decisão
Neste tipo de estrutura, um determinado trecho de código é executado ou não

dependendo do resultado de um teste lógico. Abaixo encontra vários exemplos
práticos.
Exemplo 1:
O exemplo abaixo descreve a condição/decisão “se Acordar, vou Trabalhar, caso

contrário, não vou Trabalhar” através de pseudocódigo.
if "Acordar" then
"Trabalhar"
else
"Não trabalhar"
endif
Fluxograma correspondente:
O pseudocódigo acima já não está em português e já se assemelha ao que

irá visualizar nas linguagens de programação. Sempre que aparecerem termos em
inglês no código relacionado com a sintaxe, encontrará a sua tradução mais abaixo.
Neste caso:
if → se
then → então
else → caso contrário
endif (end if) → fim do if
Agora, e novamente relacionado com a decisão, repare que o trecho de código

“Trabalhar” só será executado se o indivíduo “Acordar”. Caso contrário, o trecho
“Não trabalhar” será executado. Abaixo pode visualizar mais exemplos.
Exemplo 2:
Dói-me a cabeça. Se doer muito pouco, vou trabalhar. Se doer pouco, tomo um
comprimido e vou trabalhar. Se doer muito, vou ao médico e falto ao trabalho.
case "Dor de cabeça"

when "muito pouco" then "trabalhar"
when "pouco" then "tomar comprimido"; "trabalhar"
when "muito" then "ir ao médico"; "não trabalhar"
Este é mais um exemplo mas utilizando diferentes comandos. Este trecho poderia ser
também escrito através de comandos if/else da seguinte forma:
if "Dor de cabeça"
if "muito pouco" then
"trabalhar";
elseif "pouco" then
"tomar comprimido";
"trabalhar";
else if "muito" then
"ir ao médico";
"não trabalhar";
endif
endif
Em fluxograma:
Novos termos:
case → caso
when → quando
else if → caso contrário se
Iteração
Neste tipo de estrutura, também conhecido como repetição, um trecho de código será
repetido um número finito de vezes dependendo do resultado de um teste lógico.
Exemplo 1:
Abaixo encontra a repetição “não saio de casa enquanto não estiver vestido” em
formato de pseudocódigo para melhor análise:
do {
"não sair de casa";
} while ( "não estou vestido" )
Ou seja, pode ler da seguinte forma: fazer x enquanto y.
Novo termo:
do → fazer
Exemplo 2
Enquanto estiver a Dormir, não me vou Vestir.
while ( "Durmo" )
"Não me visto";
Ou seja, enquanto acontece algo, faço outra coisa.
Exemplo 3
Lavo os dentes 20 vezes.
for ( i = 0; i < 20; i++ )

"Lavar os dentes"
Ou seja, enquanto não acontece qualquer coisa, faço qualquer coisa. Em fluxograma:
Novo termo:
for → para/enquanto
Exemplo 4
Para cada dente, lavo-o muito bem.
for each "dente" in "boca"

"Lavar muito bem"
Ou seja, para cada item do conjunto, fazer qualquer coisa. Novos termos:
each → cada
in → em
Paradigma Declarativo
O Paradigma Declarativo contrasta com o Imperativo pois é capaz de expressar a

lógica sem descrever como o fluxo de comandos funciona, ou seja, apenas diz ao
computador o que fazer e não como fazer.
Um excelente exemplo de uma linguagem que utiliza este paradigma é Prolog, muito
utilizado na área de inteligência artificial.
Paradigma Funcional
O Paradigma Funcional engloba todas as linguagens de programação que utilizam

funções matemáticas. Estas linguagens de programação são muito utilizadas no
campo da matemática.
Exemplos: Matlab, Wolfram Language/Mathmatica/M, B.
Paradigma Orientado a Objetos
A Programação Orientada a Objetos permite a criação de objetos com base

em classes. Estes objetos são instâncias dessas classes e possuem todos os atributos
e funções presentes nas classes em questão.
Este paradigma é muito extenso e tem muita informação que mais à frente irá ser
abordada. Atualmente, existem muitas linguagens que utilizam este paradigma.
Exemplos: Java, C++, C#, PHP.
Os paradigmas de programação não se limitam aos 6 (seis) apresentados pois existem

inúmeros outros. Estes são os mais utilizados. Existem ainda paradigmas que são
baseados noutros, contrastando com outros, etc.
Agradeço à Ana Narciso pela disponibilização de alguns exemplos utilizados na secção

“Paradigmas de Programação”.
Mais uma vez, gostávamos de saber a sua opinião. Caso tenha alguma dúvida, pode
utilize a keyword [DUVIDA] no início do seu comentário.
Uma breve história sobre C

atualmente.
Hoje trazemos aos nossos leitores, a si, uma pequena grande história sobre a
linguagem de programação C que começará a ser utilizada em breve.
Visualize este vídeo no Youtube
Antes de continuar, deve conhecer a história da linguagem de programação que

começará a ser utilizada em breve (dentro de uma ou duas semanas). Apesar de,
inicialmente, apenas abordarmos C, poderemos falar de outras também.
C – Uma pequena grande história
Os anos de 1969 a 1973 foram de extremo entusiasmo dentro da AT&T Bell Labs
porque foi quando a linguagem de programação C começou a ser desenvolvida.
O principal desenvolvedor desta linguagem foi Dennis Ritchie que descreveu o ano de
1972 como o mais produtivo e criativo. Este foi o ano em que mais avanços foram
criados na linguagem.
A linguagem desenvolvida por Ritchie chama-se C porque esta linguagem baseou-se

imenso numa outra linguagem de programação chamada B. Muitas das características
de C foram baseadas em B.
Numa fase inicial, esta linguagem de programação, C, tinha como principal finalidade o
desenvolvimento do Unix, que já havia sido escrito em Assembly – uma outra
linguagem de programação.
A versão mais recente de C é C11 e foi lançada a dezembro de 2011. Esta linguagem foi
uma das influências de muitas das linguagens de programação que atualmente são
muito utilizadas.
Dentro de muitas, C influenciou AWK, BitC, C++, C#, C Shell, D, Euphoria, Go, Java,
JavaScript, Limbo, Logic Basic, Objective-C, Perl e PHP. Isto não significa que estas
linguagens não tenham sido influenciadas por outras.
Características da linguagem
Todas as linguagens de programação contam com diversas características. Como

abordámos anteriormente, os paradigmas de programação são muito importantes e
influenciam a forma como devemos escrever.
Sendo assim, C é uma linguagem de programação, em relação aos paradigmas,

estruturada, imperativa e procedimental. Outras características desta linguagem
são o facto de ser compilada, padronizada pela ISO e de propósito geral.
Uma linguagem de programação compilada é aquela que passa pelo processo

de compilação ou seja, o seu código fonte é diretamente transformado na linguagem
da máquina por via de um compilador.
Porque iremos utilizar C?
Na comunidade de programadores/desenvolvedores existem sempre muitas opiniões:

todas diferentes e distintas. Porém, não quer dizer que sejam inválidas.
Nós iremos começar por abordar C porque é uma linguagem “mãe”, que influenciou
muitas outras. Aprendendo a linguagem C, fica preparado para se iniciar com muitas
outras linguagens de programação pois tem uma sintaxe muito utilizada e, além disso,
sabe a lógica.
Estes primeiros artigos não têm permitido muita interatividade entre si, leitor, e nós
mas, brevemente, isso irá mudar. Quando começarmos a colocar código-fonte C,
iremos colocar também exercícios para que desafie a sua mente.
utilize a keyword [DUVIDA] no início do seu comentários.
Instalação de um IDE

atualmente.
Na semana passada, a história da linguagem de programação C foi abordada. Na

próxima semana, iremos já começar a fazer exercícios e criar os nossos próprios
algoritmos. Mas, antes de começarmos a fazê-lo, vamos preparar o ambiente de
trabalho.
Esta semana não há vídeo mas na próxima semana já existirá.
Primeiramente, o que é um IDE? Um IDE é um Ambiente de Desenvolvimento
Integrado e deriva do inglês Integrated Development Environment. É um programa de

computador que reúne diversas ferramentas para apoiar no desenvolvimento de
software.
Existem diversos IDE disponíveis logo, as ferramentas que cada um disponibiliza não
são sempre as mesmas. Aqui está uma pequena lista com os três elementos
que costumam vir com um IDE:
Editor – a ferramenta primária que nos permite escrever o código-fonte nas

linguagens que o IDE suporta. Com um editor podemos ver a syntax do código-
fonte colorida.
Compilador -a ferramenta que transforma o código-fonte na linguagem da
máquina através do processo de compilação.
Depurador – esta ferramenta ajuda no processo de encontrar bugs (defeitos) no
código-fonte.
Sendo assim, hoje vou recomendar-lhe um IDE, que será utilizado ao longo da nossa
saga. Portanto, todas as instruções que lhe serão dadas ao longo do resto da saga,
serão direcionadas a este IDE.
Se utilizar outro IDE, não há qualquer problema, visto que não deverão existir
diferenças no código-fonte. Não recomendo a utilização do Visual Studio da
Microsoft por agora visto que o compilador por este IDE utilizado poderá precisar de
eventuais configurações.
Assim, para dar os primeiros passos em C, recomendo a utilização do NetBeans

porque é simples, tem uma interface agradável e está disponível para as mais diversas
plataformas.
Existem alguns passos que devem ser seguidos para instalar este IDE. Em primeiro
lugar, temos que instalar o JDK (Java Development Kit) que pode ser descarregado
aqui. A instalação do JDK não tem segredos e é fácil e rápida.
Depois, é hora de instalar o Netbeans. Descarregue-o aqui e certifique-se de que a

versão que descarrega é a C/C++. Ao contrário da maioria dos IDE, este não traz o
compilador pré-configurado.
Existem vários compiladores suportados pelo Netbeans. Pode ver aqui como instalar
o gcc nas diversas plataformas existentes. O GCC é o GNU Compiler Collection e
está nativamente disponível na maioria dos SO Linux.
Na página indicada acima existem instruções para Windows, Mac OS X, Solaris OS e

Linux. Se tiver qualquer dúvida em relação a qual ou como instalar o compilador, não
hesite em perguntar.
“Hello World!”

atualmente.
Na semana passada, falámos sobre a instalação de um IDE, sendo que o IDE que foi
recomendado foi o Netbeans. A partir de agora, algumas das partes que serão aqui
visualizadas terão o Netbeans na sua base, como, por exemplo, a forma de executar
um programa.
A utilização de um IDE poderá esconder diversos conceitos aos mais iniciantes porém,
nós optámos por seguir esse caminho visto que existem muitos sistemas operativos e
teríamos que dar instruções para vários SO ao mesmo tempo.
Visualize este vídeo no YouTube
Como seria o mundo da programação sem o famoso “Hello World”? É uma tradição o
primeiro programa criado por alguém imprimir a mensagem “Hello World” no ecrã.
Antes de escrever qualquer coisa em C, precisa criar um projeto. Para isso, abra o
Netbeans e clique File → New Project. No ecrã que se abriu escolha C/C++
Application.
De seguida clique em Next. Na nova janela, escolha o nome do projeto – que eu
coloquei “HelloWorld” – e onde vai guardar os ficheiros do projeto.
As restantes definições podem ficar como estão. Agora, deve ver uma disposição de
ficheiros parecida à seguinte:
De momento, deve focar-se na pasta Source Files que é a que contém o código-fonte
da aplicação. Abra o ficheiro main.c que foi criado automaticamente e apague o seu
conteúdo. Depois, copie e cole o seguinte trecho de código:
1 #include <stdio.h>
2
3 int main()
4 {
5 printf("Hello World!\n");
6 return 0;
7 }
Este trecho de código irá imprimir, numa janela de linha de comandos, a mensagem
“Hello World!”. Vamos então executar este trecho de código. Para isso, tem que clicar
no seguinte botão que está localizado na barra superior:
Depois de aguardarmos uns momentos, iremos visualizar a mensagem “Hello World!”

numa “caixa” semelhante à seguinte (localizada na parte inferior do Netbeans):
“#include”
A primeira linha do trecho acima não é C mas sim uma indicação para o compilador.
Vamos começar do início. C é uma linguagem de alta velocidade, por isso é que é
usada em locais que necessitam disso como, por exemplo, o kernel – núcleo – do Linux
e de diversos sistemas operativos como o Windows.
Devido à alta velocidade que pode ser proporcionada por esta linguagem, C não está
preparado, por omissão, para todos os tipos de tarefas. Assim, precisamos de incluí-
las para ter disponíveis mais funções.
Para as incluir, utilizamos o comando “#include” que diz ao compilador que precisa de
incluir ficheiros ponto H (.h) que são ficheiros do tipo HEADER.
Nesta caso adicionámos o ficheiro “stdio.h” que quer dizer standard input/output, ou
seja, sistema padrão de entrada e saída.
Função “main”
Todos os programas C têm que ter, obrigatoriamente, uma função “main” que será
automaticamente executada. Esta função retorna um dado do tipo “int” (número
inteiro).
De momento não há mais nada a acrescentar sobre funções porém, mais à frente,
iremos voltar a falar sobre este tema e o porquê de ser muito importante.
“printf”
Este é um comando/função que está contido no ficheiro stdio.h e, caso não incluamos
o ficheiro, será gerado erro. Esta função quer dizer print formatted ou seja “escrita de
dados formatados”.
Esta função aceita vários parâmetros ou seja, permite-nos enviar várias coisas que irão
ser processadas por ela. De momento, apenas iremos falar do primeiro argumento.
O primeiro argumento é uma string ou seja “conjunto de caracteres”. Este conjunto de

caracteres deve ser colocado dentro de aspas.
Neste caso escrevemos “Hello World!\n!” o que quer dizer que será imprimido “Hello
World!” na janela. E o que faz “\n”? Simples, é um caracter especial que imprime uma
nova linha. Chama-se new line.
A “\” serve para inserir caracteres especiais. Então… como se insere esta mesma
barra? Basta colocar “\\”. Existem alguns outros caracteres especiais que também
devem ser inseridos utilizando esta barra:
Tab → \t
Carriage Return (coloca o cursor no início da linha) → \r
Alguns sons → \a e \7
Por cento → %%
“return”
Como referi acima, a função main irá, neste caso, retornar um número inteiro. É aqui
que o comando return, que quer dizer retorno, entra. Este retorna o número 0 que é o
binário para falso.
De momento, ainda não temos muito a acrescentar sobre este comando mas mais à
frente iremos falar de novo sobre ele quando abordarmos funções e procedimentos.
Exercícios
1. Imprima o seu nome no ecrã.

2. Imprima a sua idade no ecrã.
3. Imprima o seu nome, idade, profissão e morada no ecrã em linhas separadas.
Tipos int, float, double e char.

atualmente.
Tipo int
O tipo de dados int é, como já deve saber, referente a números inteiros. Int quer
dizer integer number, ou seja, números inteiros. C, como é uma linguagem que
trabalha muito com o hardware do computador, permite-nos definir o tamanho de
cada variável deste (e de outros) tipos.
Primeiramente, como se declara uma variável int em C? É muito simples. No seguinte

exemplo pode visualizar como declarar uma variável e, posteriormente, imprimi-la:
2
3 int main() {
4
5 int a = 20;
6
7 printf("O número que guardei é %d.", a); //Imprime: O número que guardei é 20.
8 return 0;
9 }
Antes de continuar, deve ter reparado que foi utilizado um %d dentro do primeiro
parâmetro. Este caractere é substituído pelo valor da variável a quando é imprimido no
ecrã.
Função printf e números inteiros:
Utiliza-se %d quando se quer imprimir o valor de uma variável dentro de uma frase. A
variável deve ser colocada nos parâmetros seguintes, por ordem de ocorrência.
Exemplo:
2
3 int main() {
4 int a = 20;
5 int b = 100;
6
7 printf("O primeiro número é: %d.\n", a);
8 //Imprime: O primeiro número é: 20.
9 printf("O segundo número é: %d.\n", b);
10 //Imprime: O segundo número é: 100.
11 printf("O primeiro e segundo números são %d e %d.\n", a, b);
12 //Imprime: O primeiro e segundo números são 20 e 100.
13
14 return 0;
15 }
Este tipo de variáveis ocupa, normalmente, entre 2 a 4 bytes na memória de um

computador mas, e se quiser utilizar uma variável para um número pequeno? Não
poderei gastar menos recursos? E se acontecer o contrário e precisar de um número
maior?
Nestas situações, pode utilizar long e short para controlar os gastos de recursos.
Estes modificadores permitem-nos criar variáveis que ocupem um maior ou menor
número de bytes, respetivamente.
Um número inteiro de…
1 byte armazena de -128 a +127

2 bytes armazena de -32 768 a +32 767
4 bytes armazena de -2 147 483 648 a +2 147 483 647
8 bytes armazena de -9 223 372 036 854 775 808 a +9 223 372 036 854 775
807
A utilização destes modificadores é feita da seguinte forma:
1 short int nomeDaVariavel = 20; //Ou "long"
O número de bytes atribuída utilizando um destes modificadores pode depender do

computador onde o código está a ser executado. Para descobrirmos qual o tamanho
de bytes que utiliza o seu sistema, basta utilizar a função sizeof da seguinte forma:
2
3 int main()
4 {
5 printf("int : %d bytes\n", sizeof(int) );
6 printf("short int: %d bytes\n", sizeof(short) );
7 printf("long int: %d bytes\n", sizeof(long) );
8 return 0;
9 }
No computador que estou a utilizar, por exemplo, short refere-se a 2 bytes, long a 8
bytes e o tamanho padrão de int é 4 bytes.
Como sabe, os números inteiros podem assumir forma positiva e negativa. Por vezes,
na programação, os números negativos podem atrapalhar (ou então ajudar),
dependendo do caso.
Para termos controlo sobre a positividade ou negatividade de um número, podemos

atribuir os modificadores signed e unsigned.
Para que uma variável possa conter tanto números positivos como negativos, devemos
utilizar o modificador signed. Caso queira que o número seja apenas positivo, incluindo
0, utilize unsigned
Tipo float e double
Além dos números inteiros, existem outros tipos de dados que nos permitem
armazenar números que, ao invés de serem inteiros, são decimais.
Existem dois tipos de dados que nos permitem armazenar valores do tipo decimal/real.
Estes tipos são float e double. Devem ser utilizados da seguinte forma:
1 float pi = 3.14;
2 double pi = 3.14159265359;
Como pode ter reparado, em C (e na maioria das linguagens de programação), não se

utiliza a vírgula, mas sim um ponto para separar a parte inteira da decimal.
A diferença entre float e double é que o segundo ocupa mais memória que o primeiro
logo, consegue armazenar números de maior dimensão.
Normalmente, o tipo float ocupa 4 bytes de memória RAM enquanto o segundo tipo,
double, ocupa 8 bytes de memória. Mais uma vez, relembro que estes valores podem
alterar de máquina para máquina.
Para quem precise de fazer cálculos mais precisos, o tipo de dados double é o mais
aconselhado pois é o que permite uma maior extensão do valor.
Função printf e números decimais:
Utiliza-se %f quando se quer imprimir o valor de uma variável dos tipos float ou double
dentro de uma frase. A variável deve ser colocada nos parâmetros seguintes, por
ordem de ocorrência. Exemplo:
2
3 int main()
4 {
5 float piMinor = 3.14;
6 double piMajor = 3.14159265359;
7
8 printf("Pi pode ser %f mas, de forma mais exata, é %f.", piMinor, piMajor);
9 //Imprime: Pi pode ser 3.140000 mas, de forma mais exata, é 3.141593.
10 return 0;
11 }
Pode visualizar que, quando se utiliza %f, é utilizado um número específico de casas
decimais. Caso o número de casas decimais seja mais pequeno do que o da variável
original, o número é arredondado.
Pode definir o número de casas decimais que quer que sejam apresentadas da
seguinte forma: %.{Número de Casas Decimais}f. Veja o seguinte exemplo, baseado no
anterior:
2
3 int main()
4 {
5 float piMinor = 3.14;
6 double piMajor = 3.14159265359;
7
8 printf("Pi pode ser %.2f mas, de forma mais exata, é %.11f.", piMinor, piMajor);
9 //Imprime: Pi pode ser 3.14 mas, de forma mais exata, é 3.14159265359.
10 return 0;
11 }
Notação Científica
Certamente conhece notação científica, ou seja, números no formato NUM1 X

10^NUM2 (NUM vezes dez elevado a NUM2). Podemos utilizar notação científica nas
variáveis do tipo float e double. Veja o seguinte exemplo:
2
3 int main()
4 {
5 float num = 24E-5; //24 x 10 elevado a -5
6 printf("%f\n", num); //Imprime: 0.000240
7
8 num = 2.45E5; //2.45 x 10^5
9 printf("%.0f", num); //Imprime: 245000
10
11 return 0;
12 }
Tipo char
Há algumas semanas atrás, falámos do tipo string: um tipo de dados que nos permite
armazenar sequências de caracteres, ou seja, de forma geral, frases.
Por agora, ainda não abordaremos este tipo, mas sim char. Este é um tipo de dados
que nos permite armazenar um único caractere. É declarado da seguinte forma:
Como pode visualizar, a variável “letra” agora contém o caractere “P”. Pode, ao invés
de utilizar este tipo de notação, utilizar números hexadecimais, octais e decimais.
Clique aqui para descarregar uma tabela ASCII em pdf com os códigos que pode
utilizar em C.
Função printf e caracteres:
Utiliza-se %c quando se quer imprimir o valor de uma variável dos tipos char dentro de
uma frase. A variável deve ser colocada nos parâmetros seguintes, por ordem de
ocorrência. Exemplo:
2
3 int main()
4 {
5 char letra = 'P';
6
7 printf("O nome Pplware começa por %c.", letra);
8 return 0;
9 }
Exercícios
Imprima o nome “Pplware” recorrendo a variáveis do tipo “char”.

Imprima a sua idade numa frase do tipo “A minha idade é X.” recorrendo às
funcionalidades da função printf.
Imprima o número 125.2485215487514 com apenas duas casas decimais.
Descubra o tamanho dos tipos signed, unsigned, int, short e long que são
utilizados no seu computador.
Descubra o tamanho do tipo char recorrendo à função sizeof.
Na próxima semana, as coisas vão começar a tornar-se mais interessantes.

Começaremos a pedir dados ao utilizador e a criar condições.
Operadores e loops “if else”

atualmente.
Operadores
Operadores são símbolos para efetuar determinadas ações. Na programação existem

diversos tipos de operadores. Operadores estes que também existem noutras áreas do
conhecimento como matemática, por exemplo.
Serão abordados 3 tipos de operadores: aritméticos, de atribuição e relacionais. O

primeiro grupo de operadores serve, obviamente, para efetuar operações
matemáticas. São utilizados os seguintes símbolos:
Operadores Aritméticos
Nome Símbolo Exemplo
Soma + 5+4=9
Subtração – 154 – 10 = 144
Multiplicação * 5,55 * 10 = 55,5
Divisão / 40 / 2 = 20
Resto de uma divisão % 1500 % 11 = 4
Os operadores de atribuição, tal como o próprio nome indica, servem para atribuir a
uma variável, determinado valor. Existem vários operadores de atribuição e, muitos
deles, funcionam como abreviatura para operações aritméticas.
Relembro que os operadores que aqui estão representados existem em muitas outras
linguagens e que existem alguns outros dependendo da linguagem de programação.
Operadores de Atribuição
Símbolo Exemplo*
= var = 20 → 20
+= var += 5 (igual a var = var + 5) → 25
-= var -= 10 → 15
*= var *= 4 → 60
/= var /= 5 → 12
%= var %= 5 → 2
* Os exemplos aqui apresentados estão todos encadeados. O valor de var no segundo

exemplo é atribuído no primeiro exemplo e assim consequentemente. Os valores a
negritos precedidos por uma seta (→) correspondem ao valor com que a variável ficou.
Os operadores que agora vamos abordar, serão extremamente úteis para a matéria
seguinte (Loops) pois permitem-nos efetuar comparações entre variáveis numéricas.
Ora veja:
Operadores Relacionais
Nome Símbolo Exemplo
x == y → retorna TRUE se x for igual a y e FALSE se tiverem
Igualdade ==
valores diferentes
Diferente != x != y → retorna TRUE se x for diferente de y ou FALSE se x for

igual a y
Maior > x > 40
Maior ou
>= y >= 25
Igual
Menor < y < 20
Menor ou
<= x <= y
Igual
Loops “if else”
Os loops “if else” permitem executar determinados trechos de código dependendo do

resultado de um teste lógico/condicional. A palavra if quer dizer “se” e else quer dizer,
neste caso, “ou”. A sintaxe deste loop é a seguinte:
1 if (condição) {
2 //Se a condição retornar TRUE então este código é executado.
3 } else {
4 //Caso contrário, isto é executado.
5 }
Comentários
No código acima pode verificar que utilizámos duas barras (//) e depois escrevemos
algo. Isto chamam-se comentários e são simplesmente ignorados pelo compilador.
Existem dois tipos de comentários: comentários de uma linha e comentários de várias

linhas. Veja o seguinte exemplo:
2
3 int main()
4 {
5 int n = 1; //Até ao final da linha é um comentário.
6
7 /*
8 TUDO ISTO é um comentário
9 */
10 }
Imagine que tem uma variável que contém um número qualquer e quer que o seu
código imprima se a variável é maior ou igual a 50 ou menor que 50. Como vai
proceder?
Para criar este algoritmos precisamos de inicializar uma variável, efetuar um teste
condicional (utilizando um operador relacional) e depois executar o código em
questão. Veja:
2
3 int main()
4 {
5 int n = 25;
6
7 if (n >= 50) {
8 printf("O valor %d é maior ou igual a 50.", n);
9 } else {
10 printf("O valor %d é menor que 50.", n);
11 }
12
13 return 0;
14 }
Este trecho de código imprime uma mensagem a dizer que 25 é menor que 50. Como
pode ver, isto apenas nos diz se a variável é menor que 50 ou então maior ou igual.
Mas, e seu quiser que as seguintes condições sejam testadas:
Se for maior que 50 imprime X.

Se for igual a 50 imprime Y.
Se for menor que 50 imprime Z.
Podíamos efetuar este teste condicional da seguinte forma:
7 if (n > 50) {
8 printf("O valor %d é maior que 50.\n", n);
9 }
10
11 if (n < 50) {
12 printf("O valor %d é menor que 50.\n", n);
13 }
14
15 if (n == 50) {
16 printf("A variável é igual a 50.\n");
17 }
Isto tornaria o código um pouco repetitivo. Podemos utilizar o comando else if que
quer dizer “ou se” da seguinte forma:
7 if (n == 50) {
8 printf("A variável é igual a 50.\n");

9 } else if (n < 50) {
10 printf("O valor %d é menor que 50.\n", n);
11 } else {
12 printf("O valor %d é maior que 50.\n", n);
13 }
Como gerar um número aleatório
Nos exercícios seguintes, irá precisar de gerar um número aleatório. Para o fazer, irá
necessitar de incluir mais um ficheiro .h que se chama time.h.
Pode utilizar a função para gerar números aleatórios da seguinte forma:
2 #include <time.h>
3 #include <stdlib.h>
4
5 int main()
6 {
7 //Inicializar a seed para o número aleatório
8 srand (time(NULL));
9 //Atribuir o número aleatório (entre 1 e 10) a uma variável
10 int n = (rand() % 10) + 1;
11
12 return 0;
13 }
Mais tarde falaremos melhor sobre esta função. Deverá incluir a biblioteca “stdlib” que
é uma biblioteca de propósito geral que contém um leque de funções muito utilizadas,
incluindo a rand e a srand.
Exercícios
1 – Crie três variáveis. Duas com números à sua escolha e uma terceira com a soma
das outras duas. De seguida, imprima o valor das duas.
2 – Crie uma variável do tipo número inteiro que contenha um valor entre 1 e 100. De
seguida, duplique o seu valor.
Depois, verifique se o seu valor é igual a 100 e, caso seja, imprima uma mensagem de
congratulação.
Caso o valor seja mais pequeno que 100, imprima o valor e que este é menor que 100.
Faça o mesmo caso o número seja maior que 100 alterando a mensagem para
corresponder.
3 – Crie um programa que resolva uma equação de 2º grau completa de 3 números

aleatórios lembrando que a fórmula para resolver equações de 2º grau completas é a
seguinte:
Na próxima semana iremos falar de como interagir com o utilizador. Será, talvez, um
dos pontos mais emocionantes até hoje.
Receber números e letras do utilizador

atualmente.
Interação com o utilizador
Numa aplicação, a interação com os utilizadores é algo extremamente fundamental.

Se não houver interação com o utilizador, a aplicação é, na maioria das vezes, algo
inútil.
Na sequência disto, irá aprender a receber dados do utilizador utilizando duas

funções: scanf e getchar. Todas diferentes mas, ao mesmo tempo, todas úteis.
scanf
A função “scanf” permite-nos obter diversos tipos de dados do utilizador: números

inteiros, decimais e também caracteres. Exemplo:
2
3 int main()
4 {
5 int idade;
6
7 printf("Digite a sua idade: ");
8 scanf("%d", &idade);
9
10 printf("A sua idade é %d", idade);
11
12 return 0;
13 }
Como pode ver na oitava linha, o primeiro argumento da função “scanf” contém o tipo
de variável que vai ser inserido (tal como na função “printf”).
Os argumentos seguintes serão o nome das variáveis, precedidos por um “&”, a que os
valores vão ser atribuídos. Pode ler a linha 8 da seguinte forma: “atribuir um número
inteiro a idade”.
Quando se executa o código acima, irá aparecer a mensagem “Digite a sua idade: ” e o
cursor irá posicionar-se logo após essa frase aguardando que um valor seja inserido.
Depois de inserir o valor e pressionar ENTER, será imprimida uma mensagem com a
idade que inseriu.
Relembrando, pode utilizar as seguintes expressões para definir o tipo de dados a ser
introduzido:
%d → Números inteiros (int)

%f → Números decimais (float e double)
%c → Caracteres (char)
Pedir mais do que um item
Podemos pedir mais do que um valor/caractere da seguinte forma:
2
3 int main()
4 {
5 int num1, num2;
6
7 printf("Digite dois números: ");
8 scanf("%d %d", &num1, &num2);
9
10 printf("Os números que digitou são %d e %d.", num1, num2);
11
12 return 0;
13 }
Ou seja, depois de aparecer a mensagem “Digite dois números:”, terá que inserir dois
números e pode identificar a sua separação com um espaço, enter ou tab.
Como pode ver, é muito simples utilizar a função scanf. Apesar de apenas termos
utilizado números inteiros, pode utilizar números decimais ou caracteres com esta
função.
getchar
Existe outra forma, mais simples, de pedir caracteres ao utilizador: a função “getchar”.
Compare os seguintes dois exemplos (primeiro com scanf e segundo com getchar):
2
3 int main()
4 {
5 char letra;
6
7 printf("Insira a primeira letra do seu nome: ");
8 scanf("%c", &letra);
9
10 printf("A primeira letra do seu nome é %c.", letra);
11 return 0;
12 }
2
3 int main()
4 {
5 char letra;
6
8 letra = getchar();
9
10 printf("A primeira letra do seu nome é %c.", letra);
11 return 0;
12 }
Como pode verificar, a utilização da função “getchar” é bastante simples e permite-

nos receber, mais facilmente, caracteres do utilizador.
Buffer e a sua limpeza
2
3 int main()
4 {
5 char letra1, letra2;
6
8 scanf("%c",&letra1);
9
10 printf("E agora a última: ");
12
13 printf("O seu nome começa com \"%c\" e termina com \"%c\".", letra1, letra2);
14
15 return 0;
16 }
Olhando para o código acima, irá pensar que coloco duas letras como “H” e “E” e que,
no final é imprimido «O seu nome começa com “H” e termina com “E”.» mas não. Não
é isso que acontece. Experimente correr o código.
Como deve ter verificado, logo após digitar a primeira letra, o programa terminando
deixando o espaço para a segunda letra em branco.
O que aconteceu aqui? Quando nós clicamos no ENTER para submeter a primeira
letra, além dessa letra, o ENTER (“\n”) é submetido para a memória e quando aparece
um novo pedido para inserir um caractere, o “\n” é automaticamente assumido como
esse novo caractere.
Para que isto não aconteça, basta limpar o buffer antes de utilizar novamente a
função. No Windows utilizamos a função “fflush(stdin)” e no Linux “__fpurge(stdin)” de
forma a limpar o buffer do stdin (teclado).
Então, ficaria assim:
2
3 int main()
4 {
5 char letra1, letra2;
6
9
10 fflush(stdin);
11 __fpurge(stdin);
12
13 printf("E agora a última: ");
15
16 printf("O seu nome começa com \"%c\" e termina com \"%c\".", letra1, letra2);
17
18 return 0;
19 }
Exercícios
1 – Crie um programa que gere um número aleatório entre 1 e 10; de seguida peça-lhe
um número e, se acertar no número gerado recebe uma mensagem a dizer que
ganhou. Caso contrário, recebe uma mensagem a dizer que perdeu.
2 – Crie um programa, baseando-se no da aula anterior, que peça os três números de

uma equação de 2º grau e a resolva. Caso esta seja impossível, o utilizador deverá ser
alertado.
3 – Crie um programa que, primeiro, peça dois números do tipo float e, de seguida,
imprima as seguintes instruções:
Que operação deseja efetuar:

A - Soma
B - Subtração
C - Divisão
D - Multiplicação
De seguida deverá pedir a opção ao utilizador e mostrar o resultado consoante a
escolha. O resultado deverá ter 3 casas decimais.
Operadores de incremento/decremento/lógicos e Loops while

atualmente.
Infelizmente, esta semana não temos um vídeo por motivos “temporais” porém,
prometemos que na próxima semana voltará a haver vídeo.
Operadores Lógicos
Os operadores lógicos são, normalmente, utilizados em testes lógicos quando
queremos incluir mais do que uma condição para que algo aconteça. Existem três
operadores lógicos que vamos abordar agora: “&&”, “||” e “!”.
Operador “&&”
Na programação, o operador “&&” funciona como um “e” na nossa língua: para

adicionar algo, neste caso, uma condição. Veja alguns exemplos:
2
3 int main()
4 {
5 int num1;
6 num1 = 4;
7
8 if (num1 > 0 && num1 <= 10) {
9 printf("O número %d está entre 1 e 10.", num1);
10 }
11
12 return 0;
13 }
O que está expresso na condição acima é: se “num1” for maior que 0 e menor ou igual
a 10 então executa o código que está ali dentro.
Este comando pode ser utilizado mais do que uma vez dentro de um teste condicional
pois podemos colocar duas ou mais condições utilizando este operador. Basta
adicionar “&&”.
Operador “||”
O operador “||” refere-se a “ou”, ou seja, utilizando este operador podemos executar
uma condição do seguinte tipo: executa isto se x acontecer ou se y acontecer.
Exemplo:
2
3 int main()
4 {
5 int num1;
6 num1 = 3;
7
8 if (num1 == 3 || num1 == 5) {
9 printf("O número é 3 ou 5.\n");
10 }
11
12 return 0;
13 }
Como pode visualizar, o teste condicional acima verifica se a variável “num1” é 3 ou

cinco e só depois executa o código condicionado ou não.
Operador “!”
Podemos traduzir o operador “!” para “o contrário de”. Quando utilizado numa
condição, por exemplo, este nega tudo o que lá está. Exemplo:
2
3 int main()
4 {
5 int num1;
6 num1 = 0;
7
8 if (!num1) {
9 printf("O valor de num1 corresponde a falso.\n");
10 }
11
12 return 0;
13 }
Relembrando que 0 é considerado falso e qualquer número maior é considerado

verdadeiro, o código que está dentro do teste condicional acima só é executado se
num1 não for verdadeiro.
Operadores de Incremento e Decremento
Os operadores de incremento e decremento são dois operadores que vão ser

extremamente úteis na vida de qualquer programador.
Imagine que necessita de contar um número infinito de números independentemente

se é no sentido crescente ou decrescente. Vai fazê-lo um a um? Não, não é
necessário.
2
3 int main()
4 {
5 int num;
6
7 num = 1;
8 printf("O número é %d\n", num);
9
10 num = num + 1;
12
13 num = num + 1;
15
16 return 0;
17 }
O código acima imprime a frase “O número é” e o número que está atribuído a “num”
nesse momento. Começando em 1 e chegando a 3 no final do algoritmo.
Existe outra forma de adicionar e remover uma unidade a uma variável: “++” e “–“.
Veja como ficaria o código anterior utilizando essa sintaxe:
2
3 int main()
4 {
5 int num;
6
7 num = 1;
9
10 num++;
12
13 num++;
15
16 return 0;
17 }
Isso irá imprimir o mesmo que o código mostrado anteriormente. Para remover uma
unidade basta fazer do seguinte modo:
2
3 int main()
4 {
5 int num;
6
7 num = 1;
9
10 num--;
12
13 return 0;
14 }
Estes operadores podem ser utilizados antes ou depois de uma variável: “num++” ou
“++num”. Quando estes operadores são utilizados isoladamente, nenhuma diferença
existe porém, quando estamos a efetuar uma atribuição, existe uma diferença. Analise
o seguinte exemplo:
2
3 int main()
4 {
5 int a, b, c;
6
7 a = 0;
8 b = a++;
9 c = ++a;
10
11 printf("A: %d, B: %d, C: %d", a, b, c);
12
13 return 0;
14 }
Primeiramente, declaramos três variáveis: “a”, “b” e “c”. De seguida, atribuímos o valor
0 à variável “a”. Quando atribuímos “a++” à variável “b”, o que vai acontecer?
A variável “b” vai assumir o valor 0 e um valor é incrementado a “a” ficando esta com o
valor 1, ou seja, “b = a++” é um atalho para o seguinte:
De seguida, quando atribuímos “++a” à variável “c”, estamos a incrementar primeiro a

variável “a” e só depois é que o valor de esta é atribuído a “c”, ou seja, é um atalho
para o seguinte:
Como pode visualizar, estes operadores podem ser muito úteis em diversas situações.
Mesmo que agora não esteja a visualizar estas situações, não se preocupe: irá ver
muitas!
Controlo de fluxo com while
Já foi abordado o controlo de fluxo utilizando if else. Agora é a vez de um novo “tipo”
de controlo de fluxo, o while ou, em português, “enquanto”. A sintaxe do while é a
seguinte:
1 while(condição) {
2 //Algo acontece
3 }
Veja então o seguinte exemplo da utilização deste tipo de controlo de fluxo que
imprime os números de zero a dez:
2
3 int main()
4 {
5 int num;
6 num = 0;
7
8 while(num <= 10) {
9 printf("%d\n", num);
10 num++;
11 }
12
13 return 0;
14 }
Sem utilizar este controlo de fluxo, teríamos que escrever muito mais código de forma
a conseguir imprimir os números de um a dez através de uma variável.
Exercícios
1 – Imprima os números pares de 0 a 100 utilizando um loop while.
2 – Imprima todos os números entre -100 e 100 que sejam divisíveis por 5 e 3.
3 – Gere um número inteiro aleatório entre 1 e 10. De seguida, peça ao utilizador que
insira um número entre o intervalo anteriormente indicado.
Caso o número que o utilizador insira esteja fora do intervalo, deverá alertar o
utilizador para esse problema. Caso o número esteja no intervalo e seja igual ao
gerado, deverá mostrar uma mensagem de parabéns.
Caso não seja igual ao número gerado, deverá dizer ao utilizador a seguinte
mensagem dependendo da amplitude (diferença entre o número inserido e o número
indicado):
Extremamente Perto. (Amplitude 1)

Perto. (Amplitude 2/3)
Podia estar mais perto. (Amplitude 4/5)
Hmmm… Um pouco longe. (Amplitude 6/7)
Muito longe. (Amplitude 8/9)
De seguida, o programa deverá continuar a pedir um número ao utilizador e verificar

todas estas condições até o utilizador acertar no número.
Observação: para obter um valor absoluto utilize a função “abs” do ficheiro “stdlib.h”.
Interrupção do fluxo e teste lógico switch

atualmente.
Interrupção do Fluxo
Os fluxos são algo (quase) indispensável em programas minimamente complexos que,

por vezes, precisamos ter um maior controle sobre os mesmos. Já conhecemos
o loop while que nos permite repetir um determinado trecho de código enquanto uma
condição for verdadeira.
Mas e se necessitarmos de interromper a continuidade de um fluxo por algum motivo?

Se por exemplo, efetuarmos um teste lógico if para saber se é necessário efetuar algo
mais dentro de um loop while. Se sim, realiza, mas caso contrário, deverá passar para
a próxima iteração (repetição).
break
O primeiro comando que nos permite ter um maior controle sobre os fluxos de
repetição é o comando break permite que terminemos o loop atual sem quaisquer
problemas.
Exemplo
Precisamos de encontrar o primeiro número divisível por 17, 18 e 20 entre 0 e

1000000. Para o fazermos, bastaria utilizar o seguinte código:
2
3 int main()
4 {
5 int count,
6 num;
7
8 count = 1;
9 num = 0;
10
11 while(count <= 1000000) {
12 if(num== 0) {
13 if((count%17==0) && (count%18==0) && (count%20==0)) {
14 num=count;
15 }
16 }
17 count++;
18 }
19
20 printf("O número divisível por 17, 18 e 20 entre 1 e 1000000 é: %d", num);
21 return 0;
22 }
Este trecho de código, depois de encontrar o número, que é 3060, continuaria a

efetuar testes lógicos até o contador chegar a 1000000. Mas, se já encontrou o
número, qual a necessidade de gastar tempo e poder de processamento? Bastaria
adicionar um break para colmatar esta situação da seguinte forma:
2
3 int main()
4 {
5 int count,
6 num;
7
8 count = 1;
9 num = 0;
10
11 while(count <= 1000000) {
12 if(num== 0) {
13 if((count%17==0) && (count%18==0) && (count%20==0)) {
14 num=count;
15 break;
16 }
17 }
18 count++;
19 }
20
21 printf("O número divisível por 17, 18 e 20 entre 1 e 1000000 é: %d", num);
22 return 0;
23 }
continue
O comando continue é o segundo comando deste género que interrompe a iteração

atual passando logo para a seguinte iteração.
Exemplo
Precisamos de somar todos os números entre 0 e 1000 que não são múltiplos de 2
nem de 3. Para isso utilizamos o seguinte código:
2
3 int main()
4 {
5 int count,
6 sum;
7
8 count = 1;
9 sum = 0;
10
11 while(count <= 1000) {
12
13 if(count%2 == 0 || count%3 == 0) {
14 count++;
15 continue;
16 }
17
18 sum += count; //sum = sum + count

19 count++;
20 }
21
22 printf("Soma %d", sum);
23 return 0;
24 }
O que este código faz é percorrer os números de 1 a 1000 e, se for divisível por 2 ou
por 3, passa para a próxima iteração (adicionando um valor ao número atual). Caso a
condição não se verifique, o número é acrescentado à soma, adicionado um número a
count passando assim para a próxima iteração.
Teste lógico switch
O teste condicional switch é extremamente útil quando precisamos de, por exemplo,
efetuar um comando dependendo da opção, entre 0 e 10, que o utilizador escolheu.
Claro que poderíamos utilizar os if porém o código ficaria deveras extenso e um pouco
complicado de ler. Veja o seguinte código com um switch:
2
3 int main()
4 {
5 int option;
6
7 printf("Insira a opção:\n");
8 scanf("%d", &option);
9
10 switch(option) {
11 case 1:
12 printf("Escolheu a opção 1");
13 break;
14 case 2:
16 break;
17 case 3:
19 break;
20 case 4:
22 break;
23 case 5:
25 break;
26 default:
27 printf("Opção inexistente.");
28 break;
29 }
30
31 return 0;
32 }
Como pode visualizar, o código executado para cada opção pode ser diferente. Caso o
inserido não corresponda a nenhuma das opções, o que está em default é executado.
Veja o código anterior com if else:
2
3 int main()
4 {
5 int option;
6
7 printf("Insira a opção:\n");
8 scanf("%d", &option);
9
10 if (option == 1) {
12 } else if (option == 2) {
20 } else {
21 printf("Opção inexistente.");
22 }
23
24 return 0;
25 }
Comparando as duas, é possível verificar que utilizando o switch o código fica mais
legível e fácil de ser editado.
Deve ter reparado ainda que no final de cada instrução do switch utilizámos um break.
Isto acontece porque, caso não o utilizemos, o programa continuaria a correr os
comandos seguintes que existem no switch.
Exercícios
1 – Crie uma calculadora que possibilite fazer adições, subtrações, divisões e

multiplicações a mais do que dois números. Utilize um switch e um loop while.
2 – Crie um programa que imprima os três primeiros números divisíveis por 5 e,

simultâneamente por 10, entre 100 e 1000 minimizando o processamento recorrendo à
interrupção do fluxo.
Testes Lógicos de Repetição do while e for

Teste Lógico do while
Os testes lógicos de repetição são, como já deve saber, extremamente úteis em

inúmeras situações pois permitem-nos reutilizar código. Recentemente abordámos o
teste lógico de repetição while e hoje iremos abordar um outro semelhante: o do while.
A sua sintaxe é a seguinte:
1 do
2 {
3 //código a ser repetido
4 } while (condição);
Ao contrário do que acontece com o teste lógico while, no do while, o código é

executado primeiro e só de seguida é que se confirma a veracidade da condição. Se a
condição for verdadeira, então o código é executado mais uma vez, caso não o seja, já
não será executado.
Este facto faz com que o que código contido dentro do teste lógico seja
executado pelo menos uma vez. Veja então o seguinte exemplo de uma simples
calculadora com o código documentado.
2
3 int main()
4 {
5 /*
6 * Variável que irá determinar se executamos
7 * o código da calculadora de novo ou não.
8 */
9 int calcular;
10
11 do {
12
13 char operacao;
14 float num1,
15 num2;
16
17 //Limpeza do buffer
18 fflush(stdin);
19 __fpurge(stdin);
20
21 printf("Escolha a operação [+ - * / ]: ");
22 scanf("%c",&operacao);
23
24 printf("Insira o primeiro número: ");
25 scanf("%f",&num1);
26
27 printf("Insira o segundo número: ");
28 scanf("%f",&num2);
29
30 switch( operacao )
31 {
32 case '+':
33 printf("%.2f + %.2f = %.2f\n", num1, num2, num1 + num2);
34 break;
35
36 case '-':
37 printf("%.2f - %.2f = %.2f\n", num1, num2, num1 - num2);
38 break;
39
40 case '*':
41 printf("%.2f * %.2f = %.2f\n", num1, num2, num1 * num2);
42 break;
43
44 case '/':
45 printf("%.2f / %.2f = %.2f\n", num1, num2, num1 / num2);
46 break;
47
48 default:
49 printf("Você digitou uma operação invalida.\n");
50 break;
51 }
52
53 printf("Insira 0 para sair ou 1 \n");
54 scanf("%d", &calcular);
55
56 } while (calcular);
57 /*
58 * Se "calcular" for diferente de 0 (falso), o código
59 * da calculadora será executado novamente.
60 *
61 * Para terminar o código basta então digitar 0 quando
62 * for pedido.
63 */
64
65 return 0;
66
67 }
Teste Lógico for
Outro teste lógico de repetição que é muito importante é o for e é muito útil quando,
por exemplo, precisamos de inicializar uma variável a que deve ser incrementado um
número. Veja a sintaxe:
1 for(inicio_do_loop ; condição ; termino_de_cada_iteração)

2 {
3 //código a ser executado
4 }
Vamos agora ver um pequeno exemplo comparando a sintaxe com um teste lógico
while. O código seguinte utiliza o último loop mencionado para imprimir os números de
0 a 100:
2
3 int main()
4 {
5 int num;
6 num = 0;
7
8 while (num <= 100) {
10 num++;
11 }
12
13 return 0;
14 }
Abaixo pode encontrar o seu equivalente com o teste de repetição for:
2
3 int main()
4 {
5 int num;
6
7 for(num = 0; num <=100; num++) {
9 }
10
11 return 0;
12 }
Apesar de parecer apenas uma pequena redução de duas linhas, com códigos mais
complexos poderão ser poupadas mais linhas e este loop também melhora a
legibilidade do código.
Ressalto também que os interruptores de fluxo break e continue funcionam com este
teste lógico de repetição.
Exercícios
1 – Crie um pequeno menu de opções com, no mínimo, cinco opções à sua escolha
sendo uma delas para terminar o programa e as restantes para efetuar qualquer coisa
que deseje. O menu deverá continuar a aparecer até o utilizador pedir para fechar.
2 – Recorrendo ao teste lógico for, imprima todos os números divisíveis por 4, 10 e 25

entre 1 e 1000.
Funções e Procedimentos

Pedimos desculpa pela gafe no vídeo onde é referido que 6 + 4 é igual a 11.
Funções
Uma função é um bloco de código que, tal como o próprio nome indica, tem uma
função própria, ou seja, que serve para aquela finalidade. As funções permitem-nos,
por exemplo, reutilizar código.
Ao invés de colocarmos um determinado trecho de código diversas vezes, basta

criarmos uma função com esse código e, de cada vez que for necessário, precisamos
apenas de invocar a função.
Durante os seus anos de programador, irá criar milhares de funções para as mais
diversas funções. Então, recomendamos que vá guardando as funções que utiliza
porque, futuramente, poderá necessitar delas.
Existe uma função que tem vindo a ser sempre utilizada: a função main. É a função
principal do programa, aquela que é executada automaticamente quando um programa
é executado. A sintaxe das funções é a seguinte:
1 tipo_dado_retorno nome_da_funcao(parametros) {
2 //Codigo da Funcao
3 }
Vejamos então o exemplo de uma função simples que nos permite mostrar a
mensagem “Olá Mundo!”:
2
3 int main() {
4 sayHello();
5 return 0;
6 }
7
8 void sayHello() {
9 printf("Olá Mundo!\n");
10 }
A função chama-se “sayHello” e não retorna nenhuns dados (“void”). O que está
dentro das chavetas (“{}”) é o código que é executado quando a função é chamada.
Argumentos e Parâmetros
No exemplo acima é possível visualizar que tanto na invocação da função, como na sua
escrita foi colocado um par de parênteses sem nada. Isto acontece porque não
existem parâmetros.
Vamos criar uma função que efetua uma soma: como enviamos os valores para a
função? Definindo o nome e o tipo de parâmetros a serem recebidos. Veja o seguinte
exemplo.
1 void soma(int n1, int n2) {

2 int soma = n1 + n2;
3 }
A função acima, denominada “soma”, tem dois parâmetros, o “n1” e o “n2”, ambos do
tipo inteiro. Os valores que a eles irão ser atribuídos chamam-se argumentos.
Para utilizar a função, basta então proceder do seguinte modo:
Substituindo os números 4 e 6 por quaisquer números que desejar e a função irá

armazenar, na variável “soma” que apenas está disponível dentro da função, o valor da
soma entre os dois números.
Retorno
Na função anterior somámos dois números mas nada mais aconteceu. E se quisermos,
por exemplo, que a função retorne o valor da soma?
Para isso teremos que substituir o “void” pelo tipo de dados que, neste caso é “int” e
utilizar o comando “return”. Ficaria algo semelhante ao seguinte:
1 int soma(int n1, int n2) {

2 int soma = n1 + n2;
3 return soma;
4 }
Ou seja, enviamos dois números para a função; esta cria a variável “soma” com a soma
dos dois números e de seguida retorna esta variável que é do tipo “int”. Podemos
simplificar esta função ficando apenas com o seguinte:

2 return n1 + n2;
3 }
Podemos, por exemplo, utilizar esta função no seguinte contexto:
2
3 int main() {
4 int a, b;
5
6 printf("Insira o primeiro número: ");
7 scanf("%d", &a);
8
9 printf("Insira o segundo número: ");
10 scanf("%d", &b);
11
12 printf("A soma é %d", soma(a,b));
13 return 0;
14 }
15
17 return n1 + n2;
18 }
Procedimentos
Procedimentos são também blocos de código que contêm uma função específica. A
diferença entre funções e procedimentos é que os segundos não retornam quaisquer
valores.
Exercícios
Nesta semana trazemos uma dose maior de exercícios em relação às semanas

anteriores. Os exercícios das semanas anteriores podem ser reaproveitados!
1 – Crie uma função denominada “receberNumero” que recolha um número do tipo

“float” e o retorne e outra chamada “receberInt” para receber um número inteiro.
2 – Crie funções que peçam, calculem e mostrem os valores das seguintes

fórmulas/operações:
Perímetro
Quadrado
Retângulo
Triângulo
Círculo
Área
Quadrado
Retângulo
Triângulo
Losango
Círculo
Trapézio
Elipse
Volume
Cubo
Paralelepípedo
Cilindro
Esfera
Pirâmide Quadrangular/Retângular
Cone
E também para resolver equações de segundo grau completas e imprimindo os seus

resultados, relembrando que a fórmula é a seguinte e que, quando o resultado do que
está dentro da raiz é negativo não se deve prosseguir (números imaginários não).
3 – Crie três funções para dizer os valores das áreas, perímetros e volumes finais.
Deve ser chamada no final de cada uma das funções anteriores (excepto a da fórmula
resolvente/equação de segundo grau).
4 – Articule tudo o que fez anteriormente através de menus.
Deixamos aqui a resolução deste exercício mas, primeiro tente, só depois de muitas
tentativas é que deve ver a resolução.
Arrays Unidimensionais e Multidimensionais

Infelizmente, o artigo desta semana não é acompanhado por vídeo porém esperemos
que apreciem o restante conteúdo.
Arrays
Até agora apenas falámos de variáveis escalares, ou seja, variáveis com valores
individuais. Vamos então falar de uma nova estrutura de dados: as arrays.
Arrays, também conhecidas por “tabelas” ou “vetores”, são estruturas de dados que,
ao contrário de variáveis escalares, nos permitem armazenar mais do que um valor.
Estas são como matrizes (ou tabelas) de dados em que cada dado está localizado
numa determinada posição que pode ser acedida através de “coordenadas”. Existem
dois tipos: as unidimensionais e as multidimensionais.
Arrays Unidimensionais
Arrays unidimensionais podem ser comparadas a tabelas com uma única coluna e
várias linhas. São o tipo mais simples de arrays.
Sintaxe
Onde:
tipo → O tipo de dados que a array vai conter;

nome → O nome da array, tal como se faz com uma variável;
tamanho → O número máximo de elementos que a array irá conter.
Exemplo
1 int idades[10]; //Array de 10 elementos

2
3 idades[0] = 14; //Atribuição Correta
6 idades[10] = 20; //Atribuição Incorreta (tamanho máximo da array ultrapassado)
No exemplo anterior, a última declaração está errada porque o índice máximo da array
foi ultrapassado, ou seja, a array apenas pode conter 10 elementos mas, como a
contagem inicia sempre no zero, “idades[10]” refere-se ao décimo primeiro elemento.
Podemos também, à semelhança do que acontece com as variáveis, atribuir valores às

arrays no momento em que as declaramos da seguinte forma:
1 int idades[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
Arrays Multidimensionais
Arrays multidimensionais são todas aquelas que contenham mais do que uma
dimensão, ou seja, se comparamos a uma tabela, têm mais do que uma coluna.
Sintaxe
1 tipo nome[linhas][colunas];
Exemplo
1 /*
2 * Declaração de uma array 6x5
3 */
4 float notas[6][5];
5
6 notas[0][0] = 18.7; //1ª Linha, 1ª Coluna
10 notas[6][0] = 20.0; //Excedeu o máximo de linhas (6)
11 notas[5][5] = 17.4; //Excedeu o máximo de colunas (5)
No exemplo anterior é possível visualizar a criação de uma tabela array 6 linhas por 5
colunas. Traduzindo esta array para uma tabela, ficaríamos com o seguinte:
Que, inserindo os dados anteriormente utilizados no exemplo, ficaria preenchida da

seguinte forma:
18.7 15.4
19.6
17.5
A sintaxe que aplicámos anteriormente para atribuir valores a arrays quando as

inicializamos também pode ser utilizada neste contexto. Veja o seguinte exemplo:
1 int idades[2][4] = {
2 {1, 2, 3, 4},
3 {0, 1, 2, 3}};
Exercícios
1 – Crie um programa que peça cinco números inteiros ao utilizador, os armazene

numa matriz e, posteriormente, imprima os números armazenados na matriz tal como
o índice (posição) em que se encontram.
2 – Crie um pequeno programa onde o utilizador tenha que inserir os valores (float)
que obteve no final do ano letivo em sete disciplinas e, posteriormente, mostre a sua
média. Utilize apenas uma array para armazenar todos os valores.
3 – Crie mais um programa para obter as notas de cinco testes em 3 disciplinas (matriz
3×5) e percorra cada linha de forma a dizer a nota mais alta de cada uma das três
disciplinas.
Constantes

Constantes
Em C, tal como em outras linguagens de programação, existem as constantes.

Constantes são, à semelhança das variáveis, algo em que pudemos armazenar dados
mas que, ao contrário das variáveis, não podemos alterar os dados que lá estão
gravados.
Existem diversas formas de declarar constantes em C. Iremos abordar duas que são as
mais utilizadas: as constantes declaradas e as constantes definidas.
Constantes Definidas (#define)
Chamam-se Constantes Definidas àquelas que são declaradas no cabeçalho de um

ficheiro. Estas são interpretadas pelo pré-processador que procederá à substituição
da constante em todo o código pelo respetivo valor.
Sintaxe
1 #define identificador valor
Onde:
identificador → o nome da constante que, convencionalmente, é escrito com

letras maiúsculas;
valor → o valor da constante.
Exemplo
2
3 #define PI 3.14159
4
5 int main (){
6
7 double r = 5.0;
8 double circle;
9
10 circle = 2 * PI * r;
11 printf("%f\n", circle);
12 return 0;
13
14 }
O que acontece aqui é que, quando o pré-compilador lê a definição da constante “PI”,

substitui todos os “PI” no código pelo valor que lhe está atribuído, literalmente.
Constantes Declaradas (const)
As Constantes Declaradas, ao contrário das Constantes Definidas são, tal como o

próprio nome indica, declaradas no código, em linguagem C.
A declaração destas constantes é extremamente semelhante à declaração das

variáveis. Apenas temos que escrever const antes do tipo de dados.
Sintaxe
1 const tipo nome = valor;
Onde:
tipo → o tipo de dados que a constante vai conter;

nome → o nome da constante;
valor → o conteúdo da constante.
Exemplo
2 #include <math.h>
3
4 int main() {
5 const double goldenRatio = (1 + sqrt(5)) / 2;
6
7 goldenRatio = 9; //Erro. A constante não pode ser alterada.
8
9 double zero = (goldenRatio * goldenRatio) - goldenRatio - 1;
10 printf("%f", zero);
11
12 return 0;
13 }
Existem vantagens ao utilizar esta forma de declarar constantes. Através das

constantes declaradas podemos ter constantes locais ou globais porém as definidas
são sempre globais.
Uma constante local é uma constante que está restrita a uma determinada função, por
exemplo. Se declararmos uma constante dentro de uma função, esta só estará
disponível para o código que está dentro dessa mesma função.
Exercícios
1 → Crie um pequeno programa em que o utilizador insira um montante sem IVA e que
o programa lhe devolva o valor com IVA. Deve utilizar uma constante.
2 → Crie um pequeno programa onde efetua dez operações (à sua escolha) que
relacione os números que desejar e uma constante. Esta constante deve ser numérica.
Apontadores: uma pequena introdução

Infelizmente, e mais uma vez, esta semana não iremos ter vídeo porém garantimos que
na próxima semana haverá. Antes de continuar, recomendamos uma breve leitura
deste artigo no Pplware Kids onde explicamos a diferença entre bits e bytes.
Apontadores
Para os computadores tudo se resume a bits, ou seja, a zeros e a uns. Então, para os
computadores, as diferenças que nós conhecemos entre os diversos tipos de variáveis
(char, int, double/float, etc) são praticamente inexistentes.
Uma forma bastante utilizada para administrar o número enorme de 0’s e 1’s é através
do endereçamento. Cada bocado da memória, cada variável, cada constante

(Constante Declarada) tem o seu endereço único.
Quando uma variável é declarada é reservado, automaticamente, um espaço na

memória que irá conter os valores desta mesma variável. Dentro do nosso computador
existem micro-dispositivos cuja função está diretamente ligada com o endereçamento.
Os apontadores, também conhecidos por ponteiros ou pointers, são tipos de dados

que serve para armazenar um endereço da memória. Apesar dos endereços de
memória serem representados por números inteiros, não os confunda com o tipo de
dados int.
Endereço de uma variável
Para nos referirmos ao endereço de uma variável, devemos utilizar o operador & (e
comercial) antes do nome da variável. No exemplo seguinte, imprimo o endereço de
memória onde está alocado o valor da variável “num” e “letra”:
2
3 int main() {
4
5 int num = 4;
6 char letra = 'c';
7
8 printf("%p e %p", &num, &letra);
9
10 return 0;
11 }
Como pode ver, neste caso foi utilizado %p visto que se refere a endereços de
pointers. Eu recebi os valores 0028FF1C e 0028FF1B, mas a si é provável que a função
retorne outros valores. Estes valores são o endereço da memória onde estão alocadas
as variáveis acima mencionadas. Cada byte da memória RAM tem o seu endereço.
Daí que, em funções como, por exemplo, a scanf, utilizemos este operador antes do
nome da variável para nos referirmos ao endereço de memória da variável e assim
armazenar o valor nesse local.
Esta semana não iremos recomendar exercícios pois o conteúdo de hoje não é
suficiente para novos exercícios. Porém, continue a praticar! Na próxima semana
iremos continuar o tema dos apontadores.
Apontadores: endereçamento

Apontadores
Na semana passada, começámos a abordar o tema “Apontadores”. Esta semana,

iremos continuar a abordar esse mesmo tema que é muito útil.
Tamanho e endereço de variáveis
Primeiramente, devo recordar que todos os tipos de dados ocupam um espaço

diferente na memória RAM. Para saber quantas bytes ocupam um determinado tipo,
deve-se recorrer à função sizeof cujo único argumento é a variável em questão.
Ou seja, para se saber quantas bytes ocupa o tipo int, devemos passar como
argumento à função sizeof uma variável desse tipo.
No seguinte exemplo é imprimido o tamanho de espaço que ocupam quatro tipos de

dados e ainda o endereço da memória a que corresponde cada variável.
3
4 int main()
5 {
6 char caractere;
7 int inteiro;
8 float Float;
9 double Double;
10
11 printf("Tipo\tNum de Bytes\tEndereço\n");
12 printf("-------------------------------------\n");
13 printf("Char\t%d byte \t\t%p\n", sizeof(caractere), &caractere);
14 printf("Inteiro\t%d bytes \t%p\n", sizeof(inteiro), &inteiro);
15 printf("Float\t%d bytes \t%p\n", sizeof(Float), &Float);
16 printf("Double\t%d bytes \t%p\n", sizeof(Double), &Double);
17
18 return 0;
19 }
O resultado da execução do código acima deverá ser algo semelhante ao seguinte:
1 Tipo Num de Bytes Endereço

2 -------------------------------------
3 Char 1 byte 0028FF1F
4 Inteiro 4 bytes 0028FF18
5 Float 4 bytes 0028FF14
6 Double 8 bytes 0028FF08
Como pode verificar, todos os tipos de dados exceto char ocupam mais do que um
byte na memória RAM. Então, o endereço que é imprimido corresponde apenas ao
primeiro byte ocupado pela variável.
Hexadecimal para Decimal
Antes de continuarmos, será útil abordar como se convertem números hexadecimais

para decimais. Primeiramente, como já deve ter reparado, os números hexadecimais
contam com letras, além de números.
Isto acontece porque a numeração hexadecimal tem como base 16 números enquanto
que a decimal tem como base 10 números. Veja então o número que corresponde a
cada letra da numeração hexadecimal na tabela seguinte:
Hexadecimal Decimal Hexadecimal Decimal

0 0 8 8
1 1 9 9
2 2 A 10
3 3 B 11
4 4 C 12
5 5 D 13
6 6 E 14
7 7 F 15
Iremos converter o número hexadecimal 0028FF1F para decimal. Em primeiro lugar,

iremos tirar os primeiros dois zeros que são, neste caso, desprezíveis.
De seguida precisamos conhecer o significado de cada dígito hexadecimal em número

decimal que está presente nesse número. Em decimal, os números 2, 8, F e 1 são,
respetivamente, 2, 8, 15 e 1.
Para efetuar a conversão, temos que multiplicar cada um desses números por uma
potência de base 16 cujo expoente é igual à posição de cada um dos números (da
direita para a esquerda). Então, temos:
1 (2*16^5)+(8*16^4)+(15*16^3)+(15*16^2)+(1*16^1)+(15*16^0) =
2 = 2097152+524288+61440+3840+16+15 =
3 = 2686751
Voltando aos endereços das variáveis e convertendo-os para números decimais,

obtemos os seguintes valores:
1 Tipo Num de Bytes Endereço

2 -------------------------------------
3 Char 1 byte 2686751
4 Inteiro 4 bytes 2686744
5 Float 4 bytes 2686740
6 Double 8 bytes 2686728
Podemos concluir dos dados acima que a variável que declarámos do tipo char, no
meu computador, ocupa a posição 2686751 enquanto que as outras ocupam mais do
que uma.
Relembrando que as bytes alocadas para variáveis que ocupam mais do que uma
encontram-se localizadas lado a lado, de seguida e que o endereço que obtemos
corresponde ao da primeira byte, a variável do tipo inteiro que declarámos ocupa as
bytes cujos endereços (em número decimal) são 2686744, 2686745, 2686746 e
2686747.
Estas informação serão muito úteis para os próximos artigos. Fique atento.
Declaração e inicialização de Apontadores

Nesta semana, infelizmente, não haverá vídeo porém tentaremos fazer na próxima
semana. Hoje iremos continuar o tema dos apontadores. Os apontadores, como já foi
referido anteriormente, são um tipo de variáveis que armazenam endereços.
Declaração de apontadores
A declaração deste tipo de variáveis é bastante simples: para declarar um apontador

basta colocar um * (asterisco) antes do nome da variável.
Sintaxe
Veja então a sintaxe da declaração de ponteiros.
Tal como nas restantes variáveis, temos que colocar o tipo de dados na declaração da
variável devido ao facto do espaço ocupado por cada tipo de dados ser diferente.
Quando não é dado um valor a um apontador, geralmente este assume o valor da

constante NULL, ou seja, não aponta para endereço nenhum.
A constante NULL está contida na biblioteca stdlib, ou seja, standard library e o seu
valor é, na maioria das vezes, 0.
Inicialização de apontadores
Para inicializar um apontador, devemos igualar o seu valor ao endereço de uma outra
variável do mesmo tipo.
Exemplo 1
Para exemplificarmos a relação entre uma variável comum e um ponteiro, iremos

declarar o seguinte código:
3
4 int main()
5 {
6 int numero = 5;
7 int *ponteiro = &numero;
8
9 printf("%d e %d", numero, *ponteiro);
10
11 return 0;
12 }
Dentro da função principal, declaramos duas variáveis: a primeira, chamada numero, é

uma variável do tipo de números inteiros e conta com o número 5.
De seguida, declaramos um ponteiro cujo nome é, exatamente, ponteiro e este

ponteiro aponta para o endereço da variável numero. Podemos então dizer que
“ponteiro aponta para numero” ou “ponteiro é o endereço de numero”.
Depois imprimimos o valor de numero e do endereço que para o qual aponta ponteiro.
Isto irá imprimir “5 e 5”, pois é o mesmo dizer numero e *ponteiro visto que o ponteiro
ponteiro aponta para a variável numero.
Exemplo 2
O segundo exemplo é minimamente bizarro: efetuar a soma de duas variáveis

utilizando apenas apontadores que apontem para estas mesmas variáveis. Ora veja:
Se está a ter problemas com a codificação dos caracteres no Windows, inclua a

biblioteca “Windows” e altere a página de codificação da linha de comandos
como está na linha 7.
3 #include <windows.h>
4
5 int main()
6 {
7 SetConsoleOutputCP(65001);
8
9 int a, b, c;
10 int *p, *q;
11
12 a = 5;
13 b = 4;
14
15 p = &a;
16 q = &b;
17 c = *p + *q;
18
19 printf("A soma de %d e %d é %d.", a, b, c);
20 return 0;
21 }
No exemplo anterior pode visualizar que são declaradas cinco variáveis: a a, b e c que
são do tipo número inteiro e, de seguida, dois apontadores, p e q. Posteriormente é
atribuído o valor 5 à variável a e o valor 4 à variável b.
Agora, para efetuar a soma utilizando os operadores, igualamos o apontador p ao

endereço da variável a e o apontador q ao endereço da b. Finalmente, a soma (que
estará contida na variável c) é igual à soma do conteúdo dos endereços que para os
quais os apontadores p e q estão a apontar.
Exemplo 3
O exemplo anterior aparenta ser inútil, pois poderíamos fazer o mesmo com menos
linhas de código. Mas, e se precisar de, por algum motivo, criar uma função que troque
o valor de duas variáveis? Poderíamos, inicialmente, pensar no seguinte:
1 int trocaDeValores( int x, int y)

2 {
3 /* Esta função está errada */
4 int temp;
5
6 temp = x;
7 x = y;
8 y = temp;
9
10 return 0;
11 }
Mas a função apresentada não vai realmente alterar os valores das variáveis, pois
apenas recebe os seus valores e “coloca-os” numas míseras variáveis locais. A função
correta teria que ser a seguinte:
1 int trocaDeValores( int *p, int *q)

2 {
3 int temp;
4
5 temp = *p;
6 *p = *q;
7 *q = temp;
8
9 return 0;
10 }
Com esta função sim, poderíamos trocar os valores de duas variáveis, pois ao termos
acesso aos seus endereços podemos facilmente efetuar as mudanças.
Exercícios
1 – Analise o seguinte trecho de código e descubra o porquê deste estar errado.
1 int trocaDeValores( int *i, int *j) {

2 int *temp;
3
4 *temp = *i;
5 *i = *j;
6 *j = *temp;
7
8 return 0;
9 }
2 – Crie uma função que receba três variáveis do tipo inteiro: minutosTotais e dois
apontadores (um para a variável horas e outro para a variável dos minutos).
Dentro dessa função, os minutosTotais devem ser convertidos em horas e minutos e

guardados nas respetivas variáveis cujos endereços foram passados para dentro da
função.
Na função main, crie as variáveis que achar necessárias e peça o número de minutos
que deseja converter em horas e minutos ao utilizador. De seguida utilize a função
anteriormente criada e imprima o resultado dado por esta.
Não se esqueça que a função horasParaMinutos não deve retornar o número de horas
e minutos, mas sim colocar esses valores nos endereços passados para a função.
Apontadores: incremento, decremento e comparação

Operações com Operadores
Uma das principais vantagens da utilização de apontadores é a fácil modificação de

outras variáveis e que o C trabalha de forma mais rápida quando são utilizados
ponteiros.
Tal como acontece com as outras variáveis, podemos incrementar e decrementar

apontadores, ou seja, incrementar ou decrementar ou endereço (valor) que contém o
apontador.
Imagine que temos um array do tipo double com dois elementos. Sabemos também
que cada variável deste tipo ocupa, geralmente, 8 bytes na memória RAM. De seguida,
cria um apontador cujo endereço aponta para esse array. O que vai acontecer é que
esse endereço apontará para o primeiro byte do array e não para todos eles.
1 double numeros[2]; /* Declaração do array com dois elementos. */

2 double *apontador;
3
4 apontador = numeros;
Hipoteticamente falando, esse apontador armazena o endereço 4550. Então, sabendo

que o array ocupa 16 bytes (visto que tem capacidade para dois elementos do tipo
double), podemos dizer que este array ocupa todos os bytes entre 4550 e 4565
(inclusive).
Se procedermos a uma incrementação (apontador++), este apontador deixará de

apontar para o endereço 4550, apontando agora para o 4558. Porquê? Porque a
próxima variável do array localiza-se nessa posição e não na posição 4551 devido ao
tamanho ocupado por esse tipo de dados. O mesmo ocorre quando decrementamos
um valor.
Imaginando os endereços de variáveis como números decimais (não se esqueça de

que são representados em hexadecimal), as duas linhas seguintes seriam
equivalentes:
1 apontador++;
2 apontador + sizeof(double);
Exemplo Para exemplificarmos o uso de operações e apontadores, vamos fazer uma

Progressão Aritmética, onde há um termo inicial e uma razão. Cada termo é igual ao
termo anterior somado com a razão.
n[y] = n[y-1] + r
Poderíamos fazer este pequeno programa da seguinte forma (o código abaixo está
explicado):
3
4 int main()
5 {
6 int pa[10], razao;
7 int *pointer;
8
9 /*
10 * Aqui pedímos o termo inicial, ou seja, o primeiro
11 * número da PA (Progressão Aritmética).
12 *
13 * De seguida o apontador é definido para apontar para
14 * o array pa.
15 */
16 printf("Insira o termo inicial: ");
17 scanf("%d", &pa[0]);
18 pointer = pa;
19
20 printf("Insira razão: ");
21 scanf("%d", &razao);
22
23 while(pointer != &pa[9]) {
24 /*
25 * Cada valor da PA é definido somando o valor corrente do apontador com a razão.
26 * De seguida, o apontador é incrementado de forma a apontar para o próximo
27 * elemento do array. (Isto acontece enquanto o apontador for diferente do
28 * endereço do último elemento da PA.)
29 */
30 *(pointer + 1) = *pointer + razao;
31 pointer++;
32 }
33
34 printf("PA");
35
36 for(pointer = pa ; pointer <= &pa[9] ; pointer++) {
37 /*
38 * Aqui todos os elementos do array são percoridos
39 * e imprime-se assim a Progressão Aritmética criada.
40 */
41 printf(" -> %d", *pointer);
42 }
43
44 return 0;
45 }</stdlib.h></stdio.h>
Strings: declaração e inicialização

Strings
Strings, como já mencionado anteriormente, são sequências de caracteres e, em C,

são arrays de caracteres com um delimitador que indica o final da string, o delimitador
\0. Daí termos abordado primeiro os arrays.
O \0 é ASCII para 0 e é utilizado para finalizar “strings>.
1 "Pplware" -> String

2 "P" -> String
3 'P' -> Caracter
Como mostrado acima, os caracteres, já abordados, são colocados dentro de plicas

enquanto que todas as strings são colocadas dentro de aspas. Um único caracter
inserido dentro de aspas é considerado uma string.
Sintaxe Em C podemos declarar strings de diversas formas. Podemos declarar um

array do tipo char com um número de caracteres definidos:
1 char nome[8] = "Pplware";
Nesse string podemos colocar a palavra “Pplware” que tem 7 caracteres, mas qual é a
razão que nos leva a colocar 8 quando declaramos a variável? Não se esqueça do
caracter \0 que conta como 1 caracter.
Podemos ainda declarar e inicializar strings das seguintes formas:
1 char nome[8] = {'P', 'p', 'l', 'w', 'a', 'r', 'e', '\0'}; /* Forma mais trabalhosa */
2 char nome[] = "Pplware"; /* Não há necessidade de colocar o seu tamanho. */
3 char *nome = "Pplware";
Este “tipo” de dados pode, à semelhança de todos os outros, ser integrado com a
função printf utilizando “%s”, uma abreviatura para string.
Exemplo No exemplo seguinte declaramos uma string que depois é imprimida

recorrendo à função printf.
3
4 int main()
5 {
6 char *nome = "Vamos Programar? - Introdução à Programação";
7
8 printf("%s\n", nome);
9 return 0;
10 }
Exercícios
1 – Crie uma variável que armazene o seu nome e, de seguida, o imprima.
2 – Peça o primeiro e último nomes do utilizador através da função scanf (scanf(“%s”,
nome_da_var)) e depois imprima-o no seguinte formato: “Bem-vindo, Sr(a) NOME +

ULTIMO_NOME”.
Ler e imprimir strings.

Depois de vos explicarmos o que são e como se utilizam strings na Linguagem C, é

importante saber como as podemos ler e imprimir no ecrã. Antes de continuarmos, é
importante referir que o “seletor” utilizado para strings é \%s.
Imprimir strings
A impressão de strings no ecrã pode ser feita de diversas formas. Iremos abordar duas
delas: a função printf, já conhecida por todos vós, e a função puts.
Função printf
Esta função já é conhecida por todos vós e permite a impressão de diversos tipos de
dados de forma bastante simples.
Sintaxe
Para a utilizar com strings basta escrever da seguinte forma:
1 printf("Esta é uma string: %s", nomeDaString);
Ou seja, é bastante útil quando necessitamos de imprimir uma string variável

intercalada com algum outro texto.
Função puts
Por outro lado, temos a função puts que quer dizer put string. Esta função é bastante
útil quando precisamos imprimir apenas uma sequência de caracteres variável.
Sintaxe
Ora veja a sintaxe:
Leitura de Strings
Finalmente, abordaremos como se leem strings escritas pelo utilizador.
Função scanf
A utilização da função scanf para obter sequências textuais é semelhante à forma que
utilizamos para ler números, tanto inteiros, como decimais. Porém, existe uma
pequena diferença.
Sintaxe
Veja a sintaxe e tente descobrir a diferença que existe (além do uso de \%s):
1 scanf("%s", nomeDaString);
Como pode verificar, ao contrário do que acontecia com os restantes tipos de

variáveis, neste não colocamos o operador & antes do nome da variável. Porquê?
Porque as variáveis que contêm strings são arrays, logo o seu nome aponta para a
primeira posição da memória ocupada por todo o array. Daí não ser necessário o uso
do operador &.
Exemplo
No seguinte exemplo pode ver como utilizamos esta função para obter diversos dados
do utilizador que depois são imprimidos recorrendo à função printf anteriormente
abordada.
3
4 int main()
5 {
6 char nome[21],
7 apelido[21],
8 morada[51],
9 codigoPostal[11];
10
11 printf("Por favor insira os seus dados conforme pedido:\n\n");
12 printf("Primeiro nome: ");
13 scanf("%s", nome);
14
15 printf("Último nome: ");
16 scanf("%s", apelido);
17
18 printf("Morada: ");
19 scanf("%s", morada);
20
21 /* Limpeza do buffer no Windows.
22 Usar "_fpurge(stdin)" em sistemas Unix */
23 fflush(stdin);
24
25 printf("Código Postal: ");
26 scanf("%s", codigoPostal);
27
28 printf("\nO seu Cartão de Identificação:\n");
29 printf("Nome: %s, %s\n", apelido, nome);
30 printf("Morada: %s\n", morada);
31 printf("Código Postal: %s\n", codigoPostal);
32 return 0;
33
34 }
Função gets
Outra função que nos permite ler strings é a função gets, cujo nome advém de get
string, ou seja, obter string. A utilização desta função é algo bastante simples.
Sintaxe
Ora veja a sintaxe:
Onde “nomeDaString” se refere ao apontador que aponta para a primeira posição do

array que contém a sequência de caracteres.
Exemplo
Aqui pode ver como fica o programa do exemplo anterior utilizando esta função.
3
4 int main()
5 {
6 char nome[21],
7 apelido[21],
8 morada[51],
9 codigoPostal[11];
10
13 gets(nome);
14
16 gets(apelido);
17
19 gets(morada);
20
22 gets(codigoPostal);
23
28 return 0;
29 }
Exercícios
Esta semana temos poucos exercícios para vós. Aqui vai:
1 – Criar um pequeno programa que peça o primeiro nome ao utilizador e que o
imprima de trás para a frente.
2 – Criar uma aplicação que peça os utilizador o seu nome, o seu apelido, a sua data
de nascimento, morada, código postal, número de telemóvel, telefone e que imprima
uma espécie de BI.
Um pouco mais sobre a função scanf e algumas dicas

O artigo de hoje irá incidir sobre algumas sugestões a referir dadas por leitores no
artigo da semana passada, mas também iremos começar a abordar outro tópico.
Limpeza do buffer
No artigo número nove da presente saga introduzimos as seguintes funções:
Ambas as funções permitem-nos limpar o buffer de entrada, porém não são muito
seguras. Em programação profissional de C (e outras linguagens), estas funções não
são utilizadas por motivos de segurança.
Claro que existem “soluções” alternativas. O leitor José Carlos Ferreira, no artigo da
semana anterior, sugeriu-nos o seguinte:
1 #define CLEAR_INPUT while (!getchar ())
O que nos permite utilizar o trecho de código:
Recorrendo apenas ao nome “CLEAR_INPUT”.
Alternativa a gets e a scanf
Devido à falta de uma solução efetiva ao problema existente com a função scanf e à
existência de alguns contra-tempos com a função gets foi sugerido, pelos leitores Zé e
lmx a utilização da função fgets.
Sintaxe
Esta função tem algumas diferenças relativamente às funções mencionadas no título.

Ora veja a sintaxe:
1 fgets(char *str, int n, FILE *stream);
Onde:
str – O apontador para um array de caracteres onde a \textit{string} será

armazenada.
n – O número máximo de caracteres a serem lidos (incluindo o delimitador final).
Geralmente é igual ao tamanho do array.
stream – O apontador para o ficheiro ou objeto donde serão lidos os caracteres.
Exemplo
Vejamos então um exemplo baseado no boletim de informação criado no artigo
anterior.
3
4 int main()
5 {
6 char nome[21],
7 apelido[21],
8 morada[51],
9 codigoPostal[11];
10
13 fgets(nome, 21, stdin);
14
16 fgets(apelido, 21, stdin);
17
19 fgets(morada, 51, stdin);
20
22 fgets(codigoPostal, 11, stdin);
23
28 return 0;
29 }</stdlib.h></stdio.h>
Remoção das Mudanças de Linha
Mas, se corrermos o código acima, iremos receber algo parecido com o seguinte:
1 O seu Cartão de Identificação:

2 Nome: Apelido
3 , Nome
4
5 Morada: Morada
6
7 Código Postal: CP
Como pode verificar, isto mostra que os arrays ficaram, também com os delimitadores
da mudança de linha (“\n”). Para removermos estes delimitadores podemos recorrer à
função “strtok”.
Sintaxe
Ora veja a sintaxe desta função.
1 strtok(char *str, const char *delim);
Onde:
str – O apontador para um array de caracteres onde a \textit{string} está

armazenada.
delim – O delimitador em questão ou uma constante que o contenha.
Exemplo
Então, para que o exemplo acima imprima corretamente o Bilhete de Informação,

devem ser adicionadas as seguintes linhas antes de ser imprimida qualquer
informação:
1 strtok(nome, "\n");
2 strtok(apelido, "\n");
3 strtok(morada, "\n");
4 strtok(codigoPostal, "\n");

Vamos Programar?

Enviado por

Dados do documento

Descrição original:

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

Vamos Programar?

Enviado por

Direitos autorais:

Formatos disponíveis

Vamos Programar?

– Introdução à Programação #25 - Pplware 12/11/15, 15:16

Vamos Programar? – Introdução à Programação #25

O mundo está constantemente a evoluir: desde o mais pequeno inseto à espécie

Este é o último artigo da saga Introdução à Programação. Neste episódio marcamos as

Relativamente à saga “Introdução à Programação”, este é o seu fim. Mas, na próxima

O mundo está constantemente a evoluir: desde o mais pequeno inseto à espécie

Na semana passada, começámos a saga Introdução à Programação a falar sobre

Atualizámos o artigo da semana passada para conter mais informação. A partir de

Visualize este vídeo no YouTube.

Quando declaramos uma variável ou constante, estamos a reservar um endereço da

O valor desse endereço passará a estar disponível através do nome da variável

Tal como o próprio nome indica, as constantes permite-nos armazenar

constante EMPRESA = "Pplware"; //Declaração da constante empresa e atribuição de valor.

EMPRESA = "A Minha Empresa"; //Erro: o valor da constante já foi definido

O nome das constantes é, normalmente, escrito em letras maiúsculas. Isto é apenas

Ao contrário das constantes, podemos alterar o valor das variáveis a qualquer

temaAtual = "Constantes"; //Declaração da variável "temaAtual" e atribuição de um valor

Nas variáveis seguimos o padrão CamelCase, mais precisamente, o

Não pode começar com números;

Tipos de variáveis e constantes

Nas próximas semanas abordaremos os tipos existentes na linguagem que vamos

Como podem ver na imagem acima, os “principais” tipos de constantes e variáveis

int de “integer number” ou número inteiro: 5, -5, 22554, -515984512;

Como já referi, existem variações de linguagem para linguagem e quando começarmos

O mundo está constantemente a evoluir: desde o mais pequeno inseto à espécie

Visualize este vídeo no Youtube

O conceito linguagem de programação ainda não foi abordado. Antes de continuar, é

Uma linguagem de programação é uma forma padronizada para comunicar

Todas as linguagens de programação têm várias características dentro delas

Cada linguagem de programação pode adoptar um ou mais paradigmas de

O paradigma imperativo concentra-se num estado (que são as variáveis) e ações

Exemplos (de linguagens de programação imperativas) : C, Java, C#, Pascal.

O paradigma procedimental permite a reutilização de código sem o copiar através da

Uma linguagem de programação estruturada é aquela em que todos os programas

Este é um exemplo de uma sequência. Em muitas linguagens de programação, os

Acordar; Vestir; Tomar o pequeno-almoço; Ir trabalhar;

A utilização do ponto e vírgula é, normalmente, obrigatória quando existem várias

Neste tipo de estrutura, um determinado trecho de código é executado ou não

O exemplo abaixo descreve a condição/decisão “se Acordar, vou Trabalhar, caso

O pseudocódigo acima já não está em português e já se assemelha ao que

Agora, e novamente relacionado com a decisão, repare que o trecho de código

case "Dor de cabeça"

Ou seja, pode ler da seguinte forma: fazer x enquanto y.

Enquanto estiver a Dormir, não me vou Vestir.

Ou seja, enquanto acontece algo, faço outra coisa.

Lavo os dentes 20 vezes.

for ( i = 0; i < 20; i++ )

Para cada dente, lavo-o muito bem.

for each "dente" in "boca"

O Paradigma Declarativo contrasta com o Imperativo pois é capaz de expressar a

O Paradigma Funcional engloba todas as linguagens de programação que utilizam

Exemplos: Matlab, Wolfram Language/Mathmatica/M, B.

Paradigma Orientado a Objetos

A Programação Orientada a Objetos permite a criação de objetos com base

Exemplos: Java, C++, C#, PHP.

Os paradigmas de programação não se limitam aos 6 (seis) apresentados pois existem

Agradeço à Ana Narciso pela disponibilização de alguns exemplos utilizados na secção

Uma breve história sobre C

O mundo está constantemente a evoluir: desde o mais pequeno inseto à espécie

Visualize este vídeo no Youtube

Antes de continuar, deve conhecer a história da linguagem de programação que

C – Uma pequena grande história