Manual Do Docente

Departamento de
informática
PROGRAMAÇÃO IMPERATIVA EM C
_________________________
Moçambique ______________________
Programação Imperativa
Indicação de ícones
Os ícones servem como elementos gráficos utilizados para facilitar a organização e a leitura
do Texto. Abaixo indicamos a legenda e a descrição da função de cada um deles.
Fonte Tipo de icone Significado
Atenção: indica pontos de maior relevância no texto
Saiba mais: oferece novas informações que enriquecem o

assunto ou “curiosidades” e notícias recentes relacionadas
ao tema estudado. Não indicar simplesmente livros,
INSTITUTO
filmes, links, etc. Oriente os estudantes sobre o que vão
FEDERAL
encontrar no material indicado.
FARROUPIL
Mídias Integradas: sempre que se desejar que os
HA. Manual
estudantes desenvolvam atividades empregando
para a
diferentes mídias: vídeos, filmes, jornais, ambiente AVEA,
elaboração
sites e outras
de apostilas;
Versão 3.0
12/Dez/12 Glossário: indica a definição de um termo, palavra ou
expressão utilizada no texto
Atividades de aprendizagem: apresenta atividades em

diferentes níveis de aprendizagem para que o estudante
possa realizá-las e conferir o seu domínio do tema
estudado
“Qualidade do
Comprometimento Resistência, trabalho” “Aprender através
COMMONW / da experiência”
EALTH of perseverança (excelência/
perseverança Auto-avaliação autenticidade) Exemplo / Estudo
LEARNING Actividade de caso
(COL) Avaliação / Teste
Paz/harmonia
Debate Unidade/relações Vigilância / “Eu mudo ou
humanas preocupação transformo a minha
Actividade de grupo Tome Nota! vida”
Objectivos
“Pronto a enfrentar as Apoio /

[Ajuda-me] deixa-me “Nó da sabedoria”
vicissitudes da vida” encorajamento
ajudar-te” Terminologia
Dica
Leitura
(fortitude /
preparação)
Reflexão
Escola Superior Técnica - ESTEC 1

Índice
Tópico Página
CONTEÚDO
Conteúdo ........................................................................................................................
Nota de Apresentação .....................................................................................................
UNIDADE TEMÁTICA I: Introdução ao Paradigma de Programação Imperativa .............
AULA 1: LINGUAGENS DE PROGRAMAÇÃO................................................................
Objectivo geral da aula/Meta ...........................................................................................
1.1. Linguagem de programação .................................................................................
1.2. Programação ........................................................................................................
1.3. Programa ..............................................................................................................
Actividade 1 ...............................................................................................................
AULA 2: Introdução ao paradigma de Programação Imperativa ......................................
Conteúdos da aula ............................................................. Error! Bookmark not defin
2.1. Paradigma de Programação Imperativo ................................................................
AULA 3: CICLO DE DESENVOLVIMENTO DE UMA APLICAÇÃO .................................
Conteúdos da aula ............................................................... Error! Bookmark not defin
3.1. Resolução de problemas ...................................................................................
3.2. Desenvolver um algoritmo .................................................................................
Início ...............................................................................................................................
AULA 4: • Filosofia da Programação em C .................................................................
Conteúdos da aula ............................................................... Error! Bookmark not defin
4.1. Historial da Linguagem C ..................................................................................
4.2. Aplicações desenhadas usando a linguagem c .................................................
4.3. Comparação de C com outras linguagens imperativas ......................................
4.4. Comparação de c com c++ ...............................................................................
Leituras Obrigatórias .......................................................................................................
Textos: ............................................................................................................................
UNIDADE TEMÁTICA II: Introdução ao Paradigma de Programação Imperativa ............
AULA 5:introdução a linguagem c – estrutura de um programa.......................................

AULA 6: Constantes, Palavras Reservadas, variavam e tipo de dados em linguagem
C .....................................................................................................................................
6.1. Conjunto de caracteres .....................................................................................
6.2. Constantes ........................................................................................................
6.2.1. Constantes inteiro ..........................................................................................
6.2.2. Constantes decimais / ponto flotuante ...........................................................
6.2.3. Constante caractere ......................................................................................
6.3. Palavras reservadas..........................................................................................
6.4. VARIÁVEIS EM LINGUAGEM C .......................................................................
6.5. Tipo de Dados ...................................................................................................
6.5.1. Tipo de dados definidos pelo utilizador ..........................................................
AULA 7: conversão do tipo, operadores e expressões em linguagem C .........................
CONTEÚDOS DA AULA .................................................................................................
Textos: ............................................................................................................................
UNIDADE TEMÁTICA III: Instruções de controlo e Funções ...........................................
AULA 8: estrutura de controlo- estrutura de decisão .......................................................
Conteúdo da aula ............................................................................................................
AULA 9: estrutura de controlo- estrutura de Repetição ou laço .......................................
Conteúdo da aula ............................................................................................................
AULA 10: funções: ..........................................................................................................
Conteúdo da aula ............................................................................................................
10.1. O que é uma função ......................................................................................
10.2. Classificação das funções em C ....................................................................
AULA 11: funções (variantes, tipos de variáveis) :...........................................................
11.1. Variantes de Funções ....................................................................................
11.2. Passagem de argumentos para funções ........................................................
11.3.1. Chamada por valor .....................................................................................
11.3.2. Chamada por referência.............................................................................

Textos: ............................................................................................................................
UNIDADE TEMÁTICA IV: matrizes, ponteiros, Strings uniões e estruturas .....................
AULA 12: Vector, matrizes e strings ................................................................................
12.1. Vector ou Array ...................................................................................................
12.1.1. Definindo um vector .........................................................................................
12.1.2. Passagem de um array a uma função ..............................................................
12.2. Matriz ..................................................................................................................
AULA 13: Ponteiros ou Apontadores ...............................................................................
Conteúdo da aula ............................................................................................................
AULA 14: Ponteiros e matrizes, e vectores de ponteiros ............................................
AULA 15: Estruturas e uniões ....................................................................................
Textos: ............................................................................................................................
UNIDADE TEMÁTICA III: Tratamento de Ficheiros .........................................................
AULA 16: Gestão de ficheiros ....................................................................................
Textos: ............................................................................................................................
UNIDADE TEMÁTICA V:Teste, depuração e documentação de programa .....................
AULA 17: Erros de programas, testes e Depuração de Programa ...................................
Conteúdo da aula ............................................................................................................
17.2. Depuração ..........................................................................................................
17.3. Documentação de programa ..............................................................................
Textos: ............................................................................................................................
Referências bibliográficos ............................................................................................

NOTA DE APRESENTAÇÃO
Estimado(a)
O Manuel de programação imperativa em C foi especialmente preparado para si. Os

conteúdos programáticos nele contido fazem parte do Programa de Licenciatura em
Informática ministrado pela Escola superior Técnica da Universidade Pedagógica.
O objectivo principal deste material é proceder à orientação e acompanhamento do

autoestudos durante o Processo de Ensino-Aprendizagem. Para isso, os conteúdos foram
organizados por forma a garantir a sua auto-aprendizagem.
A sequência deste guia orienta-se por notas introdutórias em cada unidade temática,
objectivos gerais e objectivos específicos de cada unidade, a menção de leituras
obrigatórias, leituras complementares (para saber mais e curiosidades), glossários
ou pequenos dicionários, actividades, exercícios de aplicação ou fichas de trabalho,
bem como as respectivas guias de correcção.
De um modo geral, é esta a proposta apresentada para esta disciplina. A expectativa é que
o estudante seja um verdadeiro centro do processo de aprendizagem e que contribua numa
efectiva produção do conhecimento, por forma a ser um interlocutor válido no complexo e
longo processo de produção do conhecimento, sua aprendizagem e disseminação, de
modo a ser capaz de lidar com os diversos problemas enfrentados na vida.
O professor responsável pela produção deste material sente-se honrado em providenciá-lo

para si, e guarda muita expectativa em torno da sua utilidade prática durante o processo de
aprendizagem. Por isso, espera que este material seja um autêntico instrumento
interlocutor e que inspire a busca de soluções para os diversos problemas encarados na
vida académica e social.
Utilize também este material para servir de base para a sua interacção sincrónica e
anacrónica com outros estudantes e docentes, de modo a gerar situações de maior
abertura ao debate e discussão em prol da aprendizagem pretendida. Leia-o sempre,

discuta todas as questões que lhe parecerem interessantes, levante questões, aprofunde
permanentemente a sua reflexão, encoraje todos os colegas do grupo a fazerem o mesmo.
Boas vindas e votos de bom trabalho!

O autor
José Luís Sambo tem Diploma em Estudos Avançados em Ciências e Tecnologias Web
pela Universidade Aberta de Portugal (2018), é Mestre em Tecnologias de Informação
desde 2012 pela Punjab Technical Educational da India e Licenciado em Informática
Educacional (2008) pela Universidade de Pedagógica (Moçambique). Estudante de
Doutoramento em Ciências e Tecnologia Web pela Universidade Aberta de Portugal.
Docente na Universidade Pedagógica – Escola Superior Técnica, Departamento de

Informática desde 2007, onde leccionou disciplinas de Programação (C, C++, Java, C#,
Web, Visual Basic), Inteligência Artificial, Laboratórios de Informática (Programação), Base
de Dados, Serviços de Redes e Tecnologias na Educação.
De 2013 a 2016 foi Chefe de Departamento de Assistência Técnica e Redes do Centro de

Informática da Universidade Pedagógica – CIUP.
De 2016 a 2019 foi Chefe de Departamento de Informática da Escola Superior Técnica.
Desde 2019 é Director Adjunto para Pós-Graduação, Pesquisa e Extensão na Escola
Superior Técnica da Universidade Pedagógica.

UNIDADE TEMÁTICA I: INTRODUÇÃO AO P ARADIGMA DE PROGRAMAÇÃO

IMPERATIVA
Introdução
Esta unidade serve como um ponto de partida sobre os princípios de

programação. A unidade é constituída por quatro aulas das quais iremos
discutir conceitos relacionados com as linguagens de programação e sua
classificação, e filosofias da linguagem de programação em C e pro fim uma
breve comparação entre as linguagens C e C++. Nessas discussão voce irá
compreender duma forma sumária sobre o processo de desenvolvimento de
aplicações. Esse processo será sequenciado de seguinte forma:
 Definição de Linguagens de Programação;

 Definição e classificação de Paradigmas de Programação;
 Explicação sobre o ciclo de desenvolvimento de aplicações e;
 Introdução a filosofia de programação em C.
No fim desta unidade esperamos que voce esteja em condições de:
• Definir o que é uma linguegem de programação;
• Discutir sobre diferentes tipos de paradigmas de programação e

descrimina-los;
• Explicar a relação entre Paradigma e Linguagem de

Objectivos
Programação;
• Descrer o processo de desenvolvimento de aplicação e;
• Compreender a filosofia da linguagem C.

1. LIÇÃO 1:

LINGUAGENS DE PROGRAMAÇÃO: Definição e Classificação
1.1. Introdução da aula
O computador é um instrumento indispensável para o Homem na actualidade, mas que ele

por si só nào é capaz de realizar nenhuma acção em benefício do mesmo. Há sempre uma
necessidade de o tornar inteligente de formas a realizar tarefas específicas. A lógica por de
trás do computador é construida de uma forma lógica nas mentes humanas e transferida a
ele. Desta forma não teriamos como saber instruí-lo sem conhecer a génese da linguagem
e a sua evolução. Assim, iniciamos este módulo definindo a linguagem de programação e a
sua respectiva classificação.
OBJECTIVO GERAL
1. Discutir os principais aspectos sobre linguagens de programação.

2. Conhecer e compreender a história e evolução das linguagens de programação
Objectivos específicos
Espera-se que com esta aula o aluno seja capaz de:
Objectivos − Definir uma linguagem de programação e a sua importancia;

− Os conceitos básicos da linguagem;
− Classificar as linguagens quanto ao tipo;
− Definir o que é a programação e ;
− Classificar as linguagens de programação quanto as gerações;
− Definir o que é um programa;
1.2. Linguagem de programação
Os computadores são máquinas que entendem apenas o código binário ou por outras 0s e 1s.
Todas as instruções que são dadas são convertidos ou traduzidos em sinais eléctricos que
significam basicamente 1 para ligado ou 0 para desligado. Um exemplo simples é o da forma de
funcionamento de uma lâmpada. O zero representa o interruptor desligado e 1 representa
interruptor ligado.
Observando, irá verificar que há uma quantidade finita de combinações que podem ser feitas.

Face a essa situação imaginemos um programador que pretenda desenvolver um

simples web site utilizando essa combinação. O que aconteceria com ele?
De certeza já podes imaginar que essa seria uma tarefa extremamente complicada, cansativa e
demorada. Então as linguagens de programação surgem para resolver essa complicação, criando
uma linguagem em comum entre o computador e o programador.
Entre a máquina e o programador está um intérprete ou compilador, mas que apenas

entende binários e do lado do programador temos a linguagem de programação do alto
nível que tem expressão em inglês e operações matemática do domínio do programador.
E com esta, pode-se introduzir comandos como leia, imprima, escreva em inglês ao invés
de inserir instruções usando combinações binárias do tipo 0101011110101.
Portanto, pode-se considerar que uma linguagem de programação serve como meio de
comunicação entre o indivíduo que deseja resolver um determinado problema e o
computador escolhido para ajudá-lo na solução.
A Linguagens de Programação deve fazer a ligação entre o pensamento humano (muitas

vezes de natureza não estruturada) e a precisão requerida para o processamento pela
máquina. Deste modo, pode-se considerar que a Linguagem de programação tem como
objectivo auxiliar o programador no processo de desenvolvimento de software, e isso inclui
auxílio no Projecto, Implementação, Teste, Verificação e Manutenção do software.
Assim podemos considerar de uma forma sumária que Uma linguagem de programação é
um sistema de escrita formal para enunciar a execução de operações no computador. Esta
é composto por duas partes fundamentais a considerar:
● Terminologia que é um conjunto de termos, palavras e sinais, que

Sintaxe é um conjunto de regras assumem determinados significados (semântica) e.
que define a forma de uma
linguagem, estabelecendo como
são compostas as suas
linguagem, estabelecendo como ● Conjunto de regras que estipulam o uso correcto dos termos para
são compostas as suas
estruturas básicas (palavras). construir expressões válidas (sintaxe).
A Semântica descreve o
significado de construções
sintácticas válidas.

Como podes ter percebido até então, qual seria a utilidade de linguagens de
programação? Quantas linguagens de programação imaginas que existem
actualmente e de que forma funcionam? Discuta.
Olhando para o que discutimos anteriormente de certeza chegou a conclusão de que as

linguagens de programação têm como finalidade fundamental proporcionarem meios para a
resolução de problemas, mediante um processamento computarizado.
Quanto a quantidade de linguagens existentes na actualidade dificilmente chegou a

conclusão acertada. Na verdade são inúmeras que é dificil quantificá-las. Mas fica a ideia
de que existem várias linguagens de programação, cada uma com suas características
próprias. Como podes ver no exemplo 1 e figura 1.
Exemplos 1: Payton, Java, Pascal, Clipper, C, Visual Basic, Delphi, etc.
Figura 1: Linguagens de Programação Fonte: Making Games
Existem linguagens compiladas, Interpretadas, do alto nível e do baixo nível.
Como vimos, as linguagens são várias e cada uma apresenta as suas características. Uma
das características que diferencia um grupo de linguagens do outro está relacionada com
os tipos de linguagens. Basicamente existem duas categorias de linguagens de
programação de acordo com a forma de execução. As compiladas e interpreitadas.
1.2.1. As Linguagens Compiladas
São as linguagens que passam por um processo de tradução (compilação), sendo

transformados para um segundo código (código de maquina) compreensível ao
processador, o programa responsável por essa tradução é chamado de compilador.
Exemplo 2: C, Java, C#, C++, Pascal, Delphi, Cobol, entre outras.
1.2.2. Linguagens interpretadas

São linguagens onde o código fonte da mesma é executado por um outro programa de
computador chamado interpretador, que em seguida é executado pelo sistema operacional
ou processador. Mesmo que um código em uma linguagem passe pelo processo de
compilação, a linguagem pode ser considerada interpretada, se o programa resultante não
for executado directamente pelo sistema operacional ou processador. Exemplo: HTML,
Java, C#, BASIC, Logo, PHP entre outras.
Note que as linguagens interpretadas e compiladas também podem ser do alto ou baixo
nível.
As linguagens do alto nivel são linguagens com um nível de abstracção relativamente

elevado, longe do código de máquina e mais próximo à linguagem humana. Desse modo,
as linguagens de alto nível não estão directamente relacionadas à arquitectura do
computador.
O programador de uma linguagem de alto nível não precisa conhecer características do

processador, como instruções e registradores. Essas características são abstraídas na
linguagem de alto nível. Exemplo Pascal, C, C++, Java, CSharp, COBOL, D,J Objective-C,
etc.;
As do baixo nível tratam-se de linguagens de programação que compreendem as

características da arquitectura do computador.
Assim, utiliza-se somente instruções do processador, para isso é necessário conhecer os

registradores da máquina. Nesse sentido, as linguagens de baixo nível estão directamente
relacionadas com a arquitectura do computador.
Exemplo é a linguagem Assembly, que trabalha directamente com os registradores do

processador, manipulando dados.
As Linguagens de programação do alto nível podem ser interpretadas assim como

compiladas. As linguagens PHP, HTML, JavaScript como como vimos nos exemplos são
interpretados e o Java, C#, C entre outras são compiladas.
1.3. Programação

A programação pode ser definida como o acto de utilizar uma linguagem de programação
para escrever instruções que podem ser executadas pelo computador com o objectivo de
resolver problemas, aplicando correctamente a sintaxe e a semântica da linguagem.
Centenas de linguagens de programação têm sido desenvolvidas e algumas estão em utilização
enquanto outras caíram em desuso. O desenvolvimento da linguagem de programação já percorreu
um longo caminho, assim, tem uma longa história, desde Prolog, Fortran, C, Visual Basic.Net, até
Rust e Swift.
Desde o surgimento das linguagens de programação, houve mudanças na

tecnologia. Será que as linguagens acompanharam essas etapas de transformação?
A resposta é sim. As linguagens foram acompanhando a evolução tecnológica. Para sustentar a

nossa afirmação iremos nos socorrer ao (Grune, 2000), que apresenta uma classificação em
gerações de forma diferente, enfatizando mais o aspecto da aplicação. Ele apresenta as gerações
da linguagens de programação em cinco que abaixo enumeramos e explicamos.
• PRIMEIRA GERAÇÃO - linguagem de máquina.
Os primeiros computadores eram programados em linguagem de máquina, em notação binária. A

instrução 0010 0001 0110 1100, quando executada, realiza a soma:
Figura 2: Instrução usando linguagem máquina
Cada instrução de máquina é, em geral, formada por um código de

operação e um ou dois endereços de registradores ou de memória;
As linguagens de máquina permitem a Comunicação directa com o

computador em termos de “bits”, registradores e operações de
máquina bastante primitivas;
Um programa em linguagem de máquina é uma sequência de zeros e

uns, a programação de um algoritmo complexo usando esse tipo de
linguagem é complexa, cansativa e fortemente sujeita a erros.
• SEGUNDA GERAÇÃO - linguagens de montagem (Assembly).
Compreende as linguagens simbólicas ou de montagem (Assembly), projectadas para minimizar as

dificuldades da programação em notação binária;
Códigos de operação e endereços binários foram substituídos por mnemónicos.

Exemplo de uma expressão Sua tradução em Assembly
• TERCEIRA GERAÇÃO - Linguagens Imperativas ou procedimentais Surgem na década 60.
Estas gerações de linguagens algumas são de propósito geral (ADA, COBOL, C) e outras são do
propósito específico, servindo apenas para solucionar problemas científicos, como o exemplo de
FORTRAN, PASCAL e ALGOL;
as linguagens procedimentais, um programa especifica um procedimento, isto é, uma sequência de

passos a serem seguidos para solucionar um problema.
• QUARTA GERAÇÃO – Linguagens Orientadas a Aplicação
As linguagens de 3ª geração foram projectadas para profissionais de processamento de dados e

não para usuários finais. A depuração de programas escritos nessas linguagens consome tempo, e
a modificação de sistemas complexos é relativamente difícil. As linguagens de 4ª geração foram
projectadas em resposta a esses problemas.
Os programas escritos em linguagens de 4ª geração necessitam de menor número de linhas de

código do que os programas correspondentes codificados em linguagens de programação
convencionais.
Exemplo de algumas linguagens dessa geração: LOTUS 1-2-3, SQL, SUPERCALC, VISICALC,
DATATRIEVE, VHML, PHP
• QUINTA GERAÇÃO - Linguagens voltadas a Inteligência artificial como as linguagens

lógicas (Prolog) e as linguagens funcionais (Lisp).
Facilitam a representação do conhecimento que é essencial para a simulação de comportamentos

inteligentes.
O termo 5ª geração refere-se, especialmente, a sistemas que usam mecanismos da área de

inteligência artificial (IA), ou seja, sistemas especialistas, processadores de língua natural e
sistemas com bases de conhecimento.
Um sistema de 5ª geração armazena conhecimento complexo de modo que a máquina pode obter
inferências a partir da informação codificada.

1.4. Programa
Um programa, no contexto das linguagens de programação, é um conjunto de

“frases”, que utilizam os termos e as regras de determinada linguagem de
programação, com vista a concretizar certos objectivos. Para saber mais
sobre
Normalmente, um programa, é a tradução de um algoritmo numa linguagem de programação,
Programa e
programação, para que possa ser entendido e executado pelo computador. Por suaLinguagens de
vez um algoritmo é uma sequência ordenada, e não ambígua, de passos que levam Programação
consula
à solução de um dado problema Sebesta, R. W.
(2009). Conceitos
Um programa é uma sequência de instruções executadas passo a passo parade linguagens de
resolver um problema particular e fazer com que o computador realize essa tarefa programação.
Bookman
específica. Editora.
Exemplo de um programa de Computador
Como podemos ver no exemplo ao lado, estamos

diante de um programa na linguagem de
Programação em C.
É um programa simples que demostra o
funcionamento do ciclo de repetição com recurso a
instrução while que traduzindo para o português
significa enquanto.
Resumo
Nesta aula definimos o que é uma linguagem de programação e destacamos a sua
utilidade na resolução de problemas, tecemos algumas considerações sobre alguns
conceitos fundamentais sobre as linguagens de programação como sintaxe,
semântica. Classificamos as linguagens quanto ao tipo, onde destacamos dois tipos
de linguagens, as compiladas e interpreutadas. Após termos conhecimento sobre as
linguagens de programação, duma forma suscita definimos o que é a programação e
navegamos ao longo do tempo da sua evolução e por fim debriçamos sobre o
conceito de programação

Actividade 1
Esta actividade, pode ser realizada individualmente ou em grupo, antes de realizar leia
atentamente o material disponibilizado. Esta actividade é sobre a aula acabada de concluir.
1. De acordo com o que já foi apresentado sobre a evolução da linguagem de

programação, e discuta sobre as suas gerações.
2. Porque é importante conhecer a história da programação?
3. Faça uma resenha sobre a semântica, sintaxe e mnemónica.
4. Até agora, estás ciente de que existem várias de linguagens de programação.
Algumas são amplamente utilizadas na indústria actualmente e algumas nunca são
mencionadas e outros estão a ser utilizados por pequenos grupos de programadores.
Por que será que a algumas dessas linguagens ganharam mais popularidade do que
outras?
5. O que entendes por programa?

2. AULA 2: INTRODUÇÃO AO PARADIGMA DE PROGRAMAÇÃO IMPERATIVA
2.1. Introdução
Em informática programação imperativa é um paradigma de programação que descreve a

computação como acções, enunciados ou comandos que mudam o estado de um
programa. Muito parecido com o comportamento imperativo das linguagens naturais que
expressam ordens, programas imperativos são uma sequência de comandos para o
computador executar. Nesta aula iremos discutir as principais características do paradigma
imperativo.
Objectivo geral
• Discutir sobre paradigma de programação com foco no paradigma Imperativa;
Objectivos específicos da aula

No fim desta aula o aluno deve ser capaz de:
• Classificar as linguagens de acordo com o seu paradigma;

• Descrever o funcionamento das linguagens do Paradigma Imperativo;
• Mencionar as principais características do paradigma imperativo;
Objectivos
• Diferenciar as linguagens imperativas das restantes usando exemplos e;
• Destacar as vantagens e desvantagens do paradigma imperativo em relação a
outras paradigmas
2.2. Paradigma de Programação Imperativo

O que entendes por paradigma? Existe uma relação entre paradigma e paradigma de
programação? Podemos classificar as linguagens de acordo com os paradigmas de
programação?
Duma forma generalizada podemos considerar Paradigma como um modelo

interpretativo (ou conceitualização) de uma realidade.
Para saber mais Sendo um paradigma um modelo, o Paradigma de Programação relaciona-se ao
sobre paradigmas de
programação: paradigma, pois fornece e determina a visão que o programador possui sobre a
estruturação e execução do programa. A forma como uma linguagem organiza-se
Consulte: Sebesta,
R. W. (2009). desde a sintaxe, semântica e pragmática permite nos que possamos classifica-las.
Conceitos de Desta forma o estilo de programação pode nos ajudar a classificar as linguagens.
linguagens de De diferentes paradigmas de programação por exemplo, podemos destacar as
programação.
Bookman Editora. seguintes linguagens:
• Paradigma Imperativo (C, C++, Pascal)

• Paradigma Funcional (ML, LISP, Haskell)
• Paradigma Orientado a Objeto (C++, Java)
• Paradigma Concorrente (ADA, Java)
• Paradigma Orientado a Aspecto (AspectJ)
• Paradigma de Programação Lógica (PROLOG)
2.3. Funcionamento das linguagens do Paradigma Imperativo
Discuta sobre o funcionamento das linguagens do paradigma imperativo.
O fundamento da Programação Imperativa é o conceito de Máquina de Turing,

que nada mais, é uma abstracção matemática que corresponde ao conjunto de funções
computáveis. A sua criação foi influenciada pela arquitectura de computadores Von
Neuman, onde programas e dados são armazenados na mesma memória, como pode ser
visto na figura 3.
Figura 3: Arquitectura do Von Neuman
Como pode ser visto na figura 3, o modelo imperativo de programação, é o mais antigo de
todos, baseia-se no modo de funcionamento do computador. Isto é reflectido na execução
sequencial baseada em comandos e no armazenamento de dados alterável, conceitos que
são baseados na maneira pela qual computadores executam programas a nível de
linguagem de máquina.
Este paradigma foi predominante nas Linguagens de Programação, pois tais linguagens
são mais fáceis de traduzir para uma forma adequada para execução na máquina. Um
programa desenvolvido a partir deste modelo, por exemplo nas linguagens C, C++,
PASCAL, consiste em uma sequência de modificações no armazenamento do computador.
As Linguagens Imperativas são caracterizadas por três conceitos: variáveis, atribuições e

sequência. O estado de um programa imperativo é mantido em variáveis de programa que
são associadas com localizações de memória que correspondem a um endereço e um
valor de armazenamento. O valor da variável pode ser acedido directa ou indirectamente, e
pode ser alterado através de um comando de atribuição.

O comando de atribuição introduz uma dependência de ordem no programa: o valor de

uma variável é diferente antes e depois de um comando de atribuição. Além disso, o
significado de um programa depende da ordem na qual os comandos são escritos e
executados. Já as funções de linguagens de programação imperativas são descritas como
algoritmos que especificam como processar um intervalo de valores, a partir de um valor de
domínio, com uma série de passos prescritos.
A repetição, ou laço, é usada extensivamente para processar os valores desejados. Laços

são usados para varrer uma sequência de localizações de memória tal como vectores, ou
para acumular um valor em uma variável específica.
2.4. Mencionar as principais características do paradigma imperativo
Enumere as principais características das linguagens do paradigma

Imperativo
Certamente, se prestou atenção na actividade sobre o funcionamento das

linguagens do paradigma de programação Imperativo deve ter concluído que as
principais características são:
 As variáveis, que modelam as células de memória;
 Comandos de atribuição, que são baseados nas operações de transferência
dos dados e instruções;
 A execução sequencial de instruções;
 E a forma interactiva de repetição, que é o método mais eficiente desta
arquitectura;
 A repetição (laços) é utilizada extensivamente para computar valores
desejados. Laços são usados para varrer um vector ou acumular valores
numa variável.
 As linguagens imperativas têm sido chamadas de orientadas a estado ou
orientadas à atribuição.
2.5. Principais linguagens imperativas usando exemplos

Através do quadro comparativo (tabela 1) apresentamos as principais linguagens e suas
características quanto ao valor e tipo, Expressão, Comandos e sequência, declarações,
procedimentos e funções. As principais linguagens deste paradigma são FORTRAN,
PASCAL, C E ADA.

Tabela 1: exemplos de linguagens de programação baseadas no modelo imperativo
FORTRAN PASCAL
- tipos: integer, real, double - tipos: simples: boolean, integer, char, real;
precision, complex, logical; vetor: estruturados: array, file, record, set
dimension - expressões:
- valores e tipos <nome> (dim1, dim2, dim3), real, integer boolean: and, or, not, xor
- expressões - constantes lógicas: .true., .false. integer: +, -, *, div, mod, =, >=, <>. abs, sqr,
- operadores: **, *, /, +, -, .ge., .gt., .le., trunc, round
.lt., .eq., .ne., .not., .and., .or. string: var a: string; a = ‘abc’; file:
type arq = file of integer;
if (<exp>) then - comandos simples: write, writeln, read, clrscr,
… gotoxy, delay, readkey, upcase
end if if-then, if-then-else case
if (<exp>) <exp> of
… case <op1>:
else if ( ) then case <op2>:
- comandos e … else
seqüências else end
… for x := <inic> to|downto <fim> do while
end if <cond> do
begin
- comandos I/O: open, close, read, ...
write, print, rewind, endfile
end;
- goto, continue, pause, stop
- declaração var.: <tipo> <id> - declaração var.: var <id>: <tipo>;
- funções: function <id> (<parâm.>) - procedimentos e funções:
- proc.: procedure <id> (<p.>) procedure <id> (<parâm.>); function <id>
- declarações (<parâm.>): <tipo>;
- procediment versões anteriores a FORTRAN 90: não é case sensitive
os e funções somente letras maiúsculas; outras
versões
traduzem para maiúsculas
durante a compilação
C ADA
- valores e - tipos: char, int, float, double, struct, - tipos:

tipos union array: <id> array(x..y) of <tipo>
- expressões - operadores: -, +, *, /x, %, ++, >, >=, =, integer, natural, positive, character,
!=, &&, ||, !, & boolean, string: type string is array(x..y)
bit a bit: &, |, ^, ~, >>, << of character; float
- operadores: =, /=, >, >=, +, -, abs, **,
and, or, xor, not
- comandos if (<exp.>) if <cond> then case <exp> is

e <comandos> else elsif <cont> then <alt. 1>
seqüências <comandos> else <alt. 2>
for (inic; cond; incremento) end if; end case;
switch (<exp>){
case <op1>: ...; when <lista escolha> => <com.> when
break; case <op2>: <others> => <comandos>
...; break; default:
...; while <cond.> loop
} <comandos> end
while (<cond.>){ loop;
....;} do for <id> in <interv> loop
.... <comandos> end
while (<cond.>); loop

return <exp>, goto <tótulo>, break
- declarações - declaração var.: <tipo> - declaração var.: <id>: <tipo>;
- procedimentos <lista variáveis>; - procedimentos:
e funções - constantes: const <tipo> <id> = <valor>; procedure <id> (<parâm>) is
- funções: <tipo> <id> (<parâm>) - funções:
function <id> (<p.>) return <tipo>
é case sensitive
2.6. Destacar as vantagens e desvantagens do paradigma imperativo em relação a

outras paradigmas
Como pode ter visto ao longo da aula, as linguagens do paradigma imperativo pela forma
do seu funcionamento podem ser determinantes na escolha de uma linguagem para o uso
devido a algumas vantagens como:
 Eficiência (embute o modelo de Von Neuman);
 Mais fácil de traduzir para a linguagem de máquina;
 Paradigma dominante e bem estabelecido;
 Modelagem “Natural” de aplicações do mundo real;
 Muito flexível;
Para além das vantagens colocadas no paragrafo acima, podemos encontrar algumas das
características não desejadas como:
 Descrições demasiadamente operacionais;
 Focaliza o “como” e não o “quê”;
 Relacionamento indirecto com a E/S (indução a erros/estados).
Resumo
Nesta aula falamos dos paradigmas de programação e definimos como sendo um
estilo de programação que fornece uma determina visão ao programador sobre a
estruturação e execução do programa. Listamos possíveis paradigmas de
programação que dominaram o mercado e destacamos o paradigma imperativo.
Falamos do modelo computacional deste paradigma e apresentamos algumas
linguagens de programação deste paradigma que dominaram o mercado,
apresentando a sua filosofia de estruturação e por fim destacamos as suas
vantagens e desvantagens em comparação com outros modelos de programação.
apresentando a sua filosofia de estruturação e por fim destacamos as suas
vantagens e desvantagens em comparação com outros modelos de programação.
ACTIVIDADES 2

Nesta actividade, é requerido que leia sobre os paradigmas de programação e seus

modelos computacionais; observe as características, vantagens e desvantagens de cada
tipo, incluindo gerações de linguagens de programação. Depois de ler, escreva notas
breves para:
• Descrever as linguagens pertencentes ao paradigma Imperativo ou estruturado.

• Descrever as características das linguagens de programação de acordo com os seus
paradigmas.
• Descrever as características e modelos computacionais destes paradigmas.
Desafio em grupo:
Usando o MindMap façam um esquema de paradigmas existentes e liguem nas suas

possíveis linguagens de programação. Busquem subsídios na actividade 1.

3. AULA 3: CICLO DE DESENVOLVIMENTO DE UMA APLICAÇÃO
3.1. Introdução

imperativo.
Objectivo geral
• Discutir os principais aspectos sobre o desenvolvimento de aplicação;

• Compreender o processo básico de desenvolvimento de um programa

• Resolução de Problemas
• Definir o algoritmo e suas formas de representação
Objectivos
• Entender a necessidade de se utilizar uma linguagem formal para construir
algoritmos a serem interpretados por computadores.
• Compreender os conceitos de variáveis, constantes e tipos de dados
aplicados a algoritmos.
• Conhecer os conceitos de comandos de atribuição, entrada e saída de dados.
• Construir algoritmos.
3.1. Resolução de problemas

A concepção do programa envolve a forma de resolver o problema e é uma fase de
resolução de problemas que vem a seguir a fase de definição do problema. Trata-se de
uma forma de fornecer soluções de problemas através da aplicação de várias técnicas de
concepção, incluindo a modelação. Estas técnicas incluem a divisão do programa em
subprogramas. A prática de divisão de um programa em subprogramas é denominada de
modularização. A modularização, por outro lado, é um dos elementos básicos da
programação.

Seja qual for o tipo de problema que precisamos resolver, antes

devemos planificar cuidadosamente passos bem definidos, claros
e finitos. A esse conjunto de passos chamamos de algoritmo. No
Glossário
geral quando pretendemos transformar a solução de um problema
Depurar é o
para um meio computacional, devemos antes: processo de
1. Desenvolver o algoritmo; detenção e
fixação de erros
2. Escrever o programa; num programa.
3. Documentar o programa;
4. Testar e depurar o programa
Considere as quatro etapas de transformação de uma solução de um

problema para o mundo computacional, e discuta o que seria um
algoritmo, as formas de construção?
Analisando a questão podemos dizer que um algoritmo é um conjunto de passos gerados

pelo programador para ajudar a resolver um problema particular. Porque um algoritmo é
utilizado como uma ferramenta de projecto, deve, portanto, ser finito, claro, simples, preciso,
completo, eficaz e que permite a entrada e saída de dados.
Os algoritmos são independentes das linguagens de programação e podem

ser desenvolvidos usando três representações como: Fluxograma, Linguagem
Natural ou pseudocódigo.
Por sua vez, a sua construção pode obedecer duas formas:

A construção
(i) Sequencial e;
(ii) Condicionada.
Na construção sequencial os passos são escritos em uma ordem específica, dando a

ordem de execução do passo subsequente após o término da primeira.

Exemplo de construção sequencial
Figura 4: Construção Sequencial
Portanto, pudemos ver que a execução da próxima instrução inicia apenas após a
execução actual. Neste tipo de construção é quase obrigatória a execução de todas as
instruções do programa e não há saltos nem repetição.
A Construção condicional. Significa que em algum ponto de execução de algumas

instruções do programa são executados tendo em conta a avaliação de uma determinada
condição. A construção condicional pode ser representada por duas formas básicas: A
Selecção e a Repetição
A Selecção inclui instruções if…else e A repetição inclui as instruções for, do …

switch…case. while e while.
Figura 5: Construção Condicional Selecção Figura 6: Construção Condicional Repetição
Lembre-se que definimos um algoritmo como um conjunto finito de instruções,

o que significa que eles têm um começo e um fim.
O algoritmo normalmente obedece três etapas: A entrada (dados de entrada
do algoritmo), o processamento (os procedimentos utilizados para chegar ao
resultado final) e a saída (dados já processados).

O exemplo abaixo representa um algoritmos que calcula a média de três notas de um

estudante obedecendo uma construção sequencial.
Exemplo de um algoritmo
Para mais informações
sobre outras formas de
representação de
algoritmos veja:
https://pt.slideshare.net/
elainececiliagatto/aed-
formas-de-representao-
de-algoritmos
Figura 7: Algoritmo de cálculo de média:
Imagine que queiras criar um algoritmo para resolver problemas do mundo real. De
que formas podes representar a solução?
Dentre as várias formas de representação do algoritmos de certeza encontrou quatro

formas. O fluxograma, a linguagem natural, o pseudocódigo e linguagens de programação.
Mas por enquanto vamos discutir duas formas fundamentais nomeadamente:
• O fluxograma e;
• Pseudocódigo.
3.1.1. - Fluxograma (diagrama de fluxo)
Um fluxograma (diagrama de bloco) é uma forma de representar um algoritmo através de

símbolos (representação gráfica). Uma vantagem desta representação é a simplicidade que
os elementos gráficos proporcionam para o entendimento, e uma desvantagem é a
necessidade de aprender a sua simbologia. São os mais indicados para representar
algoritmos, já que muitas vezes os símbolos substituem várias palavras.

Serão apresentados alguns exemplos e posteriormente as sugestões de actividades.
A seguir serão apresentados os símbolos mais utilizados nos fluxogramas:
Figura 8: Fluxograma
Exemplo de uso do fluxograma:
Figura 9: Representação do algoritmo em fluxograma
A segunda forma de representação que merece destaque na nossa aula é o pseodocódigo.
3.1.2. O Pseudocódigo

É uma forma de representação de algoritmos que se assemelha ao modo como os

programas são escritos. Esta forma permite que os algoritmos neles representados possam
ser traduzidos, quase que directamente, para uma linguagem de programação.
Forma Geral do Pseudocódigo.

Algoritmo <nome_do_algoritmo>
<Declaração de variáveis>
<subalgoritmos>
INÍCIO
<corpo do algoritmo>
Fim.
Tal como fluxograma, quando desenhamos um algoritmo representando em

Pseudocódigo, devemos conhecer alguns conceitos básicos para o
efeito.
Para entender a construção de algoritmos nessas representações, vamos iniciar estudando

alguns conceitos básicos como variáveis, constantes e operadores.
3.1.2.1. Variáveis
O primeiro passo para que um programa seja executado em um computador é o
carregamento desse programa para a memória. A memória é utilizada para armazenar
tanto as instruções dos programas quanto os dados utilizados pelos mesmos. Qualquer
programa, para ser executado, tem de estar na memória. Quando pretendemos solicitar ao
computador que reserve um espaço na memória fazemos através da declaração de
variáveis.
A sintaxe é
var
Nome_da variável: tipo_da_variavél
A palavra var é utilizada para indicar o início do bloco de declaração de variáveis de um

algoritmo.
nome_da_variavel encapsula a referência de um determinado sector na memória, onde

serão alocados os dados por ser processados.

tipo_da_variavel colocamos o tipo de dados para informar ao computador sobre os

valores a serem armazenados. Só assim o computador saberá determinar um espaço
adequado para variável ora declarada.
Quando declaramos uma variável, devemos ter em mente quais valores serão
armazenados naquele espaço de memória. Uma variável pode ser de um dos seguintes
tipos:
Nome Descrição
O tipo inteiro é usado da mesma forma como nas expressões
Inteiro matemáticas. Declararemos variáveis do tipo inteiro quando
precisarmos armazenar valores inteiros, positivos ou negativos
Este tipo de dados é igual aos números reais em Matemática.
Real Declararemos variáveis do tipo real para armazenar valores reais com
ponto flutuante.
Declaramos este tipo de dados para armazenar um único
Caractere
caractere, que pode ser uma letra, número ou símbolo.
Declararemos variáveis do tipo cadeia de caracteres para
armazenar uma sequência de caracteres. Quando pretendemos
String
armazenar conteúdo de tipo nome, pais, ou outros dados com
mais de um caractere, este tipo de dados é ideais.
Suporta valores do tipo verdadeiro ou falso. Este tipo de dados é
Lógico
aplicável nas instruções condicional.
Tabela 2: Tipo de dados
É uma posição nomeada de memória, que é usada para guardar um valor que
pode ser modificado pelo programa. Existem regras para dar nomes as
variáveis.
REGRA
Inicie sempre por um caractere alfabético, nunca por um número.
Não utilize caracteres especiais como “ , ( ) / * ; + .
Não coloque espaços em branco ou hífen entre nomes.
Utilize, se necessário, underline.
Crie suas variáveis com nomes sugestivos.
Tabela 3: Regras para a declaração de variáveis
3.1.2.2. Constantes

Como podemos ter observado, o valor de uma variável muda de acordo com as
necessidades do problema. Há situações em que pretendemos manter o valor durante toda
a execução do programa. Nessa situação a variável não satisfaz. Dai que existem as
contantes para garantir que o seu valor não mude durante a execução. A sua declaração
obedece as mesmas regras das variáveis.
A sintaxe é
Const
nome_da_constante ← valor
Const
É utilizada para indicar o iníco do bloco de declaração da contante de um algoritimo.
nome_da_constante
é o nome pelo qual vamos nos referir à contante
3.1.2.3. Comandos de atribuição
(←) Este símbolo é usado para indicar a atribuição em algoritmos.
A sintaxe é
Identificador expressão
Onde:
Identificador - Nome da variável ou constante a ser utilizada
Expressão – Valor ou expressão a ser armazenada
3.1.2.4. Comandos de entrada de dados

Na programação, por vezes há necessidades de realizar interacção com utilizador durante

a execução do programa por meio de teclado ou outro dispositivo de entrada. Nessa
interacção, o utilizador precisa de receber instruções dp próprio computador.
Para esse efeito existem comandos que podemos utilizar no desenho de algoritmos para o
efeitos, nomeadamente: leia()e escreva().
Leia()
é uma função responsável por ler os dados introduzidos pelo utilizador no espaço indicado.
escreva()
É a função responsável por escrever no monitor uma mensagem para a informação do
utilizador.
Sintaxe é:
leia(variável)
escreva(expressão)
Onde:
Expressão
É o conteúdo a ser exibido ao utilizador
Variável
Encapsula o espaço da memória onde os dados introduzidos serão armazenados.
3.1.2.5. Operadores aritméticos e prioridades

Os operadores aritméticos são símbolos que representam operações aritméticas, ou seja,
as operações matemáticas básicas. Em programação podemos destacar Cinco operadores
básicos como pode ser visto na tabela abaixo:
OPERADOR OPERAÇÃO PRIORIDADE EXEMPLO

+ Adição 2ª x+y
- Subtracção 2ª x-y
* Multiplicação 1ª x*y
/ Divisão 1ª x/y
% Resto da Divisão Inteira 1ª x%y

Exemplo: Cálculo da média de um aluno
Algoritmo Média
Var N1, N2, Media: real

Início
Leia N1, N2
Media  (N1 + N2) / 2
Se Media> = 6.0
Então
Escreva “Aprovado”
Senão
Escreva “Reprovado”
Fim_se
Fim.
Resumo
Na aula de hoje aprendemos sobre a resolução do problema. E para a resolução de
problema com recursos computacionais é necessário desenhar soluções por meio
de um algoritmo. Vimos ainda que um algoritmo pode ser representado em
diferentes formas e nesta aula destacamos duas formas fundamentais: (i) o
fluxograma e (ii) pseudocódigo. Ambas formas podem nos encaminhar a resolução
de qualquer problema. Enquanto o fluxograma apresenta-se por anotações
gráficas, o pseudocódigo caracteriza-se por se assemelhar a linguagem de
programação e incorpora expressões matemáticas e de linguagem natural.

ACTIVIDADE 3
Nesta actividade é requerida a leitura dos tópicos sobre o que realmente são
problemas de programação, porquê que os computadores e os outros sistemas digitais
são usados para resolver problemas, definição do problema, as similaridades entre os
problemas, as estratégias para a resolução de problemas e as etapas envolvidas na
resolução de um problema. As leituras podem ser obtidas a partir da lista de livros
fornecidos na seção de referência para esta unidade. Os alunos também devem
complementar as leituras, fazendo pesquisas individuais na internet e noutros recursos, a
fim de melhorar a sua compreensão. Nesta actividade, deves escrever breves notas
sobre:
i. Porquê que um computador é uma ferramenta necessária para a resolução de

problemas.
ii. Estratégias de resolução de problemas e seus benefícios na programação.
iii. Processo de desenvolvimento de um programa.
iv. As similaridades entre os problemas que podem ser resolvidos utilizando um
computador.
v. Por tuas palavras o que entendes por concepção de programa?
vi. Algoritmos podem ser apresentados em forma de pseudocódigo ou de um
fluxograma. Qual é a diferença entre um algoritmo e um pseudocódigo?
vii. Pseudocódigo é independente de uma linguagem de programação. O que
significa isso?
viii. Os algoritmos são desenvolvidos utilizando três construções básicas. Descreva
estas construções.
ix. Descreva as características de um bom algoritmo?
x. Quais são as vantagens de fluxogramas sobre algoritmos?
xi. Apresente as regras para a construção de um fluxograma?

4. AULA 4: • INTRODUÇÃO À PROGRAMAÇÃO EM C
4.1. Introdução

imperativo.
Objectivo geral
 Dar uma visão geral sobre o historial da linguagem C;

 Descrever o historial da linguagem C;
 Descrever as principais características de C;
 Discutir sobre as aplicação de C;
Objectivos  Comparar as linguagem C do e C++
4.1. Historial da Linguagem C
A Linguagem de programação C foi desenvolvida nos laboratórios Bell na década de 70, a

partir da Linguagem B (criada no final dos anos 60 por Ken Thompson), que foi
reformulada por Brian Kernighan e Dennis M. Ritchie
C pode ser considerada como uma linguagem de médio nível, pois possui instruções que a
tornam ora uma linguagem de alto nível e estruturada como o Pascal e de igual modo actua
como uma linguagem de baixo nível pois possui instruções tão próximas da máquina como
Assembler.
Com a linguagem C podemos construir programas organizados e concisos, com a

vantagem de ocuparem pouco espaço de memória com alta velocidade de execução como
o Assembler. Mas também, devido a flexibilidade desta linguagem, podemos também

escrever programas complicados e desorganizados de difícil percepção. Como acontece

com o BASIC.
Esta linguagem foi desenhada a partir da necessidade de se escrever programas que

utilizassem recursos da linguagem de uma forma mais simples e portável que o Assembler.
A filosofia que existe por trás da linguagem C é que o programador sabe realmente o que
está fazendo. Por esse motivo, a linguagem C quase nunca colocasse no caminho do
programador, deixando-o livre para usar de qualquer forma que queira. Existe uma
pequena verificação de erro de execução runtime error. Por exemplo, se por qualquer
motivo queiramos sobrescrever a memória na qual o programa está actualmente
armazenado, o compilador nada fará para impedi-lo.
O motivo para essa liberdade na programação é permitir ao compilador C criar códigos

muito rápidos e eficientes, já que ele deixa a responsabilidade da verificação de erros para
o programador. Em outras palavras, a linguagem C considera que o programador seja hábil
o bastante para adicionar suas próprias verificações de erro quando necessário.
Quando C++ foi inventado, Bjarne Stroustrup sabia que era importante manter o espírito
original da linguagem C, incluindo a eficiência, a natureza de nível médio e a filosofia de
que o programador, não a linguagem, está com as responsabilidades, enquanto, ao mesmo
tempo, acrescentava o suporte à programação orientada a objectos. Assim, o C++
proporciona ao programador a liberdade e o controle da linguagem C junto com o poder
dos Objectos.
Que características contribuíram para a popularização da linguagem C?
O C apresenta algumas características que justificam a sua ampla utilização como:
• Portabilidade entre máquinas e sistemas operativos.

• Dados compostos em forma estruturados.
• Programas Estruturados.
• Total interacção com o Sistema Operativo.
• Código compacto e rápido, quando comparado ao código de outras linguagem de
complexidade análoga.

Sistema operativo ou operacional é um programa ou um conjunto de

programas cuja função é gerenciar os recursos do sistema, fornecendo uma
interface entre o computador e o utilizador.
Anteriormente dissemos que o C é uma linguagem de desenvolvimento do propósito

geral, enumere algumas Aplicações desenhadas com recurso a essa linguagem e
compare-o com outras linguagens do mesmo paradigma.
Actualmente, C é a linguagem muito utilizada pelos programadores, por permitir, dadas

suas características, a escrita de programas típicos do Assembler, BASIC, COBOL e
Clipper, sempre com maior eficiência e portabilidade, como podemos constatar pelos
exemplos abaixo relacionados:
• Sistema Operacional: UNIX (Sistema Operacional executável em micro computadores

e em mainframes).
• Montadores: Clipper (O utilitário de banco de dados mais usado no Brasil).
• Planilhas: 1,2,3 e Excel (A planilha eletrônica com maior volume de vendas mundial).
• Banco de Dados: dBase III, IV e Access (o gerenciador de base de dados mais
utilizado no mundo).
• InfoStar: O Editor de Texto mais utilizado nos USA no Sistema Operacional UNIX.
• Utilitários: FormTool (Editor de formulário mais vendido no mundo).
• Aplicações Gráficas: Efeitos Especiais de filmes com Star Trek e Star War.
• Linguagens como o Power Builder e o Visual Basic, respectivamente as linguagens
mais utilizadas nos EUA e no Brasil.
4.2. Comparação de C com outras linguagens imperativas

Linguagens
BASIC
Características Assembler Clipper COBOL C
Pascal
Ideais
Executáveis
Óptimo Fraco Péssimo Fraco Óptimo
Curtos
Executáveis
Óptimo Bom Razoável fraco Bom
Rápidos
Portáveis Péssimo Bom Óptimo Óptimo Bom
Manipulação de
Óptimo Razoável Péssimo Fraco Óptimo
Bits

4.3. Comparação de c com c++

C e C++ possuem o mesmo estilo de programação, dai que quem sabe programar em C++
pode programar sem limitações em C. No entanto C não é completamente subconjunto de
C++. Existem algumas diferenças entre essas duas linguagens tais como:
C C++
Linguagem que permite programar
Linguagem estruturada nos dois modos (Orientada a Objecto
e modo orientado a procedimentos)
O C permite a conversão implícita entre o
tipo de dado void* para ponteiros para Não permite essa conversão
outros tipos
O C permite que constantes de caracteres
sejam inseridas em chamadas de funções É preciso declarar o parâmetro como
const char *
com parâmetros tipo char*
C é derivado da linguagem B Ë directamente derivado do C
Resumo
Nesta aula falamos sobre a evolução da linguagem C. Debruçamos sobre diferentes
versões até o surgimento desta que é considerada uma linguagem robusta que
actua em dois níveis o baixo e o alto nível. Tratamos também das suas
características e apresentamos algumas aplicações desenhadas usando esta
linguagem. E por fim fizemos uma análise comparativa entre esta linguagem com
outras linguagens de programação.

ACTIVIDADE 4
Nesta actividade é requerida a leitura dos tópicos sobre o que realmente são o
historial e evolução da linguagem C, As leituras podem ser obtidas a partir da lista de
livros fornecidos na secção de referência para esta unidade. Os alunos também devem
complementar as leituras, fazendo pesquisas individuais na internet e noutros recursos, a
fim de melhorar a sua compreensão. Nesta actividade, deves escrever breves notas
sobre:
i. A origem da linguagem C.
ii. Porque a linguagem C é chamada de linguagem do nível intermediária?
iii. Quais são as possíveis versões da linguagem C?
iv. Porque C é uma linguagem estruturada e não orientada a objecto?
v. Fale sobre o historial da linguagem C;
LEITURAS OBRIGATÓRIAS
• Fundamentos de Programação usando C, Marques de Sá, FCA – ISBN: 978-972-

722-475-3
• Linguagem C, Luís Damas, FCA – ISBN: 978-972-722-156-1
TEXTOS:
Leituras Complementares
• Moreira, M. A. (1996). Modelos mentais. Investigações em ensino de ciências. Porto
Alegre. Vol. 1, n. 3 (dez. 1996), p. 193-232.
• Gudwin, R. R. (1997). Linguagens de programação. Campinas: DCA/FEEC/
UNICAMP.
• Medeiros, H. Linguagens de Programação.
• Da Silva, V. L. Linguagens de Programação.
• Sebesta, R. W. (2009). Conceitos de linguagens de programação. Bookman Editora.
• Grune, D. (2000). Modern Compiler Design. Modern Compiler Design, 736.
https://doi.org/10.5860/CHOICE.50-3309
A leitura dos textos que se seguem é importância para consolidar e complementar a

compreensão dos conteúdos, daí que sejam recomendados.

CONCLUSÃO DA UNIDADE
Esta unidade discute a linguagem de programação, os paradigmas de programação e a
resolução de problemas através de recursos computacionais. Tem A unidade tem como
foco a introdução do estudante na programação através da criação da lógica de
programação e de demostração das estratégias de resolução de problema baseado no
computador, os passos seguidos no desenvolvimento de um programa, as técnicas de
concepção de programa incluindo as abordagens top down e bottom up, os algoritmos e as
formas de representação: pseudocódigo e fluxograma. Apresenta também a linguagem de
programação em C, abordando as suas características e o seu historial.
Actividades Formativa
As actividades que se seguem complementam o estudo desta unidade temática. Resolva-

as e verifique se estão certas. Estas actividades ajudam ao tutor certificar-se dos
progressos de aprendizagem de cada estudante, verificar os aspectos em que se pode
recomendar mais aprendizagem…e, sobretudo, servirem de base para o incremento da
interacção entre estudantes e dos estudantes com os tutores.
Pode-se, deste modo, por exemplo, propor que haja actividades individuais, outras em
grupos e/ou aos pares. Também podem constar actividades cuja discussão é, desde o
princípio, aberta [envolvendo toda colectividade de aprendentes] ou fechada a
determinados grupos, bem como entre o tutor e os estudantes individualmente.
Actividade Formativa 1
AVALIAÇÃO DA UNIDADE
O objectivo desta avaliação é verificar o progresso do aluno ao determinar o quanto o

aluno aprendeu nesta unidade. As perguntas abordaram tudo o que foi apresentado
nesta unidade, a fim de avaliar a compreensão global. Responde-as com cuidado e se a
tua pontuação tiver:
1. Abaixo de 40%, refazer as leituras.
2. Entre 40% e 60%, refazer as leituras em seu ponto fraco

3. Acima de 60%, conseguistes assimilar os conteúdos trabalhados na unidade

acima.
PARTE A
1. A programação pode ser definida como o acto de usar uma _____________ para
escrever __________________que pode ser executada pelo computador com o objectivo
de ____________________________, aplicando correctamente ________________ e
_________________de uma linguagem de programação.
2. __________________________foi o computador primeira geração e foi usado

linguagem ____________________ para escrever instruções de computador.
3. Qual das seguintes linguagens usa mnemónicas para representar instruções:
□Alto nível □ baixo nível □ Assembly □ Intermédia
4. A linguagem de alto nível usa _________________________ ou ___________________

para traduzir instruções para linguagem máquina.
5. Qual(s) das seguintes linguagens suportam o paradigma orientado a objectos:
□C □ C ++ □ Pascal □ Java □ Visual Basic.Net
PARTE B
1. Um fluxograma é______________________________________
2. Precisamos de computadores para resolver problemas por causa

A) Velocidade na execução de tarefas de computação; B) Menos erro
C) Redução no trabalho de papel D) Versatilidade das operações
E) Todas as respostas anteriores F) A, B e C
3. Definição do problema envolve:

A) Identificar peças-chave envolvidas B) Identificação de dados de entrada
C) Especificar a saída da solução D) Especificar as operações do programa
E) B, C, e D F) Todas as respostas anteriores

4. A simplicidade, clareza e elegância são as características de bons programas, mas

várias questões de implementação devem ser levados em consideração ao projectar
uma solução. Quais:
A) Minimizar os requisitos de memória B) Maximizar a legibilidade da saída

C) Maximizar a legibilidade do código D) Minimizar o número de instruções do código
E) Minimizar o tempo de desenvolvimento F) A e C G) Todas as afirmações
5. Combine as seguintes notações de fluxograma com suas funções e nomes

correctos.
Feedback
• Na tua opinião, o quão bem está a unidade desenvolvida/entregue?
• Quais são as áreas que achas necessária mais clareza?
• Existem termos que precisavam de mais explicações?
• Que sugestões dariam para melhorar o conteúdo apresentado?
• Os exercícios de avaliação apresentados foram adequados?
Respostas PARTE A

1. Linguagem de programação, Instruções, resolver um problema, a sintaxe, a

semântica
2. Linguagem de computador, de baixo nível
3. Assembly
4. Compiladores ou interpretadores
5. C++, Java, Visual Basic.Net
Resposta PARTE B
1. Fluxograma é uma representação gráfica de um algoritmo.

2. e
3. e
4. f
5. g
6.
a. Indica início e fim de um processo, inicio/ fim
b. Realização de cálculos e processamento, processamento
c. Representa uma tomada de decisão, condição
d. Loop de um conjunto de etapas até condição verificar, looping
e. Valores de entrada/saída
f. Ligando dois passos conectores

UNIDADE TEMÁTICA II: INTRODUÇÃO AO P ARADIGMA DE PROGRAMAÇÃO

IMPERATIVA
Introdução geral
A unidade dois tem como objectivo introduzir o estudante aos conceitos

fundamentais de programação, para o caso mais específico da linguagem C.
A unidade é constituída por três aulas das quais na primeira iremos discutir
sobre aspectos gerais da linguagem C. Apresentaremos a estrutura de um
programa em C, aprenderemos como trabalhar com os compiladores da
linguagem e discutimos passo a passo desde a configuração do ambiente do
trabalho até a programa detalhadamente.
Na segunda aula, trataremos de conceitos fundamentais como constantes,

palavras reservadas, variáveis e tipos de dados. Espera-se que nessa aula o
estudante esteja preparado desenvolver pequenos programas para
implementar os conceitos a serem discutidos.
E por fim na terceira aula trataremos de expressões, operadores, hierarquia

de operadores no runtime e por fim a conversão do tipo.
Depois desta unidade o estudante deve estar em condições de desenvolver

programas que executam de forma sequencial.

AULA 5: INTRODUÇÃO A LINGUAGEM C – ESTRUTURA DE UM PROGRAMA

Introdução
OBJECTIVO GERAL DA AULA/M ETA
1. Conhecer a ferramenta de programação que será utilizada.

2. Aprender os conceitos básicos da linguagem C, bem como sua sintaxe.
3. Conhecer os comandos de atribuição, entrada e saída de dados da linguagem C.
4. Criar programas em linguagem C.
• No fim desta aula o aluno deve ser capaz de:

• Saber introduzir o código fonte em um editor de programa;
• Fazer uma leitura de um programa em C e diferenciá-lo de algoritmo;
• Saber compilar e executar um programa usado DevC++;
• Conhecer alguns problemas relacionados com a codificação;
CONTEÚDOS DA AULA
Para discutir e ilustrar esses conceitos usando um programa C, primeiro temos que
começar por nos familiarizar com o ambiente de linguagem (visão geral da linguagem C).
Como referenciamos nas aulas anteriores, a linguagem C é uma linguagem compilada, isto
é, para a sua execução precisa de um compilador. Existem várias opções de compiladores
de C no mercado concebidos ou desenvolvidos por diferentes grupos de desenvolvedores.
Podemos encontrar como exemplo o Microsoft Visual C++, Turbo C/C++, Code::Block,
DevCPP entre outros. Dentre estes existem alguns grátis e comerciais. Nesta unidade
curricular optaremos por usar o DevCPP para ambiente Windows.
Pode ser descarregado a versão atual neste link: https://bloodshed-dev-

c.en.softonic.com/download. Neste compilador vamos aprender como criar e
compilar um programa na linguagem de programação C.
Para criarmos um programa usando este compilador podemos fazer de duas maneiras.

(i) – Criar um novo ficheiro de código fonte através de menu File/New/Source_File ou

usando um atalho combinando CTRL + N.
Passo 1: Abra o DevC++ através de Start/Programs/DevC++
Ilustração 1: Janela de Dev C++
Passo 2: Siga as instruções da figura abaixo
Ilustração 2: Criando um ficheiro de código fonte
Passo 3: Aberto o ficheiro para a codificação

Ilustração 3: Ficheiro para codificação
(ii) Através do File/New/Project
Usando esta forma, siga a instrução do passo 1;
Passo 2: Repita a instrução do passo 2, e ao envez de escolher Source-File, opte por

project. E de seguida ira ser apresentada a janela abaixo.
Ilustração 4: Criação de um projecto usando DevC++

Optaremos por Console Applications e seleccionemos o C Project por fim finalizamos a

instrução com ok.
Ilustração 5: Descrição de ambiente de trabalho
Tanto para a primeira opção assim como a segunda, as janelas apresentam as mesmas
características: Face a essa situação, vamos apresentar a legenda:
1. File Explorer – Espaço destinada a apresentação da árvore do

projecto.
Compile – Acto de
2. Header files – Usamos para incluir as bibliotecas da linguagem; verificar e detectar
erros de sintaxe no
programa;
3. Source File – Espaço onde colocamos o código por ser
Run – Acto de
executado; executar o
programa após a
4. Área de compilação – Composta pelos botões: Compile, Run, compilação.
Rebuild e Compile & Run. Rebuild – acto de
reconstrução de
objectos após a
O processo de executar um programa em C envolve os seguintes passos:
1. Criar o programa
2. Compilar o programa
3. Linkar o programa com funções necessárias a partir da biblioteca do C
4. Executar o programa

Figura 10: Etapas de compilação e execução de um programa em c
Para termos uma visão geral da linguagem que usaremos no desenvolvimento dos
programas, vamos analisar como ficaria, na linguagem C, nosso algoritmo calculo da média
apresentado como exemplo nas aulas anteriores.
ALGORITMO EM PSEUDOCÓDIGO REPRESENTAÇÃO EM LINGUAGEM C

Algoritmo Média int main(int argc, char *argv[])
{
Var N1, N2, Media: real float n1,n2,media;
Início printf("Introduza a primeira nota");
Leia N1, N2 scanf("%f",&n1);
Media  (N1 + N2) / 2 printf("Introduza a segunda nota");
Se Media> = 6.0 scanf("%f",&n2);
Então media = (n1+n2)/2;
Escreva “Aprovado” if(media>10)
Senão printf("\n Aprovado");
Escreva “Reprovado” else
Fim_se printf("\nReprovado");
Fim. return 0;
}

Ao introduzirmos o código acima em devC++ teremos uma situação similar a que podemos
verificar na figura abaixo:
Ilustração 6: Primeiro programa em C
• Linha 1 e 2: #include <stdio.h> #include <stdlib.h>
As duas linhas indicam a inclusão de bibliotecas que possuem as

funções de entrada e saída de dados necessários à execução do
nosso programa. Para evitar problemas, devemos iniciar os
programas com essas duas linhas. stdio significa
standard Input
Output
• Linha 4: /* */
Representa comentários. Este conteúdo é ignorado pelo compilador. stdlib – significa
standard library
• Linha 6: int main()
• A função main( ) é sempre a primeira a ser executada no programa C. Em todo

programa desenvolvido em C, existirá uma função main( ). O main() é o ponto de
execução do programa.

Linha 8 e 19: { }
Representam o início e o fim do bloco de comandos no programa. Para cada chaveta que
colocamos, temos que informar sobre o seu fecho através de outra chaveta do sentido
oposto.
• Linha 8: float n1,n2,media;

Foram declaradas as variáveis necessárias à execução do programa. O float indica o tipo
de dado que pretendemos armazenar na memória. O n1, n2 e soma são identificadores. E
por fim temos (;) ponto e vírgula que determinam o fim da instrução.
Toda a instrução ou expressão em C termina com ponto e vírgula
• As Linha 9, 11, 15 e 17:

A função printf( ) funciona como escreva() em algoritmos. Esta permite a exibição de
mensagens no monitor. O código especial \n é responsável por fazer saltar ou quebrar uma
linha.
• As Linha 10 e 12: scanf("%f",&n1); e scanf("%f",&n2);

A função scanf( ) é responsável por ler os dados que forem digitados pelo dispositivo de
entrada, e neste caso do teclado.
É equivalente ao leia() em algoritmos.
Nessa linha a função irá ler o primeiro número que for digitado e o armazenará no
endereço da variável n1, conforme indicado (“%f”, &n1). O “%f” indica que se trata da
leitura de um número real com ponto flutuante. O mesmo ocorre para scanf(“%f”,&n2).
• Linha 13: media = (n1+n2)/2;

O comando de atribuição (=) atribui a variável media o resultado da operação de adição de
n1 e n2 dividido por 2. Esta operação segue a regra de prioridades dos operadores.
• As linhas 14 e 16: if(media>10) e else

Estas linhas indicam uma instrução condicionada. Apenas uma instrução subordinada a
estas será executada consoante a condição colocada. Neste caso específico será

executada a linha 15 caso o resultado da média entre n1 e n2 seja superior a 10. Caso a
condição colocada não seja satisfeita, executa-se a linha 17.
• Linha 18: return 0;

Indica o número inteiro que está sendo retornado pela função; em nosso caso, o número
zero.
Dependendo do tipo de dados que declaramos a função, há sempre uma

obrigatoriedade de retornar qualquer valor do mesmo tipo, na excepção da
função ser do tipo void, pois ai não precisamos de retornar nada.
O C é case sensitive, ao contrário de algumas outras linguagens, em C há

distinção entre caracteres maiúsculos e minúsculos. Portanto, para evitar
erros, por padrão, costumamos utilizar apenas caracteres minúsculos nos
nomes de variáveis.
Apresentação do resultado da compilação e execução do programa
Para executarmos um programa em C, há necessidade de compilar primeiro. E essa tarefa

podemos realizar através de atalho (F11) ou através (i) execute/compile (F9) e depois
execute/run (F10).
Ilustração 7: Compilação e Execução do prograa
Após a instrução três podemos ter o output abaixo:

Ilustração 8 : Resultado da execução do programa
Quando compilamos um programa e o ambiente encontra algum erro no mesmo, a linha

que contém o erro fica sombreada em destaque e, na parte inferior da janela do ambiente,
são exibidas mensagens indicando o erro encontrado. Essas mensagens são muito úteis
para que possamos compreender o motivo do erro e corrigi-lo. É muito importante ficar
atento a tais mensagens.
Ilustração 9: Detecção de erros no programa
Resumo da aula
Vimos nesta aula o ambiente de programação em C, o editor DevC++,

apresentamos a estrutura básica de um programa em C que em constituído por quatro

partes destintas (comentários, pré-processadores, declaração de variáveis globais e

funções, a função principal ). De seguida colocamos os cuidados ou regras de construção
de um programa em C onde destacamos as seguintes regras: (i) C é Case Sensitive todas
as instruções são escritas em letras minúsculas; (ii) uma expressão, duas palavras devem
estar separadas por um espaço branco de modo a aumentar a confiabilidade; (iii) todas as
instruções em C terminam com ponto e vírgula (;). Destacamos duas funções de entrada e
saída o printf() e scanf(). A função printf () é usada para escrever informações num ficheiro,
no monitor ou qualquer outro dispositivo de saída. Enquanto a função scanf () é usada para
ler os dados que o programa manipula ou escreve no monitor. Estas funções são
suportadas pelo arquivo de cabeçalho ou directiva de pré-processador de <stdio.h>, que
significa ficheiro de cabeçalho para entrada e saída padrão. Por exemplo, um programa
que imprime um valor que já foi atribuído a uma variável e um valor (idade) lida para o
sistema pelo utilizador. O operador de endereço & é usado para a leitura dos valores.
Quando pretende-se imprimir ou capturar um valor do monitor ou para teclado através das
funções printf() ou scanf() deve-se usar a especificação de formatação, dependendo do tipo
de dado a ser manipulado.
ACTIVIDADE 5
Para a resolução desta actividade deve ler atentamente o conteúdo da aula e os materiais
disponibilizados no fim desta unidade. Esta actividade pode ser realizada em grupo ou
individualmente. Deve ter internet para descarregar o programa no site indicado e procure a
versão mais actualizada do DevC++ ou outro compilador que o seja de fácil manipulação.
1. Baixa e instala o compilador DeV C++ no seu computador (caso ainda não o tiver
instalado).
2. Familiarize-se com o ambiente do compilador da linguagem C e escreva um

programa simples que apresenta o seu nome no monitor.

3. Crie um projecto usando o devC++ e crie dois ficheiros de código fontes sob
projecto;
4. Escreva um programa que implementa o seguinte código. Mostra a sua saída.
int a,b,c,d=5;
a=++d;
b=a++;
c=b--;
printf (“%d %d %d %d %d”, a, b, ++c, d,--d);

AULA 6: CONSTANTES, PALAVRAS RESERVADAS, VARIAVAM E TIPO DE DADOS EM

LINGUAGEM C
Introdução

o Descrever diferentes elementos da linguagem C;
o Saber aplicar as regras de construção dos elementos de programação.

 Construir expressões usando conjunto de caracteres;
 Construir constantes obedecendo as suas regras de construção;
 Criar variáveis guiado pelas regras de construção;
 Diferenciar vários tipos de palavras reservadas e conhecer a sua utilidade;
 Discutir detalhadamente sobre tipos de dados comumente usados na
linguagem.
CONTEÚDOS DA AULA
A linguagem C é o meio de comunicação com o computador. Esta pode ser amplamente definida
como: Alfabetos, dígitos ou símbolos especiais combinados para formar constantes, variáveis ou
palavras reservadas. As quais são combinadas para formar instruções, regras e regulamentos, isto
é, combinação de sintaxes para formar expressões e a combinação de expressões formam o
programa.
6.1. Conjunto de caracteres

É um conjunto de caracteres que podem ser usadas para representar as informações em
linguagem C. Este conjunta é composto por todo alfabeto, dígitos e símbolos especiais:
Nome Exemplo
Alfabeto A–Zea–z

Dígitos 0–9
Símbolos especiais , . ; : ? ! @ % & * / \ | { } ( _ ) etc.
6.2. Constantes
Como vimos na aula anterior, Uma constante é uma variável tem um valor fixo e inalterável
ao longo do programa. Em C uma constante do tipo caractere é escrita entre aspas
simples, uma constante cadeia de caracteres entre aspas duplas e constantes numéricos
escritos como o número inteiro.
6.2.1. Constantes inteiro

Uma contante inteira é um número inteiro. É uma sequência de dígitos. Combinação de
dígitos de 0 a 9.
REGRAS PARA CONSTRUÇÃO DE CONSTANTES INTEIRAS

1. Deve ter no mínimo um dígito;
2. Não pode ter vírgula decimal;
3. Pode ser Positive ou Negativo caso não tenha sinal assume valor positive;
4. Não pode conter vírgula ou espaço em branco;
5. Inteiro é usado para alocar 2bytes na memória. O valor da constante inteira não
pode exceder os limites estabelecidos: -32768 a +32767
6.2.2. Constantes decimais / ponto flotuante

Este tipo de constante pode ser representado de duas formas: Factorial e Exponencial. As
constantes do ponto flutuantes são normalmente representadas por quantidade de precisão dupla
em C. Consequentemente, as constantes deste tipo ocupam 4 bytes da memória
REGRAS PARA CONSTRUÇÃO DE CONSTANTES FLOTUANTE

 DECIMAL

1. Deve ter no mínimo um dígito;

2. Deve conter um ponto decimal, caso não se coloque ele assume automaticamente;
3. Pode ser positive ou negativo, por defeito é positive;
4. Espaços em brancos e vírgulas não são permitidos.
 EXPONENCIAL
1. A mantissa e expoente devem ser separados por e;
2. A mantissa pode ser positive ou negative. O padrão é positive;
3. O expoente deve ter no mínimo um digito, positive ou negativo.
4. O Range desse tipo é -3.4e+38 a 3.4e+38
6.2.3. Constante caractere

A constante caractere é um simples caractere entre apóstrofos. Este pode ser qualquer símbolo. O
tamanho máximo deste é de 1 byte da memória.
Exemplo: ‘A’ ‘%’ ‘=‘
CONSTANTE CADEIA DE CARACTERES

Constante String consiste em um número de caracteres consecutivas/ sequência de caracteres
colocadas entre ASPAS “ ”.
Exemplo: “A” “Jose” “1988” “%@kad”
REGRAS CONSTANTE STRING

1. Deve ser sequência de qualquer número de caracteres entre aspas;
2. Pode existir uma String vazia “ “;
3. O compilador sempre insere o valor NULL caractere (|0) no fim de cada constante
String que não é visível quando este é visualizado.
6.3. Palavras reservadas
As palavras reservadas, também conhecidas como palavras chave da linguagem C, são

comandos de uso muito específico dentro da linguagem. Estas palavras não podem ser
usadas com outro propósito além do original dentro de programas em C. O padrão ANSI C
definiu um conjunto de 32 palavras reservadas para a linguagem C.

Saiba masi
sobre as
funções de cada
palavra
https://www.progra
miz.com/c-
programming/list-
all-keywords-c-
language
6.4. VARIÁVEIS EM LINGUAGEM C
Já aprendemos que constantes e variáveis alocam espaço em memória e são utilizadas

para armazenar valores necessários à execução do programa. Cada variável corresponde
a uma posição de memória, cujo conteúdo pode ser alterado ao longo do tempo durante a
execução de um programa.
Embora uma variável possa assumir diferentes valores, ela só pode armazenar um valor a
cada instante.
REGRAS PARA DECLARAR UMA VARIÁVEL
i. Todo nome só pode conter letras e dígitos;

ii. O caractere "_" é contado como uma letra;
iii. Todo primeiro caractere deve ser sempre uma letra;
iv. Letras maiúsculas e minúsculas são consideradas caracteres diferentes;
v. Todas as variáveis em C devem ser declaradas, antes de serem usadas;
vi. Uma declaração de variável em C consiste no nome de um tipo, seguido do nome da
variável, seguido de ponto-e-vírgula. Exemplo: int x;

vii. O nome de uma variável pode ser de uma letra até palavras com no máximo 32
caracteres;
Exemplo: a; num; essa_e_uma_variavel; tambem_essa;
viii. Palavras reservadas não podem ser usadas como nome de variáveis.
SINTAXE DE DECLARAÇÃO DE VARIÁVEL
Tipo_de_dado identificador;
O tipo de dado pode tomar um dos valores representados na tabela abaixo.
Nome Tipo Tamanho Faixa de Números Formato

em bytes específico
Caractere char 1 -128 a 127 %c
Inteiro int 2a4 -2.147.483.648 a 2.147.483.647 %d ou %i
Real float 4a8 7 dígitos de precisão %f
Exemplos:
Exemplo Resultado
Int qnt, saldo, pUnity; Correcto
char nome da escola; Errado
char nome_da_escola; Correcto
float main; Errado
float _main; Correcto
Exemplo 2: Observe o uso da declaração de variáveis no trecho de programa abaixo:

void main()
{
float raio, areaCirc; // declaracao de variáveis raio e areaCirc
raio = 2.5;
areaCirc = 3.14 * raio * raio;
printf(“A área é %f”,areaCirc);
}
6.5. Tipo de Dados
É uma combinação de valores e de operações que uma variável pode executar. É um

conjunto finito de valores, juntamente com conjunto de regras para diferentes operações.

Os tipos básicos são char, int e float. Para cada um dos tipos de variáveis existem
modificadores. Os modificadores suportados em na linguagem C são signed, unsigned,
long e short. Vejamos a tabela que detalha os mesmos:
Para manipular esses tipos de dados usando funções formatadas como printf() e scanf()
é preciso usar o formato especifico como pode ser visto na coluna 2 da tabela acima.
Para além dos tipos de dados primários, podemos encontrar outros tipos de dados como
(i) secondários, definidos pelo utilizador e tipo void. A figura abaixo ilustra cada uma
dessas categorias.
6.5.1. Tipo de dados definidos pelo utilizador
6.5.1.1. Matrizes ou arrays

É basicamente uma colecção do mesmo tipo de dados. Array é um grupo de elementos do

mesmo tipo que são dados o mesmo nome.
A sua declaração é:
tipo_de_dado identificador[subscrição];
6.5.1.2. Estruturas
É o tipo de dados que possibilita o agrupamento de registos de tipos de dados diferentes.
struct identificador
{
Declaração:
Tipo_de_dado 1 identificador 1;
….
Tipo_de_dado n identificador n;
};
6.5.1.3. União
É um tipo de dado derivado, quase similar a estructura. É declarado da mesma forma que a
estrutura.
union identificador
{
Declaração: ….
Tipo_de_dado n identificador n;
};
6.5.1.4. Ponteiro
Ponteiro é outro tipo de dado derivado, usado para armazenar os endereços de memória
de variáveis do mesmo tipo.
Declaração:
tipo_de_dado * identificador;

6.5.1.5. Typedef
Ela nos fornece uma maneira simples e significante para chamar um tipo de dados que já
declarada.
Declaração: Typedef struct identificador x;
6.5.1.6. Enum
Tipo de dados enumerado é usado para criar o nosso próprio tipo de dados e dar-lhe os
valores que tipo de dados que passará a tomar
enum especialidade
{
Declaração: SISTEMA, ENSINO, REDES, MULTIMEDIA
};
enum especialidade m1,m2;
6.5.1.7. Tipo de dado nulo / void
Também conhecida como tipo de dado vazia, é útil em muitas situações importantes. Ele é
usado para especificar o tipo de retorno de uma série de funções em que a função não é
suposto para retornar um valor. lista de argumentos vazia de uma função e para declarar
ponteiro genérico.
Exemplo do seu uso
Void add(int, int); void add(void); void * ptr;
No primeiro exemplo a função não retorna nenhum valor, no segundo a função leva
argumentos vazios e no terceiro exemplo trata-se de um ponteiro genérico.
Resumo da aula
Nesta aula tratamos de conceitos básicos de programação. Introduzimos o conceito de

conjunto de caracteres e dissemos eu é o que permite a composição de qualquer

expressão em programação. Este, é composto por dígitos, alfabeto e símbolos especiais.

Depois tratamos de constantes tendo explorado diferentes tipos desde os inteiros até os
exponenciais. Tratamos também das variáveis onde dissemos que eles são a forma de
referenciar um espaço da memória. As variáveis são capazes de armazenar diferentes
valores, mas um de cada vez. Ainda nesta aula falamos de palavras reservadas e tipos de
dados. Onde enfatizamos que as palavras reservadas são aquelas pré-definidas e que não
podemos usá-las como identificadores.
ACTIVIDADE 6
Para esta actividade leia sobre as regras de declaração de variáveis, constantes e tipos de dados
de formas a aprender a criar, definir e declarar identificadores:
1. Responda
a) Declare uma variável para armazenar a inicial do seu nome do meio.
b) Declare uma variável para armazenar a sua idade.
c) Declare uma variável para armazenar a sua altura.
d) Declare uma constante que guarde um número do intervalo (0 a 12).
e) Declare uma variável que contém um montante de capital (número real).
2. Escreva programas simples que lhe ajuda a aprender como usar variáveis, atribuir
valores a variáveis, usar os operadores e apresentar os resultados dos programas.
Usando o operador de atribuição, inicializar variáveis declaradas entre i e v e imprima os
seus valores.
3. Faça uma única instrução que;
- Lê um número inteiro x
- Lê um double y
- Lê um caractere
- Imprima um inteiro x
- Imprima um double y
- Imprima um caractere i
- Incremente x por 1

4. Usando tipos de dados, identificadores/constantes e operadores apropriados,

escreva um programa em C que lê dois valores, e pode fazer os seguintes: a soma dos
dois valores, o produto dos dois valores, divide a soma dos dois valores por 3 e apresente
os resultados no monitor.

AULA 7: CONVERSÃO DO TIPO, OPERADORES E EXPRESSÕES EM LINGUAGEM C

Introdução

o Realizar tarefas específicas usando princípios básicos de programação em C

 Criar uma expressão completa em C;
 Diferenciar vários tipos de operadores;
 Manipular os operadores segundo as necessidades do problema;
 Efectuar as conversões das expressões em C;
CONTEÚDOS DA AULA
7.1. Operadores e Expressões
Um operador é um símbolo ou letra usado para indicar e especificar uma operação em

variáveis num programa. Os operadores operam em itens de dados chamados
OPERANDOS. Alguns operadores requerem dois operandos e alguns em um só operando.
Portanto, as operações a serem realizadas com os dados podem ser determinadas por
operadores ou funções.
Para melhor percebermos o funcionamento de operadores, é necessário primeiro

entendermos o que é uma expressão. Portanto, uma expressão é uma combinação de
operadores e operandos. A cada expressão válida é atribuído um valor numérico. A
expressão válida em programação é uma completa. Isto é a que tem um significado válido.
Exemplo:
A expressão matemática 1+2 relaciona dois operandos (os números 1 e 2) por meio de um
operador (+) que representa a operação de adição/soma em que o valor é 3.
Vamos observar o exemplo dado, e pode-se verificar que ao nível de programação essa
expressão não é armazenada em memória, pois o seu resultado não é colocado em
nenhuma variável. Para ultrapassar isso é necessário utilizar operadores de atribuição.

A sintaxe é:
Identificador = expressão;
Exemplo de atribuição de um valor de uma expressão a uma variável.
a = 10;
areaCirc = 3.14 * raio*raio;
i=k;
Existem expressões que podem ser abreviadas. E a linguagem C permite a equivalência
das expressões abaixo:
EXPRESSÃO ORIGINAL EXPRESSÃO EQUIVALENTE

x=x+k; x+=k;
x=x-k; x-=k;
x=x*k; x*=k;
x=x/k; x/=k;
x=x>>k; x>>=k;
x=x<<k; x<<=k;
x=x&k; x&=k;
Voltando aos operadores, os operadores podem ser classificados por categorias

nomeadamente:
● Operadores de atribuição;
● Operadores aritméticos;
● Operadores relacionais;
● Operadores lógicos;
● Operadores bit a bit e;
● Operadores especiais;
7.1.1. Operadores de atribuição

Este é o operador usado para transferir o resultado de uma expressão para uma variável.
Em C este operador é o sinal (=).
Exemplo:
soma = a + b;
pi = 3.1416;
a=b=c=1;
7.1.2. Operadores aritméticos

Os operadores aritméticos são usados para desenvolver operações matemáticas. A seguir

apresentamos a lista dos operadores aritméticos do C:
OPERADOR ACÇÃO EXEMPLO

+ Soma (inteira e real) soma = a+b;
- Subtracção (inteira e decima) saldo = saldo – debito;
Para saber sobre
* Multiplicação (inteira e decimal) preco = quant * preco operadores leia a
obra
/ Divisão (inteira e decimal) media = soma/n; Kernighan, B. W.,
Ritchie, D. (1988).
% Resto da divisão (inteira) resto = num / x;
The C Programming
++ Incremento I++; ou ++i; Language -the ANSI
edition, Pearson
-- Decremento - - i; ou i - -; Prentice Hall.
O operador de incremento unário (++) incrementa de 1 o seu operando. Ou seja, se nós

quisermos aumentar em 1 o valor de uma variável x, podemos fazer x=x+1; ou escrever
simplesmente x++;. De forma análoga, o operador de decremento unário (--) decrementa
de 1 o seu operando. Ou seja, se quisermos diminuir de 1 o valor de uma variável x,
podemos fazer x=x-1; ou escrever simplesmente x--;. Esses dois operadores são
designados unários em outros manuais.
O operador % retorna o resto da divisão de inteiros. Neste caso se pretendermos

armazenar o resto da divisão de uma variável x por uma constante qualquer ou por uma
outra variável, usamos a expressão y = x % n; onde n toma qualquer valor.
Devemos evitar a utilização de operadores unários em expressões aritméticas, pois seu

uso pode dificultar o entendimento da expressão. Assim, recomendo a utilização desses
operadores apenas em ocasiões em que se deseja apenas incrementar ou decrementar o
operando; não utilizá-los em meio a expressões.
7.1.3. Operadores relacionais

Refere-se às relações que os valores podem ter uns com os outros (geralmente, retorna
um valor V ou F). Em C, existe um conjunto de seis operadores relacionais, os quais
podem ser usados na avaliação das expressões.
OPERADOR SIGNIFICADO
> Maior que
< Menor que
>= Maior ou igual a

<= Menor ou igual a

!= Diferente de
== Igual a
Uma expressão que contenha um operador relacional devolve sempre como resultado o
valor lógico (verdade (1) ou FALSO (0).
• Exemplo 1: Tendo duas variáveis, A = 5 e B = 3:

# EXPRESSÃO RESULTADO VALOR
1 A == B Falso 0
2 A != B Verdadeiro 1
3 A>B Verdadeiro 1
4 A<B Falso 0
5 A >= B Verdadeiro 1
6 A <= B Falso 0
Exemplo 2:
int a = 10, b = 1, c = 12;
a > b + c;
O resultado da expressão acima é: Falso
7.1.4. Operadores lógicos:

Os operados lógicos servem para interligar mais de uma operação relacional. E assim
como os relacionais retornam zero para falso e um para verdadeiro.
OPERADOR DESCRIÇÃO Sintaxe
&& AND (conjunção) (expA && expB)
|| OR (disjunção) (expA || expB)
! NOT (operador de negação) ! expA ou ! expB
Exemplo: Considere os valores de p e q. Faça a tabela de verdade.

P Q (P&& Q) (P || Q) !P
0 0 0 0 1
0 1 0 1 1
1 0 0 1 0
1 1 1 1 0
As operações lógicas funcionam como operações aritméticas na base 2.

AND, é igual a operação de “multiplicação” 1 X 1 =1; 1 X 0 = 0; etc.

OR, é igual a operação de “soma”: 1 + 1 = 1; 1 + 0 = 1; 0 + 0 = 0; etc.

NOT, é o inverso: 1 = 0; 0 = 1
7.1.5. Operadores bit a bit

Refere-se a testar, atribuir ou deslocar os bits efetivos de um byte ou uma palavra.
OPERADOR SIGNIFICADO
^ XOR
~ Complemento de um
Para saber sobre
>> Deslocamento à esquerda operadores leia a obra
Kernighan, B. W.,
Ritchie, D. (1988). The
<< Deslocamento a direita
C Programming
Language -the ANSI
edition, Pearson
Prentice Hall.
Exemplo:
Como podemos observar, nesta matemática aplicamos as regras da tabela da verdade.

Onde que para o AND, (1 && 0 = 0) e (1 && 1 = 1). Seguindo essa lógica para os demais
operadores, é possível manipular os dados com mais facilidade e de uma forma rápida.

7.1.6. Operadores especiais

Para além dos operadores comumente usados em expressões, C possui vários outros
operadores nomeadamente:
sizeof, operador ternário (? : ), operador de endereço (&), valor no endereço (*) e ponto
(.).
7.1.6.1. Operador de endereço
O operador de endereço (&) quando colocado antes da variável, retorna o endereço da

localização da memória onde a variável é armazenada. Geralmente é usada com a função
scanf() e na inicialização do ponteiro.
Exemplo: int x, *y; y = &x; printf(“%d”, *y);
7.1.6.2. Valor no operador de endereço (*)
Este também pode ser chamado como operador de indireção. o item de dados
representado por x também pode ser acessadido pelo *y, onde * é operador unário que
opera apenas com ponteiros.
Exemplo: int y = 10; printf(“%d”, &y);
Resultado: Retorna o endereço do sector da memória onde é armazenado o valor 10 ou

por outras, o endereço da variável y.
7.1.6.3. Operador sizeof (sizeof())

Retorna o tamanho do seu operando em bytes. Este operador também procede o seu
operando. A sua sintaxe é: sizeof(expressão);
Exemplo: int y; printf(“O tamanho da variável y é %d butes.”, sizeof(y));
Resultado: O tamanho da variável y é 2 bytes.
7.1.6.4. Operador condicional ou ternária (? :)

Este operador (? : ) é a forma condessada da expressão if then else do C.
exp1? exp2:exp3

int a= 6, b =8, big;

big = (a > b) ? a : b;
Neste exemplo, o resultado será o maior entre os valores das duas variáveis.
7.1.6.5. Operador ponto (.)

Este operador é usado para aceder elementos de estruturas ou uniões.
Sintaxe: expessao.expressão1;
Exemplo:
struct baseDeDados
{
int codigol
char nome[10]
};
Para aceder os elementos código e nome deve ser através do operador ponto. E procede-
se desta forma.
struct baseDeDados x;
x.codigo = 10;
x.nome=”ISEAD”;
Onde struct é a palavra reservada que ajuda nos a desenhar estrutura e baseDeDados
trata-se de um nome dado a estrutura. O x é a variável criada para manipular as variáveis
da estrutura. Pode-se considerar x como cópia da estrutura.
7.2. Conversão do tipo

Existem situações em programação onde exige se que uma variável recebe um tipo de
dado diferente do que foi atribuído no acto da sua declaração. Nestas situações há
possibilidade de se provocar um overflow na variável em questão. Esta operação pode até
provocar um runtime error. Assim, como medida de prevenção dessas ocorrências, em C
podemos ultrapassar esses contrangimentos usando as técnicas de conversão do tipo.
Existem duas formas de conversão: a conversão implícita e explícita.
7.2.1. Conversão implícita

A conversão de tipo implícita, também conhecida como coerção, é uma conversão de tipo
automática pelo compilador. Em uma expressão de tipo misto, os dados de um ou mais

subtipos podem ser convertidos para um super-tipo quando necessário em tempo de

execução, de forma que o programa seja executado correctamente.
Exemplo:
double d;
long l;
int i;
if (d > i) d = i;
if (i > l) l = i;
if (d == l) d *= 2;
A conversão é temporária e segue a hierarquia de tipo, na qual o operador de menor tipo é

convertido para o de maior, que passará a ser o tipo da expressão.
Isto é:
int < unsigned < long < unsigned long < float < double
7.2.2. Conversão explícita (Cast)

As conversões explícitas exigem um operador cast. A conversão é necessária quando as
informações podem ser perdidas na conversão ou quando a conversão pode não funcionar
por outros motivos. Exemplos típicos incluem a conversão numérica para um tipo que tem
menos precisão ou um intervalo menor e a conversão de uma instância de classe base
para uma classe derivada.
No entanto, se uma conversão não puder ser realizada sem o risco de perda de
informações, o compilador exigirá que se execute uma conversão explícita, que é chamada
de cast. Uma conversão é uma maneira de informar explicitamente ao compilador que
pretendemos fazer a conversão e que estamos cientes de que poderá ocorrer perda de
dados. Para executar uma conversão, especifique entre parênteses o tipo para o qual
estamos convertendo, na frente do valor ou da variável a ser convertida.
Sintaxe:
Identificador = (tipo_de_dado_pretendido) resultado da expressão;

Exemplo:
double y;
int x = (int)y;
Nesta linha estamos informando ao compilador que pretendemos armazenar o conteúdo da
variável y, mas convertido a inteiro.
7.3. Hierarquia dos operadores

Na tabela abaixo apresentamos, os operadores estão em ordem decrescente de prioridade:
os operadores da primeira linha executados em primeiro lugar e os operadores da última
são executados por último.
OPERADOR ORDEM DE EXECUÇÃO

() [] -> . Esquerda - Direita
- ++ -- ! & * ~ (type) sizeof Direita - Esquerda
* / % Esquerda - Direita
+ - Esquerda - Direita
<< >> Esquerda - Direita
< <= >= > Esquerda - Direita
== != Esquerda - Direita
& Esquerda - Direita
^ Esquerda - Direita
| Esquerda - Direita
&& Esquerda - Direita
|| Esquerda - Direita
?: Direita - Esquerda
= op= Direita - Esquerda
, Esquerda - Direita
RESUMO DA AULA

Na aula de hoje tratamos de quatro conceitos fundamentais de programação: (i)

expressões, (ii) operadores, (iii) conversão do tipo e (iv) hierarquia de operadores.
Discutimos sobre operandos e operadores com mais detalhes para operadores tais como:
aritméticos, relacionais, lógicos, bit a bit, atribuição, e especiais. Discutimos também sobre
a conversão do tipo de dados onde falamos das duas formas de conversão: a conversão
automática (conversão implícita) e o casting (conversão explicita) e diferenciamos as duas
formas de conversão. Por fim falamos sobre a hierarquia de operações.
ACTIVIDADE 7
1) O que são operadores? Lista vários tipos de operadores estudados;
2) O que entendes por uma expressão. Explica sobre os seus componentes.
3) Debruce sobre tipo de conversão. De exemplos em forma de programa;
4) Fale exclusivamente dos operadores unários. Qual é a sua aplicação?
5) O que entendes por hierarquia de operadores. Como isso acontece?

722-475-3
TEXTOS:
UNICAMP.


Esta actividade instruiu-lhe como instalar e executar um programa usando o Dev C++,
recomendamos a usar a versão mais recente. Também permitiu conhecer as formas de
definir e declarar variáveis e utilizar de forma adequada os vários tipos de dados e os
operadores mencionados nesta unidade. Possibilitou o entendimento de vários operadores
e quando aplica-los em exercícios específicos.




acima.
1. Defina os seguintes termos:
a) Tipo de dados
b) Variável
c) Operador
d) Identificador
e) Caractere
2. Identifique as regras que são seguidas quando se usa um identificador?
3. Por que é importante entender como usar os tipos de dados num programa?
4. Várias linguagens de programação incluindo o C suportam muitos operadores. Liste

estes operadores, dê exemplos, sua associatividade e como é que são aplicados?
5. O que é um operador ternário? Mostre a sua sintaxe?
6. Liste três tipos de dados primários e secundários?
7. Qual é a diferença entre o operador de incremento e um operador de decremento?
8. Discuta os quatro tipos de constantes?
9. Descreva três maneiras de definir constantes. Use a linguagem C, escreva um

programa para ilustrar como as constantes são declaradas com a utilização dos três
métodos?
UNIDADE TEMÁTICA III: INSTRUÇÕES DE CONTROLO E FUNÇÕES

Introdução geral
Nas duas unidades anteriores vimos conceitos que possibilitam nos trabalhar
com a linguagem C na resolução de tarefas simples.
Os programas até aqui desenvolvidos apresentam um modelo top-down. Mas

no entanto, um programa não se limita apenas ao fluxo sequencial de controlo,
porque em algum momento, um programa pode decidir usar um caminho
particular de instruções ou pode repetir um determinado número de vezes
uma instrução, enquanto uma condição é verdadeira.
Portanto, outros tipos de manipulação ou representação de controlo de fluxo

na programação incluem, selecção, repetição e saltos. Outras situações são
das que estamos diante de um problema complexo, ai precisamos de arranjar
um mecanismo para fragmentar esse problema em pequenas porções
automatizadas. E isso é só possível utilizando a modularidade.
Portanto, nesta unidade vamos aprender a usar as estruturas de selecção,

repetição, saltos e funções.
A unidade será composta de quatro aulas. Na primeira aula vamos discutir

sobre estruturas de decisão onde iremos aprender como instruir um programa
a agir mediante uma condição. Na segunda vamos debruçar sobre estruturas
de repetição e saltos. E na terceira e quarta aula iremos discutir sobre a
modularização.

AULA 8: ESTRUTURA DE CONTROLO- ESTRUTURA DE DECISÃO

Introdução
• Compreender a aplicação das estruturas de decisão

• Definir as estruturas condicionadas;
• Aplicar as diferentes estruturas de selecção;
• Fazer programas complexos com ajuda dos comandos if e switch;
• Diferencias a aplicação segundo a necessidade do problema
CONTEÚDO DA AULA
Como referimos na introdução da unidade, na execução de um programa podemos

encontrar várias formas na execução de um programa. Cada forma de execução do
programa tem a sua filosofia do funcionamento. Nesta aula vamos tratar da estrutura de
selecção ou decisão.
As estruturas de selecção são também conhecidas como estruturas condicionais ou de
decisão. São técnicas de programação que conduzem a estruturas de programas que não
são totalmente sequenciais. Uma estrutura de selecção permite a escolha de um grupo de
acções a ser executado quando determinadas condições, representadas por expressões
lógicas, são ou não satisfeitas
Uma condição é formulada com o uso de operadores relacionais.
8.1. If simples
A primeira estrutura de selecção que iremos conhecer é o if. O if é utilizado quando

estamos perante uma condição. O bloco de código referente só será executado se a
condição for verdadeira.

Sintaxe Fluxograma
Figura 11: Fluxograma do if
Onde a condição é uma expressão lógica.

Exemplo:
Neste exemplo, lemos do usuário a variável número. Se o resto da divisão do conteúdo da

variável for igual a zero, será mostrada na tela a frase O número introduzido é par. A
partir disso, podemos criar condições para o nosso programa, executando determinadas
tarefas somente se algumas condições forem satisfeitas
A instrução if() pode levar chavetas { } ou não, dependendo de números de instruções a

serem executadas quando a condição é satisfeita.
No caso de uma instrução apenas, como no nosso exemplo, não é obrigatório colocar
chavetas { } . Mas, tratando-se de um bloco composto devemos coloca-las.
Exemplo:

Caso de uma única instrução
Caso de várias instruções.
8.2. If … else
É uma extensão da instrução if. A sua sintaxe é:
Sintaxe Fluxograma
Figura 12: Fluxograma de if..else
Voltemos a analisar o exemplo da instrução if. Apenas nos apresenta o resultado quando o
numero num for par, mas e se, por exemplo o número num não fosse par?
Ele seria ímpar… mas como faríamos isso no programa? A estrutura do if é composta
do else, que é executado caso a condição do if não seja satisfeita. A seguir temos o
exemplo.

As mesmas regrais quanto as chavetas são aplicáveis para esse caso.
8.3. if aninhados ou encadeadas

Quando uma série de decisões estão envolvidas, podemos ter que usar mais de um if …
else.
Portanto o if aninhado pode ser usado como alternativa para situações em que temos mais
que uma condição por testar.
A sua sintaxe é:
Sintaxe Fluxograma
Figura 13: Fluxograma if aninhado
Portanto, o bloco de instruções podem ser várias outras instruções ifs.

Resumindo, o if aninhado, é apenas ifs dentro de if.
Exemplo: Faça um programa que recebe três valores e determina qual é o maior dentre
eles.

8.4. Comando switch
Comando switch é uma estrutura de decisão múltiplo controlo que permite que os valores
sejam testados de uma lista de valores até encontrar uma correspondência que retorna
resultados. Esta instrução é outro modo para simular o uso de varias instruções if e pode
somente verificar uma relação de igualdade. Todos os tipos primitivos (int, string, etc)
podem ser usados nas instruções switch/case.
Sintaxe Fluxograma
Figura 14: Fluxograma de Swith .. Case

Exemplo
Faça um programa que informa sobre os dias da semana por extenso mediante a inserção
do número equivalente.
A instrução break é fundamental para forçar a paragem da execução da instrução

seleccionada. Caso não exista o programa executa todas as instruções a partir do
seleccionado até ao final do case. Desta forma é quase que crucial neste comando de
selecção.
RESUMO DA AULA
Aprendemos sobre estruturas de selecção onde destacamos a utilidade de

cada um deles. O if é usado quando um bloco deve ser executando apenas se uma
condição for verdadeira, o if … else usamos quando uma condição implica a execução de
um ou outro bloco. Sempre quando houver duas condições mutuamente exclusivas. E o if
… else if .. else if … usamos para testar intervalos de valores, ou valores que são
contínuos ou podem variar num intervalo não finito; para verificar várias condições, entre as
quais existe uma prioridade para atender somente a primeira condição que for verdadeira e
pode também tratar diversas condições (não necessariamente mutuamente exclusivas). E
por fim vimos a switch (..) que é usado exclusivamente para testar uma expressão que

gere valores discretos, usado também em situações nas quais deve ser realizado um
mesmo processamento para várias condições quando o número de possibilidade for
razoavelmente grande e finito.
Portanto não existe uma regra específica para se escolher uma estrutura ou outra. Em
alguns casos, poder-se-ia utilizar qualquer uma destas estruturas.
ACTIVIDADE 8
Para realizar esta actividade o estudante deve ter acompanhado atentamente a

aula 8. E deve também reescrever os programas apresentados nos exemplos para facilitar
a compreensão. Recomenda-se também que faça o uso dos recursos bibliográficos
existentes no fim unidade ou outros existentes em outras fontes seguras. Esta actividade
pode ser realizada em grupo ou individualmente.
1. Explica o que são estruturas de controlo? Lista várias estruturas de controlo usadas em
C.
2. Estabeleça a diferença entre if, if .. else, if … else if e switch( .. );

3. Entre if ..else e switch .. case, qual das duas instruções é mais eficiente?
Actividade prática
1. Faça um programa que recebe o ano pela teclado e determina se é comum ou bissexto.
2. Faça um programa que leia três valores distintos a serem digitados pelo utilizador, determine e exiba
o menor deles.
3. Faça um programa que leia o salário bruto e calcule o salário líquido. Para esse programa, o salário
líquido será o salário bruto menos os descontos de INSS e IR, seguindo as regras:
 Caso o salário seja menor que 1.5000,00 MT não devemos descontar IRPS e
descontaremos 8% de INSS;
 Para salários a partir 1.5000,00 MT descontaremos 5% de IRPS e 11% de INSS.
AULA 9: ESTRUTURA DE CONTROLO- ESTRUTURA DE REPETIÇÃO OU LAÇO


 Discutir sobre estruturas de repetição;

 Compreender a utilização de estruturas de repetição em C.
 Conhecer os tipos de estruturas de repetição e avaliar quando utilizá-las;
 Saber combinar estruturas de repetição com outras estruturas de controlo na
execução de tarefas,
CONTEÚDO DA AULA
9.1. Estruturas de repetição

As estruturas de repetição ou laços são técnicas de programação que permitem que um
bloco de instruções seja executado várias vezes até que uma determinada condição seja
satisfeita. Assim essas estruturas são compostas por uma condição e um conjunto de
instruções a serem executados enquanto a condição não for satisfeita. A linguagem C
suporta três (3) estruturas de repetição nomeadamente: o While, For e Do…While.
9.1.1. Comando While:

O while é a estrutura de repetição mais simples. Ele repete a execução de um bloco de
sentenças enquanto uma condição permanecer verdadeira. Na primeira vez que a condição
se tornar falsa, o while não repetirá a execução do bloco, e a execução continuará com a
sentença ou comando que vem logo após o bloco do while, na sequência do programa.
O valor de condição é calculado como verdadeiro ou falso. Isto é, se a condição for
verdadeira o comando é executado e se a condição for falsa, então o while é encerrado.
A sintaxe é:
while(condição)
{
Comando(s);
}
Como a palavra sugere, enquanto a condição for verdadeira, o comando é
repetido.
A condição é sempre avaliada antes da decisão de se executar o bloco de

sentenças novamente.

Como funciona?
1. O valor de condição é calculado como verdadeiro ou falso

2. Se a condição é verdadeira:
i. O comando é executado
ii. Volte ao passo (1.)
3. Se a condição é falsa, então o while é encerrado.
Exemplo: Faça um programa que imprime o valor de 1 a 10 no monitor.
Declaramos a variável x que controlará o while. Ela armazena o valor a ser impresso. A
expressão do while verifica se o x está dentro do limite desejado (x <=10). No início, a
variável x contém o valor 1 e, portanto, a expressão do while é satisfeita. O bloco de
expressões é executado, imprimindo o valor de x e aumentando seu valor em uma unidade.
Note que isto afecta a condição que controla o bloco. Nas próximas repetições, a
expressão será verdadeira para os valores de x 2, 3, 4, …, 9 e 10. Quando x armazenar o
valor 11, a expressão que controla o while se tornará falsa. Nesse ponto, o while termina,
encerrando as repetições. No final da execução, o valor da variável x estará em 11, que foi
justamente o valor que tornou a expressão falsa, impedindo uma nova execução do bloco
while.
A condição deverá ser colocada, obrigatoriamente, entre parênteses. Quando o bloco da

estrutura while contém apenas uma única sentença, pode-se omitir as chaves que
delimitam o bloco.
O programa sempre executa o bloco de sentenças completo. Mesmo que durante uma
execução do bloco a condição se torne falsa, o programa só verificará este facto quando
avaliar novamente a expressão, preparando para uma nova repetição.

9.1.2. Estrutura de repetição for:

O ciclo for é uma estrutura de repetição muito utilizada nos programas em C. É muito útil
quando se sabe de antemão quantas vezes a repetição deverá ser executada. Este laço
utiliza uma variável para controlar a contagem da repetição/loop, bem como seu
incremento. Trata-se de um comando bem enxuto, já que própria estrutura faz a
inicialização, incremento e encerramento do laço.
A sua sintaxe é:
for(inicialização; condição; actualização)
{
Comando(s);
}
Inicialização: Atribui um valor inicial à variável contadora.

Condição: Verifica uma condição antes de decidir se executará o bloco de sentenças.
Caso a condição seja falsa, interrompe as repetições.
Actualização: Actualiza a variável contadora para o próximo valor. A actualização pode ser
um incremento ou decremento.
Comando(s): Executa o bloco de instruções.
Exemplo: Imprima todos os números pares num intervalo de 1 a 100.

Na linha 5 tem a instrução for, onde i
inicializa se por 1 através da expressão
i=0; de seguida temos a condição i<100.
Esta condição é executada no fim de
toda operação apenas para testar se o i
ainda é inferior a 100. E por fim a
expressão i++ equivalente a i+1.
Um for sempre está acompanhado de uma variável contadora que armazena quantas
vezes o bloco de sentenças do for deve ser executado. O seu cabeçalho agrupa todas as

instruções mais importantes que controlam a execução do for: a inicialização, o

teste/condição e a actualização. O programador é obrigado
a declarar toda a lógica de execução em uma única linha e de uma só vez.
Toda a estrutura for é equivalente a um while. A escolha entre uma estrutura ou outra é
uma questão de gosto e estilo de programação.
Note a ordem correta das declarações no cabeçalho: inicialização, teste/condição e

actualização! Não esqueça do ponto-e-vírgula (;) separando as declarações. Todo o
cabeçalho deverá estar obrigatoriamente entre parênteses.
9.1.3. Estrutura de repetição do … while

Esta estrutura tem um comportamento muito semelhante ao while, com uma diferença
crucial: a condição é verificada após executar o bloco de instruções correspondente.
Sintaxe:
do {
Comando(s);
} while(condição);
A condição é uma expressão que controla o do...while. Executa-se o bloco de sentenças,

independentemente da condição. Somente então a expressão é avaliada. Caso ela seja
não nula (verdadeira), então todo o bloco de sentenças será executado novamente. Este
processo se repete até que a expressão resulte em zero (falso). A expressão é sempre
avaliada depois da execução do bloco de sentenças. A condição deverá ser colocada,
obrigatoriamente, entre parênteses. Nota que diferente do while simples, Deve-se colocar
ponto-e-vírgula após a expressão.
Exemplo, tomando em consideração o exercício realizado no while, refaça-o usando o

do … while

Declaramos uma variável x que

controlará o do...while. Ela
armazena o próximo valor a ser
impresso. A expressão verifica se o
x está dentro do limite desejado (x
<=10). O bloco de sentenças é
executado, imprimindo o valor de x e
aumentado seu valor em uma
unidade.
Após executar o bloco, a expressão verifica se a variável x contínua dentro do
limite permitido. Caso afirmativo, o bloco é executado novamente. Assim, o bloco é
executado quando x armazenar 1, 2, 3,..., 9 e 10
As diferenças entre a estrutura while e do...while é sútil. Ela está no momento quando a
condição de repetição é verificada: antes ou depois de executar o bloco de sentenças. A
escolha dependerá do bom senso do programador, que optará pela estrutura que deixar o
algoritmo mais simples e legível.
Quando o bloco da estrutura do...while contém apenas uma única sentença, pode-se omitir
as chaves que delimitam o bloco.
9.2. Estruturas de Saltos: Break e continue
9.2.1. Interrupção ou Break

O comando break é um modo conveniente de terminar imediatamente a execução de um
bloco controlado por uma estrutura de repetição, sem necessidade de esperar a próxima
avaliação da condição. O comando break é útil para interromper a execução de uma
estrutura de repetição quando fica evidente que as demais repetições não produzirão
novos resultados. Assim, o programa pode economizar algum tempo de execução.
O break pode ser aplicado em qualquer uma das estruturas de repetição e a sua sintaxe é:
Break no while Break no for Break no do … while
while(condição) for(inicialização; do{
{ teste; actualização) Instruções;

Instruções; { If(condição)
if(condição) Instruções; {
{ If(condição) Break;
Break; { }
} Break; Instruções;
Instruções; } } while(condição)
} Instruções;
}
O uso do comando break costuma estar associado à uma estrutura condicional if para que
a interrupção seja realizada somente sob determinadas condições excepcionais.
Exemplo: Escreva um programa que que imprime o primeiro dígito divisível por 2 e 3.
Resolução
A variável x armazena valores
incrementados pelo ciclo de
repetição do... while. A instrução
if da linha 6, vai controlando se o
resto da divisão do x por 2 e x
por 3 é verdadeira. (Lembra-se
do funcionamento do operador
lógico (&&).Uma vez sendo
verdade, a expressão de output
printf(“%d\n”, x) é executada. Logo após a sua execução, segue o break que força a
interrupção do ciclo. E o resultado será o 6.
9.2.2. Reinicialização ou Continue

O comando continue reinicia imediatamente a execução de um bloco de uma estrutura de

repetição. O continue não espera o término da execução do restante do bloco. No caso do
while, a execução retorna imediatamente para avaliar a expressão, antes de executar
novamente o bloco, se for o caso. Se a expressão avaliar como falso, então o while é
finalizado, caso contrário ele realiza uma nova iteração.
Para o for, o continue interrompe a execução normal do bloco, realiza imediatamente a
actualização das variáveis de controle para, em seguida, realizar novamente o teste. Se o
teste resultar em falso, então o for é finalizado, caso contrário ele realiza uma nova iteração.
Enquanto no do...while, o continue simplesmente inicia uma nova iteração, no início do
bloco. O comando continue é útil para avançar para a próxima repetição quando fica
evidente que a execução actual do bloco não se faz mais necessária.
Break no while Break no for Break no do … while
while(condição) for(inicialização; do{
{ teste; actualização) Instruções;
Instruções; { If(condição)
if(condição) Instruções; {
{ If(condição) continue;
continue; { }
} continue; Instruções;
Instruções; } } while(condição)
} Instruções;
}
Exemplo: Faça um programa que gera números entre 1 a 100 e imprima apenas os
números divisíveis por 5.
Resolução
Programa Resultado

Como pode-se verificar, a

instrução continue faz o
inverso do que a instrução
break faz.
Enquanto a condição colocada
for verdadeira, a execução é
transferida até o ponto inicial e
ignora toda a instrução que está
por baixo do continue.
RESUMO DA AULA
Nesta aula vimos as estruturas de repetição. Em C existem apenas três: o

while, do .. while e for. Um programa pode ser escrito correctamente tanto com while,
como com do...while como com for. A escolha da estrutura cabe ao programador, que deve
preferir aquela que produz código mais simples e fácil de entender. O while executa o
bloco apenas enquanto uma condição for verdadeira. Se a condição for falsa logo no início,
o bloco não é executado nenhuma vez. Por sua vez o do .. while executa o bloco pelo
menos uma vez e a posterior avalia a condição se é verdadeira ou não. Caso seja falsa não
haverá a segunda execução e o for executa o bloco um certo número de vezes, controlado
por uma variável contadora. Para além das estruturas de repetição vimos também as
instruções continue e break. Alguns autores consideram-nas estruturas de salto. Tanto o
break como continue são associados às estruturas de selecção para a sua execução. O
break serve para interromper o laço caso uma determinada condição seja satisfeita e o
continue usamos para reinicializar o ciclo também quando uma determinada condição for
satisfeita.
ACTIVIDADES 9
Responda esta actividade como forma de consolidar os conhecimentos

adquiridos na aula. Para o sucesso na realização desta actividade, o estudante deve ler as
bibliografias recomendadas na parte final desta unidade.
A actividade pode ser realizada em grupo ou individualmente.
1) O que entendes sobre laço ou repetição? Descreva duas formas de laço.

2) Qual é o número mínimo de execução que uma instrução do….while realiza?
Compare-a com o while e for.
3) Explique qual é o propósito da instrução for? De exemplos práticos em forma de
programa do for.
4) Descreva a(s) diferenças entre break e continue.
Actividade prática em grupo
1) Escreva um programa que soma os dígitos de um determinado numero inteiro.

2) Escreva um programa que calcula factorial de um número positivo inteiro.
3) Escreva um programa que recebe um número n e um dígito d, e verifique se o dígito
introduzido existe no número n?
4) Escreva um programa que imprime todos números primos entre 2 a 100 com excepção de
números entre 20 a 30.

AULA 10: FUNÇÕES:

 Discutir sobre a programação modular

 Compreender a utilização de funções em C.
 Saber diferenciar funções de biblioteca e funções definidas pelo utilizador,
 Saber definir uma função prototípica;
 Saber declarar e implementar uma função na resolução de problemas.
CONTEÚDO DA AULA
10.1. O que é uma função

Uma função é um bloco autónomo de instruções que realizam uma tarefa coerente do
mesmo tipo. Todo programa C pode ser pensado como uma colecção dessas funções.
Como observamos anteriormente, o uso de funções é algo como contratar uma pessoa
para fazer um trabalho específico para nós. Às vezes, a interacção com esta pessoa é
muito simples, às vezes o é complexo.
Suponha que temos uma tarefa sempre executada exactamente da mesma maneira.
Quando pretendemos que seja feito, vamos para o serviço e dizemos: chegou o período,
faça serviços de manutenção do veículo. Não precisamos dar instruções, porque o
mecânico conhece seu trabalho. E também não precisamos ser informado sobre como o
trabalho está pronto. Assumimos que o nosso veículo seria atendido da maneira usual, o
mecânico faz isso e é isso.
Imaginemos que uma operação tiver que ser realizada em vária partes distintos em um
programa, o programador codifica o mesmo conjunto de instruções quantas vezes for
necessário. Por exemplo, em um programa que calcula a área de triângulo em diferentes
partes de um programa, seria desperdiça do tempo e o esforço do programador para
codificar a mesma sequência de instruções sempre que for necessário. Esta actividade não
só aumenta o tamanho do programa, mas também acrescenta as chances de cometer
erros tipográficos.

Uma melhor maneira de alcançar o mesmo efeito, no entanto, seria usar subprogramas ou
funções. Um subprograma ou função é um nome dado a um conjunto de instruções que
podem ser chamadas por outro programa ou subprograma. Essa técnica simplifica o
processo de programação porque um único conjunto de instruções sob a forma de
subprograma está sendo usado para todas as instâncias no programa, mudando apenas
dados. Sempre que a tarefa for feita, o controle é transferido para o subprograma e após o
término da execução, o controle é transferido de volta para o fluxo normal do programa.
A forma geral da função é:
<tipo> nome (lista_de_argumentos)

{
Instruções;
}
Onde:
Tipo: é o tipo de valor a ser retornado pela função. Caso a função não retorne nenhum
valor, neste caso, devemos defini-la como void.
Todos programas em C consistem em uma ou várias funções, e uma dessas funções
obrigatoriamente deve ser main(), pois é a função main é o ponto de execução do
programa. Existem vários benefícios de uso de funções, desde a clarificação da lógica,
evitam a repetição do código que executa as mesmas tarefas, promovem a portabilidade,
reduzem o uso da memória, permitem a modularização e reduzem as linhas do código.
10.2. Classificação das funções em C

Basicamente existem dois tipos de funções em C:
• Funções de bibliotecas e;
• Funções definidos pelo utilizador.
10.2.1. Funções de bibliotecas:

Em linguagem c, existem várias funções de bibliotecas que são usadas para realização de
algumas operações e cálculos. Essas são pré-definidas no compilador da linguagem e
armazenadas em ficheiros especiais de bibliotecas. Se o pretendemos usar uma dessas
bibliotecas especiais, devemos incluir o respectivo ficheiro através da directiva #include.
Como exemplo, vamos supor que pretendemos usar as funções matemáticas, ai teríamos
que incluir o ficheiro math.h e operacionalizando devia ser: #include<math.h>. Após essa
linha de código podemos usar todos os tipos de funções pré-definidos de matemática que
estão contidos neste ficheiro.
10.2.2. Funções definidos pelo utilizador:

Uma função é um bloco autónomo de instruções que realiza tarefa específica e bem
definida especificada pelo usuário. A esse tipo de funções chamamos de função definida
pelo utilizador ou simplesmente de uma função. Como vimos anteriormente, as funções
pré-definidas resolvem problemas já padronizadas. Mas há situações em que pretendemos
resolver situações orientadas ao problema em questão, ai as funções de biblioteca não
podem nos ajudar. Daí que existem esse grupo de funções.
Abaixo podemos observar o uso deste tipo de funções.
As instruções 1 e 3 transferem a execução para as respectivas funções para a execução. E

as instruções 2 e 4 transferem a execução ao main após a execução total das funções
mensagem1() e mensagem2() respectivamente.

1. Programa em C é a colecção de uma ou várias funções;

2. A função é chamada quando o nome da função é seguido de ponto e vírgula (;)
main()
{
mensagem(); // Chamada de função
}
3. A função é definida quando o nome da função é seguido por par de chavetas e que no
interior tem uma ou mais instruções;
mensagem()
{
Instruções;
}
4. Qualquer função pode ser chamada por outras funções;

5. Uma vez criada a função, pode ser chamada várias vezes que pretendermos usa-la;
main()
{
mensagem();
printf(“Chamada de função mais uma vez”);
mensagem();
}
6. A ordem de chamada de função e a ordem de definição das mesmas podem ser

diferentes. Não existe uma sequencia obrigatória para definir e chamar as funções.
7. A função pode chamar a ela mesma. Quando estamos perante a essa acção chamamos
de recursão.
10.2.2.1. Definindo uma função

Em uma definição, como vimos na forma geral da definição, primeiro consiste em
colocar o tipo de dado do valor a ser retornado, seguido pelo nome da função e por fim
a lista de argumentos entre parenteses. A essa lista de argumentos chamamos de
argumentos formais. Os tipos de dado dos argumentos formais são declarados dentro
dos respectivos parenteses. Caso não haja nenhum argumento a ser recebido,
deixamos em branco como vimos na função mensagem ou ainda podemos colocar o
tipo void entre parenteses.

A função que não retorna nenhum valor declaramos como void. As instruções da
função são colocadas entre chavetas. Caso a função retorne qualquer tipo de dado, é
obrigatório usar a instrução return, a qual retorna um valor do mesmo tipo da
declaração da função.
Exemplo 1:
#include<stdio.h>
int main()
{
int a,b;
printf("A soma é %d",soma(a,b));
add(a,b);
return 0;
}
int soma(int x, int y)

{
return(x+y);
}
void add(int x, int y)

{
printf("A media é: %d",x+y);
}
Neste caso temos duas funções, que realizam as mesmas operações. A primeira
retorna um valor e a segunda não retorna. O x e y são designados de argumentos
formais enquanto o a e b são argumentos actuais.
A função add() e soma() tem formas diferentes de serem referenciados no main(). As
funções que retornam qualquer valor a função não são referenciadas directamente.
Devemos chamá-las e atribuir o seu valor a uma variável do mesmo tipo, ou usá-las
directamente em funções como printf() como pode ser visto no exemplo acima. Para as
funções que não retornam, essas são invocadas directamente, como pode ser visto no
exemplo da função add().
Exemplo 2: Um programa que soma três números através da função somaTres.

#include<stdio.h>
void main()
{

int n1,n2,n3,soma;
printf("Introduza o primeiro número:");
scanf("%d",&n1);
printf("Introduza o segundo número:");
scanf("%d",&n2);
printf("Introduza o terceiro número:");
scanf("%d",&n3);
soma = somTres(n1,n2,n3);
printf("A soma dos tres numeros e: %d",soma);
}
int soma(int x, int y, int k)

{
return(x+y+k);
}
RESUMO DA AULA
Nesta aula discutimos sobre funções. Iniciamos definindo o que é uma

função, a sua utilidade. Demostramos como declarar uma função em diferentes
situações. Diferenciamos as funções que podem ser encontradas em C, as de biblioteca
e as definidas pelo utilizador. Explicamos que um códogo fonte pode ter mil funções,
mas que entretanto uma função destas deve ser obrigatoriamente função main() que é o
ponto de execução do programa. Explicamos também que o main gerência toda
execução. Por fim vimos como invocar uma função definida pelo utilizador.
ACTIVIDADE 10

adquiridos na aula.
Para o sucesso na realização desta actividade, o estudante deve ler as bibliografias

recomendadas na parte final desta unidade.
1. O que entendes por função?

2. Explica por palavras suas as vantagens de uso de funções.

3. O que é a chamada de função? Como é feita?

4. Explica o propósito da instrução return. Demostre com exemplos claros.
5. O que entendes por funções de biblioteca? Qual é o seu propósito?
6. Qual é o significado do void quando é usado nas funções?
1. Faça uma função que imprime o seu nome e invoque-a ao main.

2. Faça uma função que recebe dois valores e imprima a soma dos mesmos. Apos a
implementação chame a função para a sua execução no main.
3. Escreva um programa que calcula factorial de um número usando a função factorial().

AULA 11: FUNÇÕES (VARIANTES, TIPOS DE VARIÁVEIS) :
• Discutir sobre as funções ou modularização em C

• Descrever variantes de funções definidas pelo utilizador;
• Discutir sobre a sua implementação;
• Conhecer as diferentes formas de passagem de argumentos;
• Diferenciar uma variável local da variável global
Conteúdo da aula
11.1. Variantes de Funções

As funções definidas pelo utilizador podem tomar diferentes tipos de acordo com os
argumentos e formas de retornos. A essas variâncias das funções chamamos de variantes.
C suporta quatro (4) tipos de variantes de funções:
• Funções com argumentos e que retornam valores;
• Funções com argumentos que não retornam valores;
• Funções sem argumentos, mas retornam valores e;
• Funções sem argumentos e não retornam valores.
Tipo de função Formula Geral exemplo

void nome() void add()
Funções sem { {
argumentos e não instruções; int a,b;
retornam valores } printf(“A soma é %d”,a+b);
}
int nome() int add()
Funções sem { {
argumentos, mas instruções; Int a,b;
retornam valores return 0; return (a+b);
} }
void nome(int, int) void add(int a, int b)
Funções com
{ {
argumentos que não
instruções; printf(“A soma é %d”,a+b);
retornam valores
} }
Funções com int nome(int, int) int add(int a, int b)
argumentos e que { {

retornam valores instruções; return (a+b);

return 0; }
}
Vamos analisar um exemplo completo que aplica as quatro variantes.

Faça um programa que implementa as operações básicas aritméticas.
#include<stdio.h>
int main()
{
int a,b;
a = 20; b=10;
printf("O produto é : %d",mult());
printf("A soma é : %d",soma(a,b));
div();
sub((float)a, (float)b); //conversão do tipo - explicito
return 0;
}
int soma(int x, int y) /*Função com argumentos e retorna*/

{
return(x+y);
}
int mult() /*Função sem argumento e retorna */

{
int x = 20,y = 10;
return(x*y);
}
void sub(float x, float y) //Função com argumentos e não retorna

{
printf("O resultado é %f",x-y);
}
void div() /*função sem argumentos e mão retorna*/

{
float x,y;
printf("Introduza os valores de x e y");
scanf("%f%f",&x,&y);
printf("O resultado é %f",x/y);
}
11.2. Passagem de argumentos para funções
Na comunicação entre funções podemos encontrar dois tipos de casos: A chamada por
valor e a passagem por referência. Em ambas situações, o número de argumentos actuais
deve ser obrigatoriamente igual ao número de argumentos formais.

11.3.1. Chamada por valor
A chamada por valor é uma técnica que consiste em passar apenas o valor das variáveis
da de uma função para outra, isto é, faz-se cópia do conteúdo dos argumentos actuais para
argumentos formais.
Exemplo: Usando chamada por valor, faça um programa que determina o maior valor entre
dois números.
#include<stdio.h>
int main()
{
int a,b;
printf(“O maior e valor é %d”,verifica(a,b));
return 0;
}
int verifica(int x, int y)

{
if(a>b)
return (a);
else
return (b);
}
Exemplo 2: Faça um programa que calcula o factorial de um número.
#include<stdio.h>
int fact(int); // Protótipo da função
int main()
{
int num, f;
printf(“introduza o numero”);
scanf(“%d”,&num);
f = fact(num);
printf(“Factorial de %d = %d” , f);
return 0;
}
int fact(int n) // Função que calcula factorial e retorna

{
int i, fi;
fl = 1;
for((i=1; i<=n; i++)
fl = fl * i;
return (fl);
}

11.3.2. Chamada por referência

Para entendermos melhor a essa forma de chamada, primeiro vamos verificar atentamente
esse exemplo:
#include<stdio.h>
int main()
{
int a,b;
a = 20; b=10;
printf("Antes da troca");
printf("A=%d, B = %d",a,b);
troca(a,b);
printf("Depois da troca");
return 0;
}
void troca(int x, int y)
{
int temp = x;
x=y;
y=temp;
}
Este programa parece estar muito bem, mas analisando um pouco mais a fundo, veremos
que a função troca não influencia no comportamento da variável a. Isto porque na
passagem por valores os argumentos formais e actuais comunicam-se através de cópias
de valores e não de referências. Assim, uma alteração nos argumentos formais não tem
nenhuma influência nos argumentos actuais vice-versa.
Como resultado do programa acima teremos:
Antes da troca
A = 20 B = 10
Depois da troca
A = 20 B = 10
Portanto, se pretendermos que as alterações feitas nos argumentos formais tenham efeito
nos argumentos actuais, devemos usar a chamada por referência.
Esta técnica consiste em passar a referência do argumento actual à função chamada.
Assim, o argumento formal e o actual partilham o mesmo espaço da memória.
Isso pode ser alcançado através do uso do operador do endereço (&) nos argumentos
formais e o operador do valor do endereço (*) no argumento formal.

Usando o mesmo exemplo de troca de valores de duas variáveis:
#include<stdio.h>
int main()
{
int a,b;
a = 20; b=10;
troca(&a,&b);
return 0;
void troca(int *x, int *y)

{
int temp = *x;
*x = *y;
*y = temp;
}
Nesta segunda versão, uma vez que os argumentos partilham o mesmo espaço de
memória, toda alteração que é feita nos argumentos formais tem influencia nos argumentos
actuais. Assim o resultado da segunda versão será:
Antes da troca
A = 20 B = 10
Depois da troca
A = 10 B = 20
Uma função normalmente so retorna um único valor de cada vez. Para ultrapassar essa
limitação, podemos usar a passagem por referência, uma vez que as variáveis podem ser
manipuladas usando referencias.
11.4. Variáveis globais e locais

As variáveis podem ser declaradas como variáveis locais ou globais dentro de uma
função. As variáveis locais são definidas dentro do bloco de código de uma função
particular. Essas variáveis podem ser usadas apenas por declarações que estão dentro
dessa função ou bloco de código, simplesmente porque elas não são conhecidas por
variáveis fora das funções.

Variáveis globais são definidas fora de todas as outras funções do programa. Como acordo,
elas são declaradas na parte superior do programa após as directivas de pré-processador,
mas antes da função main ().
Vamos aprender a usar correctamente as variáveis usando o seguinte exemplo:
#include <stdio.h>
/* declaração de variável global */
int a = 20;
int main ()
{
/* declaração de variável local na função main */
int a = 10;
int b = 20;
int c = 0;
printf ("valor de a no main() = %d\n", a);
c = sum( a, b); //parâmetros actuais (a, b)
printf ("valor de c no main() = %d\n", c);
return 0;
}
/* função para somar dois inteiros */
int sum(int a, int b) //Parâmetros formais (int a, int b)

{
printf ("valor de a em sum() = %d\n", a);
printf ("valor de b em sum() = %d\n", b);
return a + b;
}
RESUMO DA AULA
Nesta aula discutimos três fundamentos muito importantes em programação.

(i) as variantes de funções - estes ajudam-nos na passagem de dados de uma função para
outra. É através das variantes que decidimos como a comunicação entre as funções vai ser
feita, se a função deve ou não retornar um valor e ajudam nos a reduzir as linhas do código
e a redução de ocupação da memória.
Depois falamos da passagem de argumentos. C suporta apenas duas formas de passagem

de argumentos. A passagem por valor e a passagem por referência. É de extrema
importância saber diferenciar estas duas formas de passagem. Passando os argumentos
por valor significa que durante o runtime quando a função é invocada, os argumentos
formais recebem a cópia do conteúdo dos argumentos actuais, isto é, os argumentos

formais e actuais ocupam espaços diferentes, o que significa a exigência da duplicação dos
espaços da memória, enquanto a passagem por referência os argumentos formais e
actuais ocupam o mesmo espaço, fazendo que qualquer alteração em variáveis em
questão significa a mudança do conteúdo da outra. E por fim tratamos de um conceito
tratado na unidade dois as variáveis. Onde classificamos estas em variáveis globais e
locais. As globais são aquelas que tem a vida durante toda execução do programa,
enquanto as locais são aquelas definidas dentro das funções e são visíveis apenas no
bloco onde são criadas.
ACTIVIDADES 11

adquiridos na aula.
Para o sucesso na realização desta actividade, o estudante deve ler as bibliografias

recomendadas na parte final desta unidade.
1) O que entendes por protótipo de uma função?

2) Explica por palavras suas a passagem por referência e a passagem por valor. Qual é
a vantagem duma técnica comparando com a outra
3) Falamos de variáveis globais e locais. Como distinguir uma da outra? Faça um
programa para exemplificar.
4) Em C, as funções só podem retornar um valor de cada vez. De que formas podemos
forçar com que retorne mais que um valor?
4. Refaça as actividades práticas da aula 10 de formas que os dados sejam inseridos no main.

722-475-3

TEXTOS:
UNICAMP.

Esta actividade habilitou-lhe a programar usando técnicas de desvio e modularização.
Também permitiu conhecer as formas de definir e declarar variáveis locais e globais, a
saber utilizar de forma adequada os vários tipos de fincões desde as de biblioteca até as
definidas pelo utilizador e ajudou-lhe a saber resolver problemas específicos de acordo
com um pensamento lógico de programação.




acima.
1. Declare uma variável inteira chamada total e inicialize-a a zero (0)?
2. Declare um caractere chamado inicial e inicialize com a letra K?
3. Use a palavra-chave “const”, declare o PI e atribui-lhe o valor de 3,14?
4. Defina a constante PI com valor de 3,14?
5. Atribua o valor da variável inteira a para uma variável b.
6. Guarde a soma de duas variáveis c e e na variável soma.
7. Adicione o valor de a e o valor b e coloque a resposta em a?
8. Divida o valor da soma por 9 e guarde a resposta na variável soma?
9. Leia um valor inteiro para y?
10. Leia um caractere para c?
11. Guarde a divisão de uma variável inteira por 5 numa variável do tipo “float” de nome
comissão.
12. Escreva um ciclo while para imprimir os valores de 1 a 15 no monitor.
13. Escreva um ciclo for para imprimir os valores de 3 a 7 no monitor.
14. Escreva um ciclo for que adiciona todos os valores entre 50 e 100 e guarde o
resultado numa variável chamada soma?
15. Escreva uma instrução if que compara o valor de um inteiro chamado produto com o
valor de 15, e se for maior, imprima a sequência de texto "excedestes".

16. Se a variável x é igual a y, imprima o valor de x, senão imprima o valor de y.
17. Reescreva o código a seguir usando o comando switch.

If (c == 'A' )
sum = 0;
else if (c == 'B')
sum+= 1;
else if (c == 'Z')
sum = 26;
else
printf ("caractere desconhecido %c\n", c);
18. Converta a seguinte expressão para o comando if/else. v=(a<b) ? a : b;
Feedback
 Na tua opinião, a unidade está bem desenvolvida?

 Quais são as áreas que achas necessário mais clareza?
 Houve termos que precisavam de mais explicações?
 Que sugestões daria para melhorar o conteúdo?
 Achas que os exercícios (avaliação) apresentados foram adequados?
Respostas da avaliação formativa
1. int total=0;
2. char initial=’K’;
3. float const PI = 3.14;
4. #define PI 3.14
5. int a, b; b=a;
6. sum=c+e;
7. a+=b; or a=a+b;
8. sum/=9;
9. scanf(“%d”, &y);

10. scanf(“%c”, &c);
11.comissao=(float) total/5;
12. int values=1;

while (values<=15)
{
printf(“%d\n”, values);
++values
}
13. for (int values=3; values<=7; ++values)
14. for (int values=51, sum=0; values<100; sum+=values, ++values) or

int sum=0, values;
for (values=51; values<100; ++values)
sum+=values;
15. if(product>15
printf(“excedestes”);
16. if(x==y)
printf(“%d”, x);
else
printf(“%d”, y);
17. switch (c) {

case ‘A’:
sum = 0;
break;
case ‘b’:
sum+= 1;
break;
case ‘c’:
sum = 26;
break;

default:
printf ("caracter desconhecido %c\n", c );
}
18. if (a<b)
v=a;
else
v=b;

UNIDADE TEMÁTICA IV: MATRIZES, PONTEIROS, STRINGS UNIÕES E

ESTRUTURAS
Introdução geral
Nesta unidade vamos discutir quatro novos conceitos: Os vectores, Ponteiros

ou apontadores, uniões e estruturas.
Para garantir a maior percepção da unidade, iremos dividir a unidade em três

aulas distintas: A primeira aula será exclusivamente para discutir conceitos
sobre vectores de diferentes tipos de dados com foco para vectores de
números inteiros, números flutuantes, caracteres.
Na segunda aula trataremos de ponteiros apenas nas suas diversas variantes.

Teremos em conta os ponteiros genéricos, e outros ponteiros e vectores,
procurando estabelecer a sua relação e a sua maior aplicação.
Na terceira aula iremos discutir sobre tipos de dados definidos pelo utilizador
capazes de agrupar elementos de diferentes tipos. Trata-se de estruturas e
uniões. Nesta abordagem vamos trabalhar de formas a criar mais uma
complexidade nos assuntos, dai que o estudante deve prestar maior
concentração nesse conjunto de aulas.
Generalizando, a unidade vai trazer uma dinâmica no raciocínio do estudante

e ajudará na criação de pensamento crítico na resolução de problemas
complexos de programação.

AULA 12: VECTOR, MATRIZES E STRINGS

• Saber manipular vectores, matrizes e strings em C

• Compreender o conceito de vectores e matrizes;
• Definir variáveis do tipo vector;
• Desenvolver problemas complexos usando vectores;
• Diferenciar vector, matriz e string.
Conteúdo da aula
12.1. Vector ou Array

Vector (Array) é uma estrutura de dados que armazena os itens de dados do mesmo tipo.
Por exemplo, para armazenar cinco inteiros na memória, somos obrigados a declarar cinco
variáveis do tipo int (por exemplo, int a, b, c, d, e); um vector vem a calhar para este caso.
Usando um vector, cria-se um identificador, em seguida, define-se o número de elementos
ou o tamanho do vector.
12.1.1. Definindo um vector

Assim como todas as outras variáveis, um vector deve ser declarada antes do seu uso. Sua
forma geral de declaração:
<tipo> nome_vetor [tamanho];
O tipo especifica o tipo de elementos que serão armazenados no vector que inclui: int, float,
char, double etc., enquanto o tamanho indica o número máximo de elementos que podem
ser armazenados no vector. Por exemplo:
int abcde [5];

float balanca [10];

Elementos do vector são acedidos usando o nome do vector e seu índice. Elementos do
vector são armazenados de um modo contíguo e o primeiro elemento do vector começa
com o índice zero (0), o último elemento do vector termina com um tamanho do elemento
menos um ([elemento-1]). No nosso do exemplo, o primeiro elemento é abcde [0] .... [4],
conforme ilustrado a seguir:
Um vector pode ser inicializado ao atribuir-lhe valores da seguinte forma:
<tipo> nome vetor [] = {valores};
Por exemplo:
int abcde [5] = {10, 20, 30, 40, 50};
ou
int abcde [5];
abcde [0] =10;
abcde [1] =20;
abcde [2] =30;
abcde [3] =40;
abcde [4] =50;
Será representado na memória da seguinte forma:
Este comando é usado para manipular o conteúdo de um vector. Para ilustrar isso, vamos
escrever este programa simples:

#include<stdio.h>
main ()
{
int abcde [5] = {10, 20, 30,40,50}, x;
for (x=0; x<5; ++x)
{
printf(“abcde[%d] =%d\n”, x, abcde[x]);
}
printf (“imprimi os elementos do meu vetor\n”);
}
O resultado será:
abcde [0] =10
abcde [1] =20
abcde [2] =30
abcde [3] =40
abcde [4] =50
Aqui, x é a nossa variável de controlo que usamos para aceder ou manipular o conteúdo do
vector.
Exemplo 2: Faça um programa que calcula a média dos elementos de um vector.

#include<stdio.h>
void main()
{
int arr[100], i,soma=0;
float media;
printf(“preencha o vector”);
// Preenchimento do vector
for(i=0;i<100;i++)
scanf(“%d”, &arr[i]);
// soma dos elementos do vector
for(i=0;i<100;i++)
soma += arr[i];
// Conversão explícita do tipo
media = (float) soma/i;
printf(“a media dos elementos do array é: %f“,media);
}

12.1.2. Passagem de um array a uma função
Como outros tipos de argumentos, os elementos de um array podem também ser passados
para uma função através de chamada por referência ou por valor.
CHAMADA POR VALOR CHAMADA POR REFERÊNCIA

#include<stdio.h> #include<stdio.h>
int main() int main()
{ {
int m[]={12,3,5,3,5,6},i; int m[]={12,3,5,3,5,6},i;
for(i=0;i<6;i++) for(i=0;i<6;i++)
imprimir(m[i]); imprimir(m + i);
return 0; return 0;
} }
int imprimir(int notas) int imprimir(int *notas)

{ {
printf(“\t %d”, notas); printf(“\t %d”, *notas);
return 0; return 0;
} }
12.2. Matriz
Temos outros tipos de vectores conhecidos como vectores multidimensionais. Vector
multidimensional é um vector de vectores. Por exemplo, vector bidimensional
(representando uma matriz ou uma tabela) é um vector multidimensional que tenta
representar todos os elementos da mesma forma. A matriz tem dois índices, um para a
linha e a outra para a coluna. Por exemplo, é apresentado a seguir é uma tabela de três por
três para armazenar nove valores (3x3 = 9).
Forma geral de uma matriz bidimensional:

<tipo_dados> nome_vetor[tamanho_linha];
Por exemplo, my_table é declarada como uma matriz com 4 linhas e 5 colunas. O primeiro
elemento da matriz é variável [0] [0] e último elemento é my_table [3] [4]. A seguir é
ilustrado uma matriz bidimensional.
Como os vectores unidimensionais, os vectores multidimensionais podem ser inicializados

como:
<tipo_dados> nome_vetor[] ={valores}
Por exemplo;
float marcas [20] = {45.8, 34.2,56.0...............78.5};
Um programa simples ilustrada um vector de duas dimensões:

#include<stdio.h>
main () {
float marcas [20] =
{45.8,34.2,55.0,66.7,76.8,78.5,54.3,49.5,52.4,36.0,55.5,54.5,4
4.3,66.5,80.5,90.5,77.5,48.0,56.6,78.5},
int x,y;
for(x=0; x<5; ++x) {
for(y=0; y<5; ++y) {
printf(“marcas[%d] [%d] =%d\n”, x,y,marcas[x][y]);

}
}
printf(“Imprimi os dois elementos da matriz\n”);
}
Exemplo 2: Soma de elementos de um array bidimensional

#include<stdio.h>
void main()
{
int arr[100], i,soma=0;
float media;
printf(“preencha o vector”);
// Preenchimento do vector
for(i=0;i<100;i++)
scanf(“%d”, &arr[i]);
// soma dos elementos do vector
for(i=0;i<100;i++)
soma += arr[i];
// Conversão explícita do tipo
media = (float) soma/i;
printf(“a media dos elementos do array é: %f“,media);
}
12.3. Strings
Uma string é um vector de caracteres que pode ser terminado com um valor nulo '\0'. Aqui
nós definimos uma string usando duas palavras que temos que encontrou nesta unidade,
como um vector de caractere (char). Uma string é declarada usando a mesma forma de
um vector, veja:
<tipo de dado >nome_string[tamanho];
O tipo é char porque é um vector de caracteres, o nome indica o identificador que marca o
local na memória para armazenar os caracteres. Tamanho contém o número de caracteres
que podem ser contidos na string. Por exemplo;
“Elisandra” é uma cadeia fechada em aspas duplas, enquanto 'y' é uma string colocada em
aspas simples. A string tem a seguinte forma:

char primeiro_nome[10];
char ultimo_nome[10];
A string pode ser inicializada como:

char primeiro_nome[10]= {‘E’, ‘l’, ‘i’, ‘s’, ‘a’, ‘n’, ‘d’, ‘r’, ‘a’,’\0’};
ou;
char primeiro_nome[10]=”ISEAD”;
Por exemplo;
#include <stdio.h>
int main ()
{
char primeiro_nome[10]= {‘E’, ‘l’, ‘i’, ‘s’, ‘a’, ‘n’, ‘d’, ‘r’,
‘a’,’\0’};
char ultimo_nome[10]=”alves”;
printf ("Ola! : %s %s\n", primeiro_nome, ultimo_nome);
return 0;
}
RESUMO DA AULA
Nesta aula aprendemos sobre os vectores nas suas diferentes formas de

representação, onde concluímos que um vector é um conjunto de elementos homogéneos.
O acesso a esses elementos é feito através da associação do nome do vector e a sua
subscrição. Diferente de uma variável normal, o vector pode armazenar vários elementos
duma única vez, desde que indiquemos o seu tamanho ou o número de elementos no acto
da sua declaração. Falamos ainda de Matrizes, que também são considerados vectores,
mas com múltiplas dimensões. Um outro conceito importante foi da cadeia de caracteres.
Em programação um vector de caracteres é designado de string. O seu funcionamento não
difere-se tanto do funcionamento dos vectores no geral.
Com estes conceitos importantes na programação, vectores e strings. Como podemos ver,
estas estruturas são quase inevitavelmente, ao desenvolver um programa em C. Nós
sempre lidamos com uma série de itens de dados, provavelmente do mesmo tipo por
exemplo o uso de vectores e strings. Portanto, é importante que entendas esses conceitos.

ACTIVIDADE 12
É requerido que leias sobre os conteúdos: vectores e strings. Após a leitura, é

requerido que escrevas programas que ilustram estes conceitos. Aconselha-se a leitura dos
livros referenciados no final da unidade, o mais concreto nos capítulos vectores e strings.
Podes também sempre complementar as tuas leituras com outras pesquisas realizadas na
internet. Esta actividade exige que faças mesmo uma pequena pesquisa. Lê os conteúdos
pesquisados, a seguir, então:
a) Escreva um programa que soma os valores armazenados numa matriz

unidimensional (vector). Mostra o tamanho do vector, o tipo de dados e valores.
b) Escreva um programa que leia os valores para uma matriz bidimensional, em

seguida, calcula a média dos valores. Cria a sua própria matriz, indicando o tipo de
matriz, o tamanho e os seus valores. Imprima todos os elementos da matriz.
c) Por vezes, é necessário limitar as matrizes de uso multidimensionais em nossos

programas. (efeitos de matrizes multidimensional em nosso sistema). Investiga
sobre este tópico e deixa algumas recomendações.

AULA 13: PONTEIROS OU APONTADORES

• Compreender o funcionamento de ponteiros

Definir e usar ponteiros;
Descrever a relação entre ponteiros e a memória RAM;
Manipular conteúdo das variáveis através de ponteiros;
CONTEÚDO DA AULA
13.1. Ponteiros
Ponteiro ponteiros são uns dos recursos mais poderosos da linguagem C. para iniciantes
desta linguagem, torna-se difícil de entender a filosofia dos ponteiros e a sua manipulação,
que na verdade não é assim. Um ponteiro em C é uma variável comum, em cujo conteúdo
armazenamos o endereço de memória de um outro objecto. O objecto cujo endereço é
armazenado pode ser de qualquer tipo, como, por exemplo, uma outra variável, um array,
ou mesmo uma função. É como se a variável apontasse para o objecto cujo endereço está
ali armazenado.
Com ponteiros, temos uma variável que aponta para outra variável. Isso é chamado de
indireção.
Em ponteiros existem dois operadores fundamentais usados em ponteiros:
1. O operador de endereço (&)
2. O operador de indireção (*)
13.1.1. O Operador de endereço (&)

Quando declaramos uma variável x em um programa, um local de armazenamento da
memória de principal é disponibilizado pelo compilador como mostrado abaixo.

Assim, x é um nome associado pelo compilador a um espaço de memória do computador.

Vamos assumir que na hora de execução o espaço da memória física alocado ao x é 2004.
Para o programador, a localização da memória é vista como apenas variável x, e para o

sistema operativo é vista como 2004. O endereço da variável x pode ser obtido através do
operador &. Este operador quando aplicado a uma variável dá o endereço de memória
física da variável. Assim, &x fornecerá o endereço 2004.
Exemplo:
int x;
x = 10;
printf(“\n valor de x = %d”,x);
printf(“\n endereço do x = %d”,&x);
Resultado:
valor de x = 10
endereço do x = 2004
Podemos notar aqui que o valor do endereço de x é assumido e o valor real é dependente
da máquina e do tempo de execução.
13.1.2. O operador de indireção (*)
O (*) é o operador de indireção ou valor no operador de endereço. Simplificando, podemos

dizer que se o endereço da variável é conhecido, então o “* “operador fornece mecanismo
de aceder o conteúdo da variável.
Exemplo:
int x = 10;
printf(“\n O valor de endereço %d = %d”, &x, *(&x));

Resultado:
valor de x = 10
O valor de endereço 2004 = 10
13.2. Declaração do ponteiro e acesso ao seu conteúdo

Um endereço de uma variável pode ser armazenado em uma variável especial chamado
ponteiro.
Sintaxe:
<Tipo_de_dado> * nome_da_variável;
Onde:
Tipo de dado: Pode ser qualquer tipo de dado básico ou derivado;
( * ) : Indica que a variável é do tipo ponteiro
Nome_da_variavel: é um identificador da variável. E este deve obedecer todas as regras
da nomenclatura de identificadores
Exemplo: Vamos assumir que essa variável é y.
int x;
int *y;
x = 10;
y = &x; // O ponteiro y é alocado o endereço de x
Como podemos notar, a variável y contém o endereço de outra variável x. E o endereço da

variável y é 4004. Em palavras mais simplificadas podemos dizer que y é ponteiro do x.
int x = 10, *y;

y = &x; // O ponteiro y é alocado o endereço de x


printf(“\n valor do x = %d”,*y);
printf(“\n endereço do x = %d”,y);
printf(“\n O valor de endereço y = %d”, &y);
Como resultado desta operação teremos:

valor de x = 10
valor de x = 10
O valor de endereço y = 4004
Para além de ponteiros simples podemos trabalhar com ponteiros que apontam em outros
ponteiros. A esse grupo de variáveis são designados de ponteiro de ponteiro.
Sintaxe:
<tipo_de_dado> ** nome_da_variavel;
Onde:
Tipo de dado: Pode ser qualquer tipo de dado básico ou derivado;
( **) : Indica que a variável é do tipo ponteiro do ponteiro
Nome_da_variavel: é um identificador da variável. E este deve obedecer todas as regras
da nomenclatura de identificadores
Exemplo:
int x; // variável normal
int *y; // variável do tipo ponteiro
int **k; // variável do tipo ponteiro do ponteiro
Estas três declarações podem ser feitas na mesma linha:

int x, *y, **k;
x =10;
y = &x;
k = &y;
Assim podemos dizer que o y aponta para o x e o k aponta para y. O valor armazenado em
y será o endereço do x e o valor armazenado no k será o endereço do y.
Ilustrando graficamente fica:

Para aceder o conteúdo da variável x através do ponteiro do ponteiro, podemos fazê-lo

através **k. O ** k significa do valor no endereço do k.
Demostração do funcionamento do ponteiro do ponteiro
int main()
{
int x = 5, *y,**k;
y = &x;
k = &y;
printf(“\n endereço de x = %u \t %u”,&x, y);
printf(“\n endereço do y = %u \t%u”,&y,k);
printf(“\n valor do x = %d \t %d \t %d”,x,*y,**k);
return 0;
}
Resultado:
endereço do x = 2004 2004
endereço do y = 4004 4004
O valor de x = 5 5 5
13.3. Aritmética de ponteiros

Pode-se notar que um ponteiro também pode ser incrementado para um local
imediatamente próximo de seu tipo.
Por exemplo, se o conteúdo de um
ponteiro p de tipo inteiro for 5006,
o conteúdo de p++ será 5008, em
vez de 5007.
A razão é que um int é sempre de

tamanho de 2 bytes e,
portanto, armazenado em dois locais
de memória
Se fosse um tipo dado diferente de int a alocação seria de acordo com o tamanho do
mesmo. Abaixo apresentamos uma tabela de tamanhos de tipos de dados:
Tipo Tamanho Incremento Antes de Depois de

em bytes incremento incremento

char 1 1 p = 2001 p ++ ( 2002)
int 2 2 p = 2008 p++ (2010)
float 4 4 p = 4002 p++ (4006)
long 4 4 p = 4008 p++ (4012)
double 8 8 p = 4010 p++ (4018)
Algumas outras operações permitidas em ponteiros

• Adição de um número a uma variável de ponteiro (m = ptr +4)
• Subtracção de um número com variável de ponteiro (m = ptr – 4)
• Subtracção de uma variável de ponteiro de outra (m = ptr1 – ptr2;)
• Decrementar ponteiro (p--).
• Comparar ponteiros (ptr>ptr1; ptr==ptr1, etc)
Exemplo: Escreva um programa que lê duas variáveis x e y do tipo inteiro. O programa

deve imprimir os conteúdos trocados dessas variáveis com a ajuda de ponteiros sem
alterar a variável.
int main()
{
int *p, *p2, *p3, x,y;
printf(“Introduza os valores de x e y:”);
scanf(“&d %d”,&x,&y);
printf(“Antes da troca\n”);
printf(“X= %d \t Y = %d”, x,y);
p1 = &x;
p2 = &y;
printf(“Depois da troca\n”);
p3 = p1;
p1 =p2;
p2 = p3;
printf(“X= %d \t Y = %d”,x,y);
return 0;
}
Resultado
Introduza os valores de x e y: 12 15
Antes da troca
X = 12 y = 15
Depois da troca
X = 15 y = 12

Resumo da aula
Nesta actividade demos uma introdução a ponteiros, aprendemos como declarar, manipular e as
possíveis operações com ponteiros. Os ponteiros só podem armazenar endereços de variáveis do
mesmo tipo de dado. A manipulação desta informação pode ser feita através da aplicação de
operadores de indireção (*) e de endereço (&).
Actividade 13
É requerido que leias sobre os conteúdo sobre ponteiros. Após a leitura, é

requerido que escrevas programas que ilustram estes conceitos. Aconselha-se a leitura dos
livros referenciados no final da unidade, o mais concreto nos sobre ponteiros.
Podes também sempre complementar as tuas leituras com outras pesquisas realizadas na
internet. Esta actividade exige que faças mesmo uma pequena pesquisa. Lê os conteúdos
pesquisados, a seguir, então:
1. O que entendes sobre ponteiros em linguagem C? de que formas podemos aceder

os conteúdos nele armazenado? Responda e dê exemplos ilustrativos.
2. Quais são as possíveis operações realizáveis com ponteiros? Qual é a relação entre
o endereço e uma variável v e o correspondente ponteiro pv?
3. A expressão (*p)++ e ++*P são equivalente? Justifique a sua resposta.

AULA 14: PONTEIROS E MATRIZES, E VECTORES DE PONTEIROS

• Discutir sobre os ponteiros e o seu relacionamento com funções, vectores e matrizes;

• Relacionar ponteiros com vectores;
• Manipular o vector e strings através de ponteiros;
• Criar vectores de ponteiros;
• Relacionar ponteiros e funções;
Conteúdo da Aula
14.1. Ponteiros e vectores

Ponteiros e vectores/arrays estão intimamente relacionados entre si. Em C o nome de uma
matriz designa o endereço inicial ou base da matriz. Na verdade, é um ponteiro para o
primeiro elemento da matriz. Assim, o nome da matriz se comporta como um ponteiro.
Vamos considerar o seguinte vector:
int arr[] = {12,14,1,23,4};
Dados são armazenados em um espaço de memória homogéneo e graficamente

representa-se como na figura abaixo.
Uma vez que o vector arr é do tipo int, cada elemento deste ocupa 2 bytes. O nome do
array contém o endereço inicial do array, assim, o nome contém o endereço 2001.
Assim se imprimirmos o nome do vector arr, teremos o endereço do array na posição zero.
printf(“Endereço na posição zero é = %d”, arr);
Para imprimir o valor na primeira posição , usaríamos o operador valor no endereço.

printf(“Endereço na posição zero é = %d o valor = %d”, arr, *arr);
Exemplo de manipulação de vector usando ponteiros.
int main()
{
int arr[] ={10, 20, 30, 40, 50}, i;
printf(“a lista é\n”);

for(i=0;i<5;i++)
printf(“\n %d \t %d … elemento”,arr[i],i);
}
Resultado
10 0 … elemento
20 1 … elemento
30 2 … elemento
40 3 … elemento
50 4 … elemento
O mesmo programa usando ponteiros

int main()
{
int arr[] ={10, 20, 30, 40, 50}, i;
for(i=0;i<5;i++)
// Imprimindo usando array
printf(“\n %d \t %d … elemento”,*(arr+i),i);
}
Resultado
10 0 … elemento
20 1 … elemento
30 2 … elemento
40 3 … elemento
50 4 … elemento
Neste programa usamos *(arr + i) para imprimir os elementos do array. Os elementos do

array são acedidos através do operador *.
Pode-se também criar um ponteiro que vai armazenar o endereço do primeiro elemento do
array e a posterior incrementar o mesmo.
int main()
{
int arr[] ={10, 20, 30, 40, 50}, I,*ptr;
ptr = arr; //Apontando para array
for(i=0;i<5;i++)
printf(“\n %d \t %d … elemento”,*ptr++,i);
}
14.2. Ponteiro para matriz bidimensional

Consideremos a seguinte declaração do array:
Int arr[3][4]; é um array bidimensional com três linhas e 4 colunas. No array unidimensional,
o nome do array é ponteiro, no bidimensional o nome é ponteiro do ponteiro.

Para manipular um array usando matriz seria necessário usar dois operadores de valor no
endereço:
*( * (arr + i) + j);
Demostração:
int main()
{
int arr[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12},{30,45,8,3}},i,j;
printf(“endereço de todas linhas são …”);
for(i=0;i<3;i++)
printf(“\n endereço do vector = %d”, i+1, arr[i]);
printf(“\n”);
printf(“elementos de matriz bidimensional são:\n”);
for(i=0;i<3;4i++)
{
for(j=0;j<4;++)
{
printf(“%d \t”,*(*(arr + i)+j);
printf(“\n”);
}
}
return 0;
}
Resultado
Elementos de matriz bidimensional são
1 2 3 4
5 6 7 8
9 10 11 12
30 45 8 3
14.3. Ponteiros e strings

String é um grupo de caracteres, e como vimos anteriormente, o seu tamanho depende do
número de caracteres. Os Strings são armazenados e manipulados como vectores de
caracteres com o último caractere null isto é: ’\0. Como exemplo de string podemos ver
”ISEAD” e esta pode ser armazenado da seguinte forma:
Para a sua declaração fica:
char nome [5] = “ISEAD”;

Para a sua manipulação podemos usar um ponteiro.

char *ptr;
ptr = nome;
Com a instrução ptr = nome apontamos o array nome com o ptr.
Exemplo de demostração da manipulação de string usando ponteiros.

int main()
{
char nome [5] = “isead”, *ptr;
//atribuindo o endereço da string nome ao ponteiro ptr
ptr = nome;
//Enquanto o conteúdo da array for diferente de último caractere imprima
while(*ptr!=’\0’)
{
printf(“%c”, *ptr);
ptr++;
}
return 0;
}
Exemplo 2: Faça um programa que recebe uma string e verifica quantos vogais existem na
string.
#include<stdio.h>
int main()
{
char nome[100],*ptr;
int counter;
printf("Introduza um nome");
scanf("%s",&nome);
ptr = nome;
while(*ptr!='\0')
{
if((*ptr=='a')||(*ptr=='e')||(*ptr=='i')||(*ptr=='o')||(*ptr=='u'))
counter++;
}
printf("A string tem %d vogais", counter);
return 0;
}

14.4. Vectores de Ponteiros

Como outros arrays / vectores, podemos também criar vectores de ponteiros. Cada
elemento do array pode apontar para um a variável específica do mesmo tipo.
Exemplo: * media [10];
Isto significa que media é um array de 10 elementos e cada elemento aponta para uma
variável do tipo float.
Vamos construir um array de ponteiro que aponta para Strings

char * nome[]= {"Mause","teclado","Processador","Impressora"};
Esta declaração cria um array de ponteiros designado nome
A vantagem de usar arrays ou vector de ponteiros em strings é que a manipulação torna-se

conveniente.
Exemplo: Escreva um programa para impressão das strings usando array de ponteiros em
strings.
#include<stdio.h>
int main()
{
char * nome[]= { "Mause","teclado","Processador", "Impressora" };
int i;
printf("As strings introduzidas são ...\n");
for(i=0;i<4;i++)
puts(nome[i]);
return 0;
}
14.5. Ponteiros e funções

Os ponteiros e funções também podem interagir. Podemos passar um ponteiro a uma
função, assim como podemos retornar um ponteiro de uma função.
14.5.1. Passando ponteiro a uma função

O funcionamento é igual a chamada por referência. Do lado dos argumentos actuais

passamos a referência da variável através do operador & e no argumento formal usamos o
operador *.
Exemplo: Faça um programa demostre a passagem de ponteiro a uma função.

include<stdio.h>
int main()
{
int a,b;
a = 20; b=10;
troca(&a,&b);
return 0;
}
void troca(int *x, int *y)
{
int temp = *x;
*x = *y;
*y = temp;
}
Assim o resultado da segunda versão será:
Antes da troca
A = 20 B = 10
Depois da troca
A = 10 B = 20
Função retornando ponteiro

A função pode também retornar um ponteiro como qualquer tipo de dados como int, char,
float, etc. Basta que durante a declaração da função (função protótipo) e na definição da
função mencionemos que ele retorna o tipo ponteiro.
Float *temp();
Isto significa que a função temp retorna um tipo de dado ponteiro. Desta forma a instrução
de retorno deve retornar um ponteiro.
Exemplo: Escreva um programa que lê dois números inteiros e determine o maior entre
eles com ajuda da função maior(). Esta função pode retornar um ponteiro.
#include<stdio.h>
int * maior(int, int); // Protótipo da função
int main()
{
int a, b, *ptr;
printf("Introduza dois números");

scanf(%d%d);
ptr = maior(a,b);
printf("O maior entre %d e %d é %d",a,b,*ptr);
return 0;
}
int * maior(int x, int y)
{
if(x>y)
returb (&x);
else
return(&y);
}
Resultado
Introduza dois números
20
10
O maior entre 20 e 10 é 20
14.6. Alocação dinâmica de memória

Como já vimos anteriormente que quando declaramos uma variável x, ela é alocada a
memória. E esta memória fica disponível mesmo que a variável não seja usada. Portanto,
esta variável é conhecida como variável estática.
A variável dinâmica é aquela que é alocada ou retornada quando é usada ou requisita no
tempo de execução.
A variável dinâmica não tem nome e só pode ser referenciada através do ponteiro.
Consideremos a seguinte declaração:
Int *p;
Esta declaração nos dá um ponteiro pendente p que não aponta para nenhum lugar. Com
este podemos apontar quer para uma variável estática ou dinâmica.
Até agora temos vindo a usar ponteiros com variáveis estáticas.
Agora vejamos como podemos usar os ponteiros com variáveis dinâmicas. E para tal
precisamos de conhecer as quatro funções de biblioteca chamadas funções de memória
dinâmica usadas para alocar e desalocar memoria. Estas são: malloc(), calloc(), free() e
realoc(). Existem outras mas nesta aula vamos nos focar nestas.
Função malloc()

Esta reserva um bloco de memória de reserva do tamanho específico e retorna um ponteiro

do tipo de dados especificado.
Exemplo:
p = (int *) malloc (5 * sizeof(int));
Onde:
p é um ponteiro do tipo inteiro;
(int *) Informa sobre o tipo que será apontado;
malloc É a função de memória dinâmica;
5 É o número de elementos a serem alocados;
sizeof (int) É usado para informar sobre o tamanho do tipo de dados específico.
Uso de sizeof
Na solicitação de memória para matrizes é necessário saber o tamanho de cada elemento,
em bytes, para calcular o tamanho total do matriz. Isto pode ser uma tarefa não trivial, pois
os tipos de dados podem apresentar tamanhos diferentes em diferentes sistemas. Além
disso, tipos formados por estruturas complexas não necessariamente têm tamanho igual a
soma do tamanho de seus atributos. Para auxiliar nesta tarefa, a linguagem C possui a
pseudo função sizeof. Ela recebe como parâmetro um tipo (inteiro, ponto flutuante,
caractere, estrutura, enumeração, etc.) ou uma variável. A função sizeof retorna o número
de bytes necessários para armazenar dados deste tipo, ou o número de bytes que será
alocado para a variável. Por exemplo, para saber o tamanho necessário para armazenar
um número inteiro, utiliza-se a expressão sizeof (int). Para conhecer o tamanho necessário
para armazenar um número fraccionário, utilizar-se-ia sizeof(float) ou sizeof(double).
O espaço alocado não tem nome, o conteúdo é acedido através do ponteiro.
Função calloc ()
Esta aloca espaço para elementos de matriz, inicializa-os para zero e retorna um ponteiro
para a memória.
Função free ()
Esta função desaloca ou libera um bloco de memória anteriormente alocado. É
responsabilidade do programador libertar o espaço. se não for necessário.

Esta função leva um ponteiro para o bloco de memória como seu argumento e, após a
execução, esse bloco não está mais disponível.
Exemplo:
Int *p;
free (p);
Função realloc()
Esta função é usada para redefinir ou modificar o tamanho anteriormente alocado.
Exemplo:
if p = (int *) malloc(5);
Pode-se alterar para 10 bytes caso queiramos de seguinte forma:
p = (int *) realloc (p, 10);
Exemplo prático: escreva um programa que aloca dinamicamente uma matriz de inteiro. A
lista deve ser lida a partir do teclado e armazenada na matriz. Determine o menor na lista e
imprima sua localização.
#include<stdio.h>
#includes<conio.h>
int main()
{
int menor,i,loc,n,*a;
printf("Informa do tamanho da matriz");
scanf("%d",&n);
a = (int *) malloc (n * sizeof(int));
for(i=0;i<n;i++)
{
printf("i = %d a = ",i+1);
scanf("%d", a + i);
}
loc =0;
menor = *(a+0);
for(i=1;i<n;i++)
{
if(menor > *(a+i))
{
menor = *(a+i);
loc=i+1;
}
}
printf("\n O menornumero = %d",menor);

printf("A posicão = %d",loc);
free(a);

return 0;
}
RESUMO
Nesta aula aprendemos como relacionar os ponteiros com vectores, matrizes e strings.
Vimos também como é que podemos manipular um ponteiro usando um outro ponteiro.
Uma nota importante por reter é que o nome do vector pode também considerado por
ponteiro.
Na segunda parte da aula vimos como podemos passar um ponteiro de uma função para
outra. E por fim vimos como fazer com que a alocação da memória as variáveis seja
realizada no acto de execução através da alocação dinâmica da memória.
Actividades 14
Para a realização desta actividade requer-se a leitura sobre os ponteiros. Após

a leitura, é requerido que escrevas programas que ilustram estes conceitos. Aconselha-se
a leitura dos livros referenciados no final da unidade.
1. Explica o que entendes por alocação dinâmica da memória?
2. Diferencie as funções malloc(), free(), calloc() e realloc().
3. O que entendes sobre array de ponteiros?
4. Escreva algumas notas sobre ponteiro de ponteiro.
5. Faça um programa que demostra a funcionalidade de alocação dinâmica.

AULA 15: ESTRUTURAS E UNIÕES

• Compreender o funcionamento das estruturas e uniões em programação

• Compreender os conceitos de estrutura e uniões
• Desenhar e manipular uma estrutura;
• Relacionar estruturas com outros tipos de dados suportados em C;
• Realizar exercícios complexos com ajuda das estruturas e uniões.
Conteúdo da aula
15.1. Estruturas
Uma estrutura ou struct é uma variável especial que contém diversas outras variáveis
normalmente de tipos diferentes. As variáveis internas contidas pela struct são
denominadas membros da struct.
Podemos dizer que as structs da linguagem C são o equivalente ao que se denomina
registros em outras linguagens de programação.
Sintaxe:
struct <identificador>
{
<Listagem dos tipos e membros>;
} struct <identificador> <variável>;
A declaração da estrutura em C é feita através da palavra reservada struct seguido pelo

identificado (o nome da estrutura) e a seguir as chavetas que vão determinar o corpo da
estrutura e por fim um ponto-e-vírgula. No meio de chavetas podemos declarar qualquer
tipo de dada inclusive uma outra estrutura.
Exemplo:
struct estudante
{
char nome [20];
int idade;
int código;
char turma [5];
};

A declaração significa que estudante é um tipo que é uma estrutura composta por
membros: nome, idade, código e turma, Uma vez que estudante é um tipo de dados,
para a manipulação dos seus membros é necessário declarar variáveis do seu tipo antes
de uso, e obedecem a seguinte sintaxe:
struct estudante est1;
Uma vez declarado o est1 este assa a conter todos os elementos do estudante. Isto é, faz
uma cópia de todos os membros da estrutura e com ele podem ser manipulados
isoladamente.
Caso queiramos armazenar dados de mais estudantes, podemos criar uma outra variável
do tipo estudante.
struct estudante
{
char nome [20];
int idade;
int codigo;
char turma [5];
}struct estudante est1,est2,est3;
A cada variável carrega a mesma estrutura e pode manipular os seus elementos

isoladamente.
14.2. Manipulação de dados em estruturas
O acesso aos membros da estrutura é feito através das variáveis criadas com auxílio do
operador ponto (.). Voltando ao caso do exemplo, se pretendermos armazenar dados nos
membros da estrutura estudante temos que usar a seguinte forma:
est1.nome =”ISEAD”;
est1.idade = 2;
est1.codigo = 1;
est1.turma =”mat”;
Com estas instruções armazenamos os dados nas variáveis membros da estrutura.

Caso queiramos adicionar mais dados para evitar a sobreposição, teríamos que usar a
variável: est2.nome, est2.codig, est2.idade e est2.turma.

Também pode se usar a forma interactiva através das funções scanf() ou gets().
gets(est.nome);
scanf("%d %d %s",&est1.idade, &est1.codigo,&est1.turma);
Para a impressão:
printf("%s %d %d %s",est1.idade, est1.codigo,est1.turma);
Inicialização da estrutura:
Podemos inicializar a estrutura através da seguinte técnica:

struct estudante
{
char nome [20];
int idade;
int codigo;
char turma [5];
}struct estudante est1 ={“ISEAD”, 12,14,”Mat”};
A inserção de dados segue a sequência de ordenamento dos dados.
14.2.1. Demostração da utilização da estrutura:
Faça um programa que recebe dados do estudante (nome, código e nota) e calcula a
média do estudante.
#include<stdio.h>
struct estudante
{
char nome [20];
int cod;
float notas[2];
};
Void main()
{
struct estudante est;
int i;
float soma = 0.0;
printf("Introduza o seu nome e código");
scanf("%s %d",&est.nome,&est.cod);
printf("Introduza duas notas do estudante" );
for(i=0;i<2;i++)
{
scanf("%f",&est.notas[i]);
soma+=est.notas[i];
}
printf("Codigo\t Nome\t Media" ;
printf("%d\t %s\t %f", est.cod, est.nome,soma/i);
}
Pode-se atribuir valores de uma variável da estrutura a uma outra do mesmo tipo.
Exemplo: est2 = est1. Isto significa que o conteúdo da variável est1 e ste2 serão

iguais.
14.3. Vectores ou Arrays de estruturas
Como vimos nos exemplos anteriores, para armazenar e manipular estruturas, precisamos
de uma variável. No caso da estrutura estudante a qual armazena notas de um estudante,
foi fácil de gerir, isto porque só tratava-se de nota de um único estudante.
Mas imaginemos se fosse uma turma de 100 estudantes? Ai seriamos obrigados a declarar
100 variáveis de estruturas de formas a acomodar a situação. E isso seria uma tarefa muito
difícil. E é por este motivo que existem os arrays de estruturas para resolver e reduzir essa
complexidade.
O array de estruturas é declarado da mesma forma como se declara um array ordinário. A

única diferença é que o array de estruturas deve ser do tipo estrutura.
Exemplo: Escreva um programa que recebe uma lista de 20 estudantes e as suas

respectivas médias e classifique os de aprovado ou reprovados caso a media seja
igual ou superior a 10.
#include<stdio.h>
struct estudante
{
char nome [20];
float media;
};
int main()
{
struct estudante dados[20];
int i;
printf("Introduza o nome e media");
for(i=0;i<20;i++)
{
printf("ESTUDANTE %d:",i+1);
scanf("%s",&dados[i].nome);
printf("MEDIA DE ESTUDANTE DE %d:",i+1);
scanf("%f",&dados[i].media);
}
printf("\nNOME\tMEDIA\tCLASSIFICAÇÃO\n");
for(i=0;i<20;i++)
{
printf("%s\t%f\t",dados[i].nome,dados[i].media);
if(dados[i].media>=10)
printf("APROVADO\n");
else
printf("REPROVADO\n");
}
return 0;
}
14.4. Passando uma estrutura a uma função

A passagem de uma estrutura a uma função é similar a passagem de qualquer variável. Ele
pode ser chamado por referência assim como valor.
Exemplo: Transforme o exemplo anterior em funções.

#include<stdio.h>
struct estudante
{
char nome [20];
float media;
};
int main()
{
struct estudante dados[20];
inserir(dados);
imprimir(dados);
return 0;
}
void inserir(struct estudante dados[]) // Passagem da estrutura a função inserir

{
int i;
printf("Introduza o nome e media");
for(i=0;i<20;i++)
{
printf("ESTUDANTE %d:",i+1);
scanf("%s",&dados[i].nome);
printf("MEDIA DE ESTUDANTE DE %d:",i+1);
scanf("%f",&dados[i].media);
}
void imprimir(struct estudante dados[])//Passagem da estrutura a função imprimir

{
int i;
printf("\nNOME\tMEDIA\tCLASSIFICAÇÃO\n");
Para saber for(i=0;i<20;i++)
mais sobre {
estruturas printf("%s\t%.2f\t",dados[i].nome,dados[i].media);
e unioes if(dados[i].media>=10)
consulte: printf("APROVADO\n");
Linguage else
m C, Luís printf("REPROVADO\n");
Damas, }
FCA }
14.5. Uniões
O uso de uniões é igual ao uso das estruturas. Eles comungam da mesma sintaxe com
única diferença da palavra reservada usada. Em estrutura é struct enquanto na união é
union.
O acesso aos seus membros é feita da mesma forma que em estruturas.

Sua sintaxe:
union <identificador>
{
<Listagem dos tipos e membros>;
} union <identificador> <variável>;
Diferença entre estruturas e uniões
Tanto a estrutura assim como uniões são usados para conter membros de diferentes tipos
em uma única unidade. Enquanto a estrutura é usada para armazenar dados em diferentes
locais da memória, a união é usada para armazenar em único espaço da memória
diferentes tipos de dados. Em uniões, o espaço que armazena todos os membros é o
espaço requerido pela variável com maior capacidade, isto é, a variável que ocupa mais
espaço da memória toma o tamanho geral da união.
Exemplo:
union estudante
{
char nome [20];
int idade;
int codigo;
char turma [5];
}union estudante est1,est2,est3;
Nesta declaração, podemos concluir que o tamanho da união será de 20 bytes, espaço
ocupado pela variável nome, pois é a variável que requer maior espaço comparando com
as restantes.
RESUMO DA AULA
Nesta aula aprendemos sobre os estruturas e uniões. Como podemos

verificar, as estruturas e uniões são um tipo de dados secundário ou derivado que diferente
de arrays elas tem a capacidade de agrupar variáveis de diferentes tipos. Nesta aula vimos
como manipular e a sua importância na programação. Estes podem ser passados a uma

função, e, dependendo da natureza do problema, pode-se criar um array de estruturas,

onde cada elemento corresponde a uma cópia da estrutura ou união.
ACTIVIDADE 15
Leia o texto proposto na aula e responda as questões que se seguem. Para a

melhor resolução dos exercícios, recomenda-se que leia as literaturas propostas no fim da
unidade e explore outros acervos bibliográficos.
1. Por palavras simples defina o que são estruturas e uniões e estabeleça a diferença
entre estes com arrays.
2. Quais são as possíveis formas de declaração de variáveis da estrutura? De exemplos.
3. Qual é o propósito do typedef em aplicados as estruturas.
Actividade pratica
1. Escreva um programa em C que recebe dados de 25 estudantes de uma turma com

atributos (nome, id, e notas de 5 provas) e imprima as mesmas.
2. Escreva um programa que recebe vários nomes e endereço e reorganize-os de

acordo com a ordem alfabética. Use estruturas
3. Cria uma estrutura com os seguintes elementos: nome, salario e departamento. Com
ajuda da função inserir(), receba dados de 50 funcionários. E através da função
imprimir(), o programa deve mostrar os 10 funcionários com melhor salário.


722-475-3
TEXTOS:
Alegre. Vol. 1, n. 3 (dez. 1996), p. 193-232.
UNICAMP.

Esta unidade habilitou-lhe programar usando novas técnicas de programação.
Introduziu conceitos como vectores, estruturas e ponteiros que são tipos de dados
indispensáveis na programação.



Abaixo de 40%, refazer as leituras.
Entre 40% e 60%, refazer as leituras em seu ponto fraco
Acima de 60%, conseguistes assimilar os conteúdos trabalhados na unidade acima.
1. O conjunto de elementos homogéneos é chamado de _______________;
2. A ______________ determina o tamanho de um vector;
3. Se um vector int vect[10], a palavra vect representa o ______________ do vector.
4. O grupo de caracteres de qualquer tamanho é chamado de ____________.
5. “A” é um ____________ e ‘A’ é um __________________;
6. O endereço de uma variável pode ser obtido através de uso do operador _______;
7. O endereço de uma variável pode ser armazenado em um __________;
8. A definição de uma estrutura termina com ________;
9. Todos os elementos de uma estrutura ou união não devem necessariamente ser do

________ tipo;
10. A palavra chave ___________ é usado para criar união.
11. Como é que um vector é passado para uma função?
1. Vector
2. Subscrição
3. Endereço;
4. String;
5. String, Caractere;
6. &;
7. Ponteiro;
8. Ponto-e-virgula (;);

9. Mesmo;
10. union
11. Vectores desempenham um papel importante no tratamento de funções. Para
passar um vector é feito através do uso do nome do array sem parenteses rectos
no argumento actual. No argumento formal deve se usar a declaração formal, sem
especificar o seu tamanho, deixando assim os parenteses rectos vazios.
Exemplo:
void main() int soma(int i, float p[ ])
{ {
float media, notas[10]; ________________
________________ ________________
________________
media = soma(n, soma); }
}

UNIDADE TEMÁTICA III: TRATAMENTO DE FICHEIROS
Introdução geral
Em programação, existem várias formas de tratar os dados. Nas unidades

anteriores todos programas que desenvolvemos o resultado do seu
processamento desaparecia após a execução, isto é tudo que fazíamos não
era gravado na memória secundária, mas sim na primária. E como sabemos a
memória primária é volátil não retém a informação por muito tempo.
Nesta unidade iremos aprender como fazer com que os resultados do
processamento do nosso programa permaneçam na memória por muito tempo.
E para o efeito iremos aprender nesta unidade diferentes formas de manipular
os ficheiros usando a linguagem C.
Neste processo de aprendizagem iremos saber (i) como abrir um ficheiro, o
que permitirá a localização do mesmo; (ii) como ler um ficheiro e (iii) como
fechar o ficheiro.
Ate o final desta unidade o estudante estará dotado de conhecimentos e será
capaz de resolver problemas complexos e garantir que a informação
processada mantenha-se armazenada por muito tempo.

AULA 16: GESTÃO DE FICHEIROS
• Saber como manipular os ficheiros através da linguagem C

• Descrever o processo de abertura, leitura e fecho do ficheiro através do programa
em C;
• Manipular dados num ficheiro localizado no disco duro através de programa em C;
• Relacionar a linguagem C e o sistema de ficheiro do sistema Operativo.
Conteúdo da aula
16.1. Tratamento de Ficheiros
O armazenamento permanente de dados: as informações permanecem disponíveis mesmo

que o programa que as gravou tenha sido encerrado, ou seja, podem ser consultadas a
qualquer momento. Os ficheiros trazem algumas vantagens tais como a garantia de
armazenamento de grandes quantidades de dados a ser armazenada, promovem o acesso
concorrente aos dados armazenados em ficheiros por diversos programas.
A linguagem C trata os arquivos como uma sequência de bytes. Esta sequência pode ser
manipulada de várias formas e para tanto, existem funções em C para criar, ler e escrever
o conteúdo de arquivos independente de quais sejam os dados armazenados.
O processamento de ficheiro envolve três passos distintos.
• Abrir o ficheiro;
• Ler o ficheiro;
• Fechar o ficheiro;
16.1.1. Abrir ficheiro
Consiste em abrir o ficheiro de forma apropriada com ajuda de funções específicas para o
efeito. O modo de abertura do ficheiro tem a ver com a forma como pretendemos trabalhar

com o ficheiro. Existem três modos de abertura: input ou read. Este modo é usado
quando pretendemos ler os dados do ficheiro. O segundo modo é output/write, usamos
este modo quando pretendemos armazenar o resultado do processamento do nosso
programa e por fim temos o modo read-write que usamos quando pretendemos escrever
ou acrescentar algo ao ficheiro.
16.1.2. Ler ficheiro
Este passo garante a manipulação dos conteúdos do ficheiro caso a abertura tenha sido
sucedido.
16.1.3. Fechar o ficheiro
Este é o passo final no processamento do ficheiro. Uma vez terminado a leitura ou a escrita
em um ficheiro, este deve ser fechado.
Todas as operações dependem das funções já pré-definidas na linguagem. A tabela abaixo

demostra algumas funções importantes.
FUNÇÃO DESCRIÇÃO DA SUA FUNÇÃO

fopen() Abre um arquivo
fclose() Fecha o arquivo garantindo a transferência do buffer.
fflush() Descarrega o buffer.
fscanf() Leitura de entrada formatada (semelhante ao scanf()).
fprintf() Escrita de saída formatada (semelhante ao printf()).
fgets() Obtém uma string do arquivo.
fgetc() Obtém um caracter do arquivo
fputs() Insere uma string no arquivo.
fputc() Insere um caracter no arquivo
fread() Lê um bloco de dados do arquivo.
fwrite() Escreve um bloco de dados no arquivo.
fseek() Reposiciona o ponteiro.
rewind() Reposiciona o ponteiro para o início do arquivo.
ftell() Retorna a posição do ponteiro.
O primeiro passo para trabalhar com um fivheiro é fazer a associação do arquivo físico com um
arquivo lógico. Para isso utilizamos o tipo FILE, definido na biblioteca stdio.h. A
abertura/associação do arquivo é feita pela função fopen(const char* arquivo, const char* modo),
em que arquivo é o directório/nome do arquivo a ser aberto e modo é o modo que a associação é

feita. Fomo referimos na abertura de ficheiros, esta tarefa é feita associando-a com o modo. A
tabela abaixo apresenta possíveis modos de abertura e manipulação de ficheiros:
MODO FUNÇÃO
”r” Abre o arquivo somente para leitura, a partir do início. O arquivo deve existir.
“w” w” Cria um arquivo vazio para escrita. Se já havia o arquivo, ele é perdido
“a” Adiciona no final do arquivo. Se o arquivo não existir, a função o cria.
“r+” Abre o arquivo para leitura e escrita, a partir do início. O arquivo deve existir.
“w+” Cria um arquivo vazio para leitura e escrita. Se já havia o arquivo, ele é perdido
Abre para adição ou leitura no final do arquivo. Se o arquivo não existir, a
“a+”
função o cria.
Exemplo: O código abaixo mostra a associação das funções e modos

#include <stdio.h>
int main(int argc, char** argv)
{
FILE *fp;
fp=fopen(argv[1],"w")
if(FP==NULL) //Verifica se o ficheiro existe
printf ("Erro na abertura do arquivo.");
else
printf("Arquivo aberto com sucesso.");
fclose(fp); //Fechar o ficheiro
return 0;
}
Quando um programa encerra correctamente, com exit(0) por exemplo, os arquivos lógicos são
liberados da memória. Porém, se o programa fechar com erro, o arquivo não é liberado. Para evitar
que isso aconteça, é conveniente fechar o arquivo quando não for mais necessário o seu uso. Para
isso basta usar a função fclose(arquivo).
16.2. Manipulação de arquivos:

Se pretendemos criar um programa que lê um caracter do arquivo, basta revisitarmos a tabela de
funções e escolher a função apropriada. Neste caso seria a função fgetc(FILE * arquivo). De forma
semelhante, para escrever um caracter no arquivo, basta usamos a função fputc(FILE * arquivo).
16.3. Escrevendo ficheiro

Exemplo:escreva um programa que recebe uma linha de texto através do teclado e escreva no
ficheiro do disco.
#include<stdio.h>
#include<conio.h>
#include<string.h>
void main()
{
FILE *fp;

char str[100];
clrscr();
fp = fopen("exemplo.txt","w");
if(fp==NULL)
{
printf(" \n Nao ee possivel abrir o ficheiro");
}
printf(" \n Introduza os elementos da string");
while(strlen(gets(str))>0)
{
fputs(str, fp);
fputs(" \n" ,fp);
}
fclose(fp);
}
Resultado:
Ficheiro: exemplo.txt
16.4. Lendo do ficheiro

Os dados escritos do ficheiro através do programa podem ser lidos usando o programa em
C. A função que permite a leitura é a função fgets(). fgets(string, tamanho_string,
ponteiro_de_ficheiro, );
Exemplo: Escreva um programa que lê dados do ficheiro exemplo.txt e escreva no monitor.
#include<stdio.h>
#include<conio.h>
#include<stdio.h>
int main()
{
FILE *fp;

char str[100];
fp = fopen("exemplo.txt","r");
if(fp==NULL)
{
}
printf(" \n Os dados em ficheiro sao\n");
while(fgets(str,100,fp)!=NULL)
{
puts(str);
}
fclose(fp);
getch();
return 0;
}
Resultado:
Exemplo de como armazenar dados do tipo inteiro no ficheiro.

Escreva um programa que escreve dados do tipo inteiro no ficheiro.
#include<stdio.h>
#include<conio.h>
#include<stdio.h>
int main()
{
FILE *fp;
char car = 's';
int n;
fp = fopen("exemplo.txt","w");
if(fp==NULL)
{
}
printf(" \Escreva s numeros inteiros e pressione entre para gravar:\n\n");
while(car =='s')
{
printf("\n Introduza um numero qualuer: ");
scanf("%d", &n);
putw(n,fp);
printf("Pretendes introduzir um outro (s/n)?");
car=tolower(getche());
}
fclose(fp);

return 0;
}
Resultado:
Para saber
mais sobre
tratamento de
ficheiro leia:
RESUMO DA AULA
Nesta aula aprendemos sobre o tratamento de ficheiros. Discutimos diferentes

operações que podem ser realizadas em ficheiros como: criar, ler e fechar.
ACTIVIDADE DA AULA
Leia o texto proposto na aula e responda as questões que se seguem. Para a

melhor resolução dos exercícios, recomenda-se que leia as literaturas propostas no fim da
unidade e explore outros acervos bibliográficos.
1. Qual é a maior vantagem em usar ficheiros?
2. Explica os procedimentos de abertura de ficheiro.
3. O que entendes sobre ponteiro do ficheiro?
4. Discuta sobre vários problemas que podem ser encarrados na abertura de ficheiro;
5. Diferencie o modo Append e modo write no tratamento de ficheiro.

Actividade pratica
1. Escreva um programa que lê um ficheiro e conta quantos caracteres existem nele.
2. Escreva um programa que escreve dados de uma estrutura num ficheiro;
3. Escreva um programa que lê dados de uma estrutura num ficheiro;
4. Escreva um programa que grava e lê elementos de um array num ficheiro.

722-475-3
TEXTOS:
Alegre. Vol. 1, n. 3 (dez. 1996), p. 193-232.
UNICAMP.

Esta unidade habilitou-lhe programar usando novas técnicas de programação.
Discutiu-se diferentes operações de gravação e leitura de informação num ficheiro, com
intuito de munir o estudante de capacidades de fazer programas cujo o resultado do seu
processamento seja mantido permanentemente do disco duro.



1. O espaço permanente de armazenamento no disco é chamado de ____________;
2. Antes de usar o ficheiro, este deve ser __________;
3. Depois de usar um ficheiro este deve ser __________;
4. O ponteiro de ficheiro este aponta para _______________;
5. Fgets() e fputs() são funções ________________ de entrada e saida ;
6. ___________ e __________ são funções de formatadas de entrada e saída.

1. Ficheiro;
2. Criado;
3. Fechado;
4. Ficheiro;
5. Console;
6. Scanf() e printf();

UNIDADE TEMÁTICA V:TESTE, DEPURAÇÃO E DOCUMENTAÇÃO DE PROGRAMA
Introdução Geral
Esta unidade discute os diferentes tipos de erros que venham a surgir

durante o desenvolvimento de um programa e mostra as diversas formas de
os corrigir. Também, de uma forma muito breve destaca a questão da
documentação de um programa no seu processo de desenvolvimento. Esta
unidade é importante pois o aluno passa a conhecer os três conceitos
importantes (teste, depuração e documentação) que são comuns a todas as
linguagens e paradigmas de programação. Os conteúdos desta unidade foram
obtidos a partir de livros de referência indicados. Portanto, aconselha-se
aceder esses recursos para outras leituras de forma a seres capaz de
trabalhar nas tarefas/actividades proposta mais adiante.

AULA 17: ERROS DE PROGRAMAS, TESTES E DEPURAÇÃO DE PROGRAMA
• Descrever o processo de desenvolvimento de um programa

• Definir testes e depuração de programas
• Aplicar tipos básicos de testes do programa
• Diferenciar os tipos básicos de testes do programa
• Depurar um programa
• Documentar um programa usando comentários e explicar outros tipos de
documentação do software
CONTEÚDO DA AULA
17.1. Tratamento de erros e teste
Existem três tipos básicos de erros: erros de sintaxe ou de compilação, erros de excepção
(erro de execução) e erros lógicos.
Um programa deve ser testado para todos esses tipos de erros. Isso garante a
confiabilidade, eficácia, desempenho entre outros atributos de um bom programa. Os testes
também são divididos em dois tipos básicos: teste de caixa branca e testes de caixa preta.
Usando métodos de teste de caixa branca um programador pode testar casos que
garantem que cada parte individual de um programa tenha sido testada pelo menos uma
vez, todas as decisões lógicas foram testadas com valores verdadeiros e valores falsos,
todos os ciclos foram testados até os seus limites e todas as estruturas de dados internas
forma testadas para garantir a sua validade. Teste de caixa petra tenta encontrar erros nas
seguintes categorias: as funções incorrectas ou em falta; os erros de interface; os erros em
estruturas de dados ou de acesso a base de dados externo; os erros de desempenho; os
erros de inicialização de finalização.
Teste de caixa preta é uma abordagem complementar que é provável descobrir um grupo
de erros diferentes que os testes de caixa branca. É praticamente impossível provar que o

programa está correto para todas as entradas.
17.2. Depuração
Depuração envolve um processo de encontrar e reduzir o número de erros garantindo que

o programa faz exactamente o que é suposto fazer. Este processo tende a ser mais difícil
quando vários subsistemas/subprogramas/sub-rotinas dependem uns dos outros ou estão
fortemente, em que as mudanças podem afectar outros subprogramas dependentes.
Teste Depuração
Teste encontra casos em que um O processo de depuração envolve analisar

programa não atenda as e, possivelmente, a extensão do programa,
especificações. uma vez que não atende às especificações,
a fim de encontrar um novo programa que
está próximo do original e não satisfaz a
especificação.
Seu objectivo é demonstrar que o O objectivo consiste em detectar a causa

programa atende as exacta e remover os erros conhecidos no
especificações de concepção. programa.
O teste é concluído quando todas A depuração é completa quando todos os

as verificações desejadas contra erros conhecidos no programa foram
especificações foram realizadas. corrigidos.
Os testes podem começar nos Depuração só pode começar depois que o

primeiros estágios de programa é codificado.
desenvolvimento de software.
O teste é o processo de validar a A depuração é o processo de eliminação de

correção do programa. erros num programa.
Erros lógicos podem ser detectados por fazer simulação do código do programa e
colocando as instruções de escrita de mensagens no código do programa. Outra
abordagem para a detecção de erros lógicos é pelo uso de um debugger. Esta é a técnica
mais utilizada. Debugger é o programa de software que auxilia um programador na

execução passo-a-passo de um programa e que permite a visualização dos resultados dos

cálculos intermediários.
O IDE inclui um debugger, é uma ferramenta de apoio para encontrar erros de execução.
Para usar o debugger, é necessário modificar as opções do compilador para incluir
informações de depuração no objecto e nos ficheiros executáveis (Ferramentas> Opções
Compiler>Compiler). Isto é feito através da adição do parâmetro -g para as chamadas e do
compilador e linkador.
Figura 15: Tela de compilador
Quando o programa é compilado e linkado com estas opções, podemos executar o

programa no modo de depuração, clicando no botão Debug (F8). Este modo permite a
execução do programa passo a passo (instruções são executadas uma a uma), parando a
execução nos pontos de interrupção, ou ver o valor de uma variável em qualquer momento
da execução.
O modo de depuração permite consultar ou ver o valor de uma variável, em qualquer

momento durante a execução do programa. Para ver o valor de uma variável, o programa

deve ser interrompido (com um ponto de interrupção ou após o uso de Executar para
Cursor).
Por exemplo, quando a sequência de código é compilada e, em seguida, executada no

programa C:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int x = 5;
double a, b;
printf("Entrar o primeiro numero (double type): ");
scanf("%lf", &a);
printf("\n a = %f", a);
a = a + x;
printf("\n a = %f", a);
printf("\nEntrar o segundo numero (double type): ");
scanf("%f", &b);
printf("%.2f + %.2f = %.2f\n", a, b, a + b);
printf("x = %d\n", x);
system("PAUSE");
return 0;
}
O seguinte resultado é obtido para valores de entrada a = 5.5 e b = 7.5:
Esta saída indica que o programa tem um ou mais erros de lógica. O debugger do Dev C++
pode ser usado para localizar o erro(s).
leitura do
programmer
wrote the
program2-
Harsha Priya, r.
Ranjeet.
17.3. Documentação de programa
A documentação é um aspecto muito importante da programação, porque durante o seu percurso

de programador, vais ler muitos códigos. Se a documentação de um programa for favorável, então
o programa será bem entendido.

A documentação frequentemente é categorizada em: instalação, referência e tutorial.
Documentação tem muitas vantagens, que incluem: facilidades de uso do programa, manutenção,
modificação, entendimento da lógica de um programa de registros documentados, são bastante
úteis para reiniciar um projeto de software que foi adiada devido a algum motivo ou outro, e,
provavelmente, o trabalho não precisa ser iniciado a partir do zero e as ideias anteriores ainda
podem ser facilmente recapituladas o que economiza muito tempo e evita a duplicação de trabalho
(reutilizável). Várias formas de documentação incluem: comentários, manual do sistema e o manual
do utilizador.
Isso também é uma actividade de leitura e o aluno é requerido que leia sobre a documentação
programa/software usando Fundamentals of programming languages book by Dipali P. Baviskar.
Vamos praticar o conceito de documentação de uma forma simples com o uso de comentários. O
aluno pode aceder o link http://en.wikibooks.org/wiki/C_Programming/Structure_and_style para ler
sobre tipos de documentação por uso de comentários. Nesta actividade, é requerido:
a) Descrever brevemente um código e auto documente-o?

b) Usando comentários, documente o seguinte programa:
#include<stdio.h>
void sms_me (int i)
{
for (; i>0; --i)
printf (“Eu sou um programador! \n”);
}
main ()
{
int x;
print (“Digite um numero inteiro pequeno para X\n”,x);
sms_me(x);
printf (“Então vais programar actividades do meu departamento\n”);
}
c) Usando a linguagem C, escreva um programa e documente-o. Faça comentários

usando tanta linha única como multilinha (estilos de comentários). No seu programa,
mostre o conceito de Auto documentação deste programa.

722-475-3

TEXTOS:
Alegre. Vol. 1, n. 3 (dez. 1996), p. 193-232.
UNICAMP.

Esta unidade introduziu os alunos na documentação do programa, uma actividade que é essencial
e que é praticado por programadores. O principal ponto a este nível é o de ajudar o aluno a
compreender o significado do código e de auto documentar e como documentá-lo código usando
comentários. O aluno também foi introduzido para sistemas de utilizador e manuais como parte da
documentação do programa. A este nível, o aluno deve ser capaz de apreciar os benefícios
da documentação do programa e aplica-lo nas suas actividades.



Defina o seguinte:
1. Um bug é _____________________________________________
2. Teste de programa______________________________________
3. Debug________________________________________________
4. Erros de compilação são detectados por___________________________
5. Erros de execução são conhecidos como__________________________
6. A instrução do programa foi escrita x=d\y; que erro será gerado no programa?
7. Para ver uma variável, o programa deve ser parado com um _________;
8. Erros lógicos podem ser detectados por __________e____________;
9. Documentação pode ser agrupada em três categorias. Nomeia as três categorias
de documentação de programa.
1. Um bug é um problema que causa falhas num programa ou produz uma saída inválida.
O problema é causado pela lógica insuficiente ou erro. Um erro pode ser um erro de
defeito ou falha, o que pode causar falha ou desvio dos resultados esperados.
2. O teste é um processo de execução de um programa com o intuito de encontrar erros.
3. A depuração é um processo metodológico de encontrar e reduzir o número de erros
ou defeitos de um programa de computador tal como esperado.
4. O compilador
5. Erros de tempo de execução

6. Sintaxe
7. breakpoint
8. Simulações e uso de um depurador
9. Instalação, referência e tutorial

Referências bibliográficos
● Ascencio, A. F.G, (2007). Fundamentos da programação de computadores. Pearson
Prentice Hall 2ª edição.
● Backes, A. (2013). Linguagem C: Completa e Descomplicada. Campus. Elsevier 1ª
edição.
● Baviskar, D.P. (2012). Fundamentals of programming languages. Technical
Publication Pune 2ª edição.
● Cormen, T. H…[et al.] (2002). Algoritmos: Teoria e Prática. Rio de Janeiro.
Elsevier 2ª edição.
● Damas, L. (1999). Linguagem C. Rio de Janeiro. FCA 10ª edição.
● Damas, L. (2001). Linguagem C. Lisboa. FCA.
● Damas, L. (2014). Linguagem C. Lisboa. FCA 24ª edição.
● Dale, N. (s/d). Programming and PROB solving using C. ISRD. McGraw-Hill
education.
● Gerard, O. (2012). A brief history of computing. London, Springer 2 ª edição.
● Guerreiro, P. (2006). Elementos de programação com C. FCA.
● Farrell, J. (2012). Programming Logic and design, Comprehensive. Amazon 8ª
edição.
● Fenwich, J. B. (s/d). Programming Languages & paradigms. Amazon 1ª edição.
● Forbellone, A. L. V. (2005). Lógica de programação: a construção de algoritmos e
estruturas de dados. Pearson Prentice Hall.
● Hanly, J. R., Koffman, E. B. (2009). Problem solving and program design in C.
Pearson Education, Inc.
● Holzner, S. (1991). C Programming. Brady.
● Jackson, M. A. (1975). Principles of Program Design. Academic Press, Inc.
Orlando, FL, USA.
● Manzano, J. A. N. G., Oliveira, J, F. (2016). Algoritmos – lógica para
desenvolvimento de programação de computadores. Érica 28ª edição
● Matos, J.A. (2009). Dicionário de Informática e Novas tecnologias. Lisboa.
Disponível em: http://www.fnac.pt/Dicionario-de-Informatica-e-Novas-
Tecnologias-Jose-A-de-Matos/a81059
● Michell, J. C. (2003). Concepts in programming Languages. Cambridge.

Disponível em: http://www.softpanorama.org/History/lang_history.shtml#General

● Mizrahi, V. V. (s/d). Treinamento em Linguagem C: curso completo, módulo I.
São Paulo. Makron Books.
● Pereira, S. L. (s/d). Linguagem C. Disponível em:
http://www.ime.usp.br/~slago/slago-C.pdf
● Kernighan, B. W., Ritchie, D. (1988). The C Programming Language -the ANSI
edition, Pearson Prentice Hall.
● Kernighan, B. W., Pike, R. (1999). The pratice of Programming. Addison-Wesley
Professional.
● Kochan, S. (2005). Programming in. Sams Publishing, 3ª edição.
● Ranjeet, H. P.(2006). Programming and problem solving through “C” languages.
Firewall media
● Rocha, A. A. (2006). Introdução á programação usando C. FCA.
● Sampaio, I., Sampaio, A. (1998). Fundamental da Programação em C. Lisboa.
FCA.
● Sampaio, I., Sampaio, A. (s/d). Introdução à informática e Algoritmia. Porto.
● Schildt, H. (1995). C – The Complete Reference, McGraw-Hill. 3rd edition.
● Schildt., H. (1995). C Completo e Total. São Paulo. São Paulo. Makron Books 3ª
edição
● Sousa, S. (2010). Tecnologias de informação. O que são? Para que servem? Lisboa.
FCA 6ª edição.
● Neves, J. (2009). Utilizar o computador Depressa e Bem. Lisboa. FCA.
Outros Links Consultados
Tutoriais e apostilas
1. http://archive.oreilly.com/pub/a/oreilly//news/languageposter_0504.html
2. http://www.softpanorama.org/History/lang_history.shtml#General

3. http://www.ime.usp.br/~kunio/devcpp/devcppintro.pdf
4. http://www.univasf.edu.br/~leonardo.campos/Arquivos/Disciplinas/Alg_Prog_I_2007_
1/Aula_02.pdf
5. http://dcm.ffclrp.usp.br/~augusto/teaching/ici/Estruturas-de-Decisao.pdf
6. http://wurthmann.blogspot.com/2013/03/depuracao-debugger-no-dev-c.html
7. http://www.esj.eti.br/Apostilas/DicasDeDepuracaoDeCodigoUtilizandoDEVCPP_V10.
pdf
8. http://wiki.icmc.usp.br/images/e/e3/Manual_Dev_C.pdf
9. http://www.urisan.tche.br/~janob/Cap_1.html
10. http://pt.scribd.com/doc/27760045/Teste-de-Inf-Basica
11. http://www.proprofs.com/quiz-school/story.php?title=teste-diagnostico-tic
12. Programming: Grade in Industrial Technology Engineering. Creative Commons. On:
http://ocw.uc3m.es/ingenieria-informatica/programming-in-c-language-
2013/IntroductiontoDevCIDE.pdf.

Manual Do Docente

Hochgeladen von

Dokumentinformationen

Originalbeschreibung:

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Manual Do Docente

Hochgeladen von

Copyright:

Verfügbare Formate

Departamento de

Atenção: indica pontos de maior relevância no texto

Saiba mais: oferece novas informações que enriquecem o

Atividades de aprendizagem: apresenta atividades em

“Pronto a enfrentar as Apoio /

Escola Superior Técnica - ESTEC 1

Escola Superior Técnica - ESTEC 2

Escola Superior Técnica - ESTEC 3

Escola Superior Técnica - ESTEC 4

O Manuel de programação imperativa em C foi especialmente preparado para si. Os

O objectivo principal deste material é proceder à orientação e acompanhamento do

O professor responsável pela produção deste material sente-se honrado em providenciá-lo

Escola Superior Técnica - ESTEC 5

Boas vindas e votos de bom trabalho!

Escola Superior Técnica - ESTEC 6

Docente na Universidade Pedagógica – Escola Superior Técnica, Departamento de

De 2013 a 2016 foi Chefe de Departamento de Assistência Técnica e Redes do Centro de

Escola Superior Técnica - ESTEC 7

UNIDADE TEMÁTICA I: INTRODUÇÃO AO P ARADIGMA DE PROGRAMAÇÃO

Esta unidade serve como um ponto de partida sobre os princípios de

 Definição de Linguagens de Programação;

No fim desta unidade esperamos que voce esteja em condições de:

• Definir o que é uma linguegem de programação;

• Discutir sobre diferentes tipos de paradigmas de programação e

• Explicar a relação entre Paradigma e Linguagem de

• Descrer o processo de desenvolvimento de aplicação e;

• Compreender a filosofia da linguagem C.

Escola Superior Técnica - ESTEC 8

1.1. Introdução da aula

O computador é um instrumento indispensável para o Homem na actualidade, mas que ele

1. Discutir os principais aspectos sobre linguagens de programação.

Objectivos − Definir uma linguagem de programação e a sua importancia;

1.2. Linguagem de programação

Escola Superior Técnica - ESTEC 9

Face a essa situação imaginemos um programador que pretenda desenvolver um

Entre a máquina e o programador está um intérprete ou compilador, mas que apenas

A Linguagens de Programação deve fazer a ligação entre o pensamento humano (muitas

● Terminologia que é um conjunto de termos, palavras e sinais, que

Escola Superior Técnica - ESTEC 10

Olhando para o que discutimos anteriormente de certeza chegou a conclusão de que as

Quanto a quantidade de linguagens existentes na actualidade dificilmente chegou a

Figura 1: Linguagens de Programação Fonte: Making Games

Existem linguagens compiladas, Interpretadas, do alto nível e do baixo nível.

1.2.1. As Linguagens Compiladas

São as linguagens que passam por um processo de tradução (compilação), sendo

Exemplo 2: C, Java, C#, C++, Pascal, Delphi, Cobol, entre outras.

1.2.2. Linguagens interpretadas

Escola Superior Técnica - ESTEC 11

As linguagens do alto nivel são linguagens com um nível de abstracção relativamente

O programador de uma linguagem de alto nível não precisa conhecer características do

As do baixo nível tratam-se de linguagens de programação que compreendem as

Assim, utiliza-se somente instruções do processador, para isso é necessário conhecer os

Exemplo é a linguagem Assembly, que trabalha directamente com os registradores do

As Linguagens de programação do alto nível podem ser interpretadas assim como

Escola Superior Técnica - ESTEC 12

Desde o surgimento das linguagens de programação, houve mudanças na

A resposta é sim. As linguagens foram acompanhando a evolução tecnológica. Para sustentar a

• PRIMEIRA GERAÇÃO - linguagem de máquina.

Os primeiros computadores eram programados em linguagem de máquina, em notação binária. A

Figura 2: Instrução usando linguagem máquina

Cada instrução de máquina é, em geral, formada por um código de

As linguagens de máquina permitem a Comunicação directa com o

Um programa em linguagem de máquina é uma sequência de zeros e