Meu fasciculo

i
ÍNDICE
1. FUNDAMENTAÇÃO.................................................................................................iii
2. OBJECTIVOS .............................................................................................................iii
. CONTEÚDO PROGRAMÁTICO ................................................................................. v
Introdução......................................................................................................................... v
INTRODUÇÃO................................................................................................................ 1
0.1 Breve histórico da linguagem C ................................................................................. 1
0.2 CARACTERÍSTICAS DA LINGUAGEM C............................................................ 2
Capítulo 1. ESTRUTURA BÁSICA DE UM PROGRAMA EM C................................ 4
1.1. Regras gerais ............................................................................................................. 4
1.2. Forma geral de funções.............................................................................................. 5
Capítulo 2. VARIÁVEIS.................................................................................................. 7
2.1. Regras gerais ............................................................................................................. 7
2.2. Palavras reservadas.................................................................................................. 10
2.3. Tipos de Variáveis................................................................................................... 11
1. Inteiros (int)................................................................................................................ 11
2. Reais (float e doble).................................................................................................... 11
3. Caracteres - char......................................................................................................... 13
2.4. Declaração de variáveis e Inicialização de variáveis............................................... 13
Capítulo 3. OPERADORES ........................................................................................... 15
3.1. ARITMÉTICOS ...................................................................................................... 15
3.2. RELACIONAIS ...................................................................................................... 16
3.3. LÓGICOS................................................................................................................ 16
Capítulo 4. ENTRADA E SAÍDA PELO CONSOLE ................................................... 19
4.1. FUNÇÕES DE SAÍDA ........................................................................................... 19

ii
1. Função scanf() ............................................................................................................ 19
2. Função getchar()......................................................................................................... 20
3. Função gets() .............................................................................................................. 20
4.2. FUNÇÕES DE ENTRADA..................................................................................... 21
1. Função printf()............................................................................................................ 21
2. Função puts().............................................................................................................. 22
EXERCÍCIOS................................................................................................................. 23
Capítulo 5. ESTRUTURAS EM C................................................................................. 32
1. ESTRUTURAS DE DECISÃO.................................................................................. 32
1. Comando If................................................................................................................. 32
2. O comando else .......................................................................................................... 33
3. O Comando if-else-if.................................................................................................. 35
4. O operador? ................................................................................................................ 36
5. O Comando switch ..................................................................................................... 38
Exercícios ....................................................................................................................... 40
BIBLIOGRAFIA BÁSICA ............................................................................................ 46

iii
1. FUNDAMENTAÇÃO
A linguagem C é uma linguagem de preparação do pricipiante que com a finalidade
de trabalhar em qualquer plataforma, mas também é uma linguagem poderoso e flexível.
C é a linguagem de programação procedural, altamente expressiva, lógica e exigente. E
por isso muitas linguagens criadas posteriormente (Java e C#, por exemplo) são
inspiradas de C.
As técnicas de programação que suporta a linguagem C proporciona aos
estudantes conhecimentos e métodos que permitem dominar a programação genérica,
adaptando-se assim às diferentes necessidades requeridas pela criação de softwares
robustos, fiáveis e extensíveis.
2. OBJECTIVOS
Geral
 Preparar os alunos aptos a entender e utilizar a informática como uma ferramenta de
trabalho;
ESpecíficos
 Descrever os comandos, tipos de dados básicos, estratégias de fluxo de controlo e
mecanismos de construção de novos tipos de dados oferecidos pela linguagem C.
 Implementar algorítmos usando as instruções fornecidas pela linguagem C.
 Identificar e descrever algumas funções da biblioteca de rotinas C.
Habilidades
Utilizar paradigmas de programação para o desenvolvimento de programas estruturados.
Aplicar metodologias e ferramentas nas atividades de análise e projetos ao domínio de
tipos de dados básicos, das estratégias de fluxo de controlo e dos mecanismos de
construção de um programa oferecidos pela linguagem C.
Valores

iv
O formando vai possuir virtude de disseminar e utilizar o conhecimento
relevante para a sociedade. Conhecer e trabalhar com ferramentas computacionais,
construindo, automatizando e desenvolvendo programas de gestão de sistemas
informáticos seguros e de qualidade.

v
. CONTEÚDO PROGRAMÁTICO
1ª PARTE: NOÇÕES INTRODUTORAS SOBRE A PROGRAMAÇÃO (Iº
SEMESTRE)
Introdução
Objectivo:
- Explicar a orígem da linguagem C e suas características
0.1 Breve histórico da linguagem C
0.2 Características da linguagem C
Capítulo 1. Estrutura básica de um programa em C
Objectivos:
- Apresentar a estrutura básica de um programa C;
- Escrever um programa C utilizando a estrutura básica.
1.1. Regras gerais
1.2. Forma geral de funções
Capítulo 2. Variáveis
Objectivos:
- Diferenciar as palavras reservadas e tipos de variáveis em linguagem C;
- Descrever a declaração das variáveis e a inicialização de uma variável.
2.1. Regras gerais
2.2. Palavras reservadas
2.3. Tipos de Variáveis
2.4. Declaração de variáveis
2.5. Inicialização de variáveis
Capítulo 3. Operadores
Objectivos:
- Definir os diferentes tipos de operadores: aritméticos, lógicos e relacionais;
- Manipular as operações usando tipos de operadores.
3.1. Aritméticos
3.2. Relacionais
3.3. Lógicos
Capítulo 4. Entrada e Saída pelo console

vi
Objectivos:
- Descrever os blocos de códigos que executam uma determinada tarefa;
- Determinar o tipo e nome da função a ser tratada;
4.1. Funções de saída
4.2. Funções de entrada
Capítulo 5. Estruturas de decisão
Objectivos:
- Identifcar o tipo de estrutura de decisão a utilizar para um determinado
problema;
- Descrever cada estrutura repetitiva.
5.1. If, If …else, Switch
5.2. Práticas sobre as estruturas de decisão

1
INTRODUÇÃO
Objectivo:
- Explicar a orígem da linguagem C e suas características
0.1 Breve histórico da linguagem C
O C é uma linguagem de programação imperativa (procedimental) típica. Foi
desenvolvida em 1970 por Dennis Ritchie para utilização no sistema operativo Unix.
Esta linguagem é particularmente apreciada pela eficiência e é a mais utilizada na
escrita de software para sistemas operativos e embora menos, no desenvolvimento de
aplicações. A sua utilização também é comum no ensino, apesar de não ser a linguagem
inicial para iniciados.
De acordo com Ritchie, o desenvolvimento inicial da linguagem C aconteceu
nos laboratórios da AT&T entre 1969 e 1973. O nome "C"foi escolhido porque algumas
das suas características derivavam de uma linguagem já existente chamada "B".
Em 1973, a linguagem C tornou-se suficientemente poderosa para suportar a
escrita de grande parte do kernel do Unix que tinha sido previamente escrito em código
assembly.
Em 1978, Ritchie e Brian Kernighan publicaram a primeira edição do livro
"The C Programming Language"[Kernighan e Ritchie, 1988] que durante muitos anos
funcionou como a especificação informal da linguagem (K&R C). Posteriormente a
segunda versão versou sobre a especificação ANSI C. A especificação K&R C é
considerado o conjunto mínimo obrigatório que um compilador da linguagem deve
implementar.

2
0.2 CARACTERÍSTICAS DA LINGUAGEM C
 Rapidez: usa instruções de alto nível como o Pascal, Cobol…
 Simples: a sua sintaxe é extremamente simples e o número de palavras
reservadas, tipos de dados básicos e operadores é diminutos, reduzindo assim a
quantidade de tempo e esforço necessários à aprendizagem da linguagem.
 Portável: o código escrito numa máquina pode ser transportado para outra
máquina e compilado sem qualquer alteração.
 Popular: internacionalmente conhecida e utilizada.
 Modular: desenvolvimento de módulo, facilitando a separação de projectos em
módulos distintos e independentes, recorrendo a utilização de funções
especificas
dentro de cada módulo.
Uma linguagem de programação deve ser, por um lado, legível e compreensível para
um humano, e, por outro lado, suficientemente simples para que possa ser
compreendida completamente e sem ambiguidades por um computador. Geralmente,
uma linguagem de programação é composta de :
 Um conjunto de palavras-chave (geralmente em inglês, como if, while, função),
associadas a certos comandos e recursos da linguagem;
 Um conjunto de símbolos (como #, ", {, etc.); e
 Um conjunto de regras que ditam o significado de todas essas coisas e como elas
podem ser combinadas e utilizadas.
No entanto, as linguagens de programação não são entendidas directamente pelo
computador (lembre-se, ele só entende a linguagem de máquina). Para que o
computador possa executar códigos escritos em linguagens de programação, existem
programas que são feitos para entender essas linguagens e traduzir os códigos para a
linguagem de máquina. Há dois tipos desses programas: os compiladores e os
interpretadores. O processo de tradução do código para a linguagem de máquina chama-
se compilação.

3
Um interpretador lê um programa escrito numa certa linguagem de programação
e imediatamente executa as instruções nelas contidas a tradução para a linguagem de
máquina é feita na hora da execução. Já um compilador apenas traduz o programa para a
linguagem de máquina (compila o programa), deixando-o pronto para ser executado
posteriormente sem depender de outro programa; isso tem a vantagem de tornar a
execução do programa mais rápida.

4
Capítulo 1. ESTRUTURA BÁSICA DE UM PROGRAMA EM C
Objectivos:
- Apresentar a estrutura básica de um programa C;
- Escrever um programa C utilizando a estrutura básica.
1.1. Regras gerais
Um programa em C é estruturado em funções, que são, basicamente, trechos
de código que podem ser chamados várias vezes para realizar uma certa tarefa. Todos os
comandos que o seu programa executar estarão dentro de alguma função. Um programa
em C é constituído de:
 Um cabeçalho contendo as directivas de compilador onde se definem o valor de
constantes simbólicas, declaração de variáveis, inclusão de bibliotecas,
declaração de rotinas, etc.
 Um bloco de instruções principal outros blocos de rotinas.
 Documentação do programa: comentários.
As funções, em geral, podem devolver valores, o resultado de algum cálculo
ou consulta e também podem receber parâmetros por exemplo, os dados de entrada para
um cálculo, ou os critérios a serem usados na busca. Nesse sentido, funções em C são
semelhantes às funções às quais nos referimos em matemática.
Por facto, em C, existe uma função “privilegiada” é a função main
(principal). Ela é como se fosse o roteiro principal do programa: a execução do
programa sempre começa por ela. Todas as outras funções (quando houver) são
chamadas, directa ou indirectamente, a partir da main.
Todo programa deve ter uma função main. Outras funções podem ser criadas
(veremos como um pouco mais adiante), e também podemos usar funções prontas, há
uma série de funções que vem disponível em qualquer compilador C, chamada de
biblioteca padrão do C.

5
É necessário não esquecer que o C é Case sensitiva, isto é, diferenciação
entre maiúscula e minúscula. Todas as instruções em C são escritas com letras
minúsculas, e a utilização de letras maiúsculas só poderá ser feita, quando desejarmos
algo por nós.
1.2. Forma geral de funções
Vamos iniciar nosso estudo com um programa extremamente simples, que
apenas imprime uma mensagem na tela:
#include <stdio.h>
int main ()
{
printf("Olá , maravilhoso mundo da programação!n");
return 0;
}
Explicamos o código acima:
#include <stdio.h>
Esta linha pede ao compilador que disponibilize para nós algumas funções de
entrada e saída de dados, que permite que o computador exiba mensagens na tela e leia
dados que o usuário digitar no teclado. Mais adiante veremos como é que essa instrução
funciona. O ficheiro stdio.h permite o acesso a todas as informações de input e output
normais.
int main()
O programa começa a partir desta linha. É aqui que definimos nossa função
main. As chaves { } servem para delimitar o seu conteúdo.
Int significa que o valor que a função devolve é um número inteiro, e os
parênteses vazios indicam que a função não recebe nenhum parâmetro. Não se preocupe
se isso não fizer muito sentido; um pouco mais adiante estudaremos funções com
detalhe, e você poderán entender melhor o que tudo isso significa. Aceitar isso como
uma “fórmula pronta” por enquanto não lhe fará nenhum mal.

6
printf("Olá, maravilhoso mundo da programação!n");
printf() é uma função usado para escrever algo na tela. Em outras palavras
podemos dizer que Essa função simplesmente toma a mensagem (uma sequência de
caracteres) que lhe foi passada e mostra-a na tela. Nessa linha, passamos como
parâmetro a essa função a mensagem que queremos imprimir (usando aspas duplas, veja
bem). E o que é aquele n intruso no final? Ele é um carácter especial que representa
uma quebra de linha indicando que qualquer coisa que for impressa depois da nossa
mensagem deve ir para a linha seguinte. Se omitíssemos o n, a próxima mensagem que
fosse eventualmente impressa sairia grudada nessa; isso é útil em várias situações, mas
não particularmente nessa; em geral é melhor terminar a saída de um program com uma
quebra de linha.
return 0;
Esta instrução serve para terminar o programa, o 0 indica para retornar nada. É
por isso essa instrução deve ser a ultima da função main(). O carácter especial
O símbolo é utilizado para retirar o significado especial que um carácter tem.
No caso do carácter aspas (“), retira-lhe o significado de delimitador, passando a
serconsiderado simplesmente como o carácter aspas.

7
Capítulo 2. VARIÁVEIS
São espaços reservados na memória para armazenar dados do mesmo tipo,
também são posições de memória que o computador reserva para armazenar os dados
manipulados pelo programa. Estas posições devem ser reservadas (declaradas) no início
do programa, a partir daí ficam disponíveis para receberem qualquer conteúdo. Este
conteúdo pode ser alterado quando necessário (daí o nome variável, pois o conteúdo
pode variar).
Objectivos:
- Diferenciar as palavras reservadas e tipos de variáveis em linguagem C;
- Descrever a declaração das variáveis e a inicialização de uma variável.
2.1. Regras gerais
O nome a atribuir a variáveis em C implica de um número reduzido de
regras:
 O nome de uma variável pode ser constituído por letras do alfabeto (minúscula e
maiúscula), dígitos (0..9) e ainda pelo carácter underscore ( _ );
 O primeiro carácter não pode ser um dígito. Terá que ser uma letra ou o carácter
underscore. No entanto é desaconselhável a utilização deste último como primeiro
letra identificativa de uma variável.
 Maiúscula e minúscula representam carácter diferentes, logo varáveis distintas.
 Uma variável não pode ter por nome uma palavra reservada à linguagem C.
Sempre que desejamos guardar um valor, que por qualquer razão não tenha
um valor fixo, devemos fazê-lo utilizando variáveis.
Uma variável não é mais que um nome que os damos uma determinada
posição de memória para conter um valor de um determinado tipo.
Uma variável é uma referencia à um dado. Como seu próprio nome indica, o
valor contido numa variável, pode variar ao longo da execução de um programa.
Uma variável deve ser sempre definida antes de ser utilizada. A definição de
uma variável indica ao compilador qual o tipo de dado que fica atribuído ao nome que
nós indicamos para essa variável.

8
Em C, há três tipos primitivos de dados: números inteiros, números de ponto
flutuante (um nome pomposo para os números fraccionários, que tem a ver com a
maneira como os computadores trabalham com eles) e caracteres (como „a‟, „#‟, „Z‟,
„5‟ — o carácter que representa o número 5, e não o número em si). A esses três tipos
de dados correspondem os quatro tipos primitivos de variáveis, listados na tabela 1.
Na verdade, eu poderia dizer que são apenas dois esses tipos: os números
inteiros eos de ponto flutuante. O que ocorre é que os caracteres são representados na
memória como se fossem números (inteiros); por exemplo, quando eu escrevo os
caracteres abc em algum lugar (em última instância, isso fica em algum lugar da
memória), o que o computador guarda na memória são os três números 97; 98; 99. Isso
está relacionado à conhecida tabela ASCII, que nada mais é que uma convenção de
quais caracteres correspondem a quais números (consulte o apêndice para ver uma
tabela ASCII completa). Por causa disso, o tipo de dados usado para armazenar
caracteres também podem ser usado para guardar números, embora isso não seja tão
comum, pois ele só permite guardar números pequenos.
Esses dois ou três tipos de dados traduzem-se em quatro tipos primitivos de
variáveis, resumidos na tabela.
Tabela 1: Os quatro tipos primitivos de variáveis na linguagem C
Tipo Utilidade
Int Armazena um número inteiro
Float Armazena um número de ponto flutuante
Double Como float, mas fornece maior precisão
Char Guarda um único carácter.
Com esse tipo também podemos guardar
sequências de caracteres (strings), mas isso requer
um outro recurso da linguagem que só veremos
mais tarde

9
Esses tipos são chamados de “primitivos” porque eles podem ser
modificados e combinados de certas maneiras, de modo a criar estruturas mais
complexas de dados (por exemplo A definição de variáveis faz-se utilizando a seguinte
sintaxe:
Tipo_Variável Nome_Variável [Nome_Variável1, Nome_Variável2, …,
Nome_Variáveln];
Exemplos:
int i; /* i é um número inteiro */
char ch1, novo_char; /* ch1 e novo_char são caracteres */
float pi, raio, perímetro; /* pi, raio e perímetro são números do tipo flutuantes */
double total, k123; /* total e k123*/
Nota: a declaração de variáveis tem que ser sempre realizada antes da sua utilização e
antes de qualquer instrução.
int main()
{
Declaração de variáveis;
Instrução1;
Instrução2;
}

10
2.2. Palavras reservadas
Auto double if static
break else int struct
case entry long switch
char extern register typedef
continue float return union
default for sizeof unsigned
do goto short while
Não é aconselhável utilizar os caracteres acentuados (ã,â, á, à, etc.) nos
nomes das variáveis, pois a grande maioria dos compiladores não os aceita como
caracteres admissíveis.
Habitualmente, o caracter underscore (_) é utilizado para separar palavras
que representam uma única variável. Ex: Num_Cliente, Idade_Aluno, etc.
Atenção:
 O nome de uma variável deve descrever aquilo que ele deve armazenar. Ex: aa,
ss vs num_factura, nome_pai.
 O nome de uma variável não deve ser todo escrito em maiúscula, pois
identificadores totalmente escritos em maiúscula são tradicionalmente utilizados
pelos programadores de C para referenciar constantes.

11
2.3. Tipos de Variáveis
1. Inteiros (int)
As variáveis declaradas do tipo inteiro são utilizadas para armazenar valores
inteiros positivos e negativos.
Ex: -3, 189, +9, 0, …
Na declaração de um inteiro podem ser utilizados 4 prefixos distintos para definir
melhor as características da variável.
 short: inteiro pequeno (2 Bytes);
 long: inteiro grande (4 Bytes)
 signed: inteiro com sinal (positivo e negativo)
 unsigned: inteiro sem sinal
Formato de escrita e de leitura de um inteiro é %d ou %i.
Ex:
# include <stdio.h>
int main()
{
int numero;
printf(“ Informe o numero: “);
scanf(“%d”, &numero); /* leitura do numero */
printf(“ O numero informado foi %d n”, numero);/* escrita do numero na tela*/
}
2. Reais (float e doble)
As variáveis do tipo float e doble são utilizados para armazenar valores
numéricos com parte fraccionária, também denominados reais ou de vírgula flutuante.
Ex: 3.14, 0.0024567, 9.0, …

12
A diferença entre variável do tipo float e uma outra do tipo double é o
numero de Bytes que reserva para armazenar o valor. A dimensão do float é
normalmente de 4 Bytes enquanto a do double é de 8 Bytes.
Ex: desenvolver um programa que calcule o perímetro e a área de uma circunferência.
#include <stdio.h>
main()
{
double pi = 3.1415, area;
float raio, perimetro;
printf(“ Introduza o Raio da circunferência: “);
scanf(“%f”, &raio);
area = pi * raio * raio;
perímetro = 2 * pi * raio;
printf(“ Area = %fnPerimetro = %fn”, área, perímetro);
}
Nota: o formato de escrita para números reais é %f.
A atribuição, leitura e escrita de números reais pode ser realizada usando a notação
científica, especificando uma base e um expoente. Pode ser 123.46E78, significa que
123.46 * 1078.
Ex: Escreva um programa que realize a conversão de toneladas quilos e gramas,
escrevendo o resultado em notação tradicional (aaaa.bbb) e científica (aaa E±bb).
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
float quilos = 1.0E3;
double gramas = 1.0e6;
float toneladas;
printf("Quantas toneladas comprou: ");

13
scanf("%f", &toneladas);
printf("Numero de quilos = %en", toneladas * quilos);
printf("Numero de gramas = %en", toneladas * gramas)
system("PAUSE");
return 0;
}
3. Caracteres - char
A variável do tipo char permite armazenar um único carácter. Um char é sempre
armazenado num Byte.
Nota: o formato de escrita e de leitura é %c. A inicialização e a declaração de uma
variável do tipo char segue a sintaxe:
char ch1 = „B‟, ch = „2‟;
Nota: a representação de caracteres em C faz-se utilizando plica (‘A’) e não aspas
(“A”).
2.4. Declaração de variáveis e Inicialização de variáveis
Sempre que uma variável é declarada, estamos a solicitar ao compilador para
reservar espaço em memória para a armazenar. Esse espaço passará a ser referenciado
através do nome da variável. Podemos dizer que uma variável quando é declarada fica
sempre com um valor, o qual resulta do estado aleatório dos bits qua a constituem.
A declaração de uma variável faz-se seguindo a sintaxe:
Tipo_Dado Nome_Variável;
Ex: Int numero;
Deste modo, uma variável pode ser inicializada com um valor através de uma
operação de atribuição.

14
A atribuição de valor em C é realizada através do sinal =, sendo a variável a
alterar sempre colocada no lado esquerdo da atribuição, e o valor a atribuir no lado
direito.
A inicialização de uma variável faz-se seguindo a sintaxe:
Tipo_Dado Nome_Variável = Valor_Da_Variável;
Ou variável = expressão;
Ex: int numero = 12;
Ou
int numero;
numero = 12;

15
Capítulo 3. OPERADORES
C é uma das linguagens com maior número de operadores, devido possuir
todos os operadores comuns de uma linguagem de alto nível, porém também possuindo
os operadores mais usuais a linguagens de baixo nível. Para fins didácticos, dividiremos
os operadores em aritméticos, lógicos e de bits. No momento abordaremos apenas as
duas primeiras classes.
Objectivos:
- Definir os diferentes tipos de operadores: aritméticos, lógicos e relacionais;
- Manipular as operações usando tipos de operadores.
3.1. ARITMÉTICOS
São operadores que ajudam a fazer operações aritméticas.

16
3.2. RELACIONAIS
São operadores que utilizados para a comparação.
3.3. LÓGICOS
Esses operadores auxiliam para encontrar valores verdadeiros e falsos.
Observação: Em C o resultado da comparação será ZERO se resultar em FALSO e
diferente de zero no caso de obtermos VERDADEIRO num teste qualquer.

17
Observemos antes de mais nada que ++x é diferente de x++!
Se
x = 10;
y = ++x;
então
x = 11 (pois x foi incrementado) e y = 11
porém Se
x = 10;
y = x++;
então
x = 11 e y = 10 (pois x foi atribuído a y antes de ser incrementado)
Se
x = 1;
y = 2;
printf("%d == %d e' %dn",x,y,x==y);
então resultaria em 1 == 2 0 (pois a expressão é falsa)
if (10 > 4 && !(10 < 9) || 3 <= 4)
resultaria em Verdadeiro pois dez é maior que quatro E dez não é menor que nove OU
três é menor ou igual a quatro.
Sizeof
É um modelador que retorna o tamanho da variável ou tipo que está em seu operando.
Por exemplo: Escreve um programa que indique qual o nº de Bytes que ocupam todos
os tipos básicos de dados em C.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{

18
printf(“O tamanho em Bytes de um char = %dn”, sizeot(char));
printf(“O tamanho em Bytes de um int = %dn”, sizeot(int));
printf(“O tamanho em Bytes de um float = %dn”, izeot(float));
printf(“O tamanho em Bytes de um double = %dn”, sizeot(double));
system("PAUSE");
return 0;
}

19
Capítulo 4. ENTRADA E SAÍDA PELO CONSOLE
Objectivos:
- Descrever os blocos de códigos que executam uma determinada tarefa;
- Determinar o tipo e nome da função a ser tratada;
4.1. FUNÇÕES DE SAÍDA
1. Função scanf()
Uma das mais importantes e poderosas instruções, servirá basicamente para
promover leitura de dados (tipados) via teclado.
Sua forma geral será: scanf("string de controle", lista de argumentos);
Posteriormente ao vermos sua sintaxe completa, abordaremos os recursos mais
poderosos da <string de controle>, no momento bastará saber que:
 %c - leitura de caracter
 %d - leitura de números inteiros
 %f - leitura de números reais
 %s - leitura de caracteres
A lista de argumentos deve conter exactamente o mesmo número de
argumentos quantos forem os códigos de formatação na <string de controlo>. Se este
não for o caso, diversos problemas poderão ocorrer incluindo até mesmo a queda do
sistema quando estivermos utilizando programas compilados escritos em C. Felizmente
ao utilizarmos o clássico C, apenas uma mensagem de erro será apresentada, para que
possamos corrigir o
programa sem outros inconvenientes.
Cada variável a ser lida, deverá ser precedida pelo carácter &, por razões que
no momento não convém explicarmos, mas que serão esclarecidas no decorrer do curso.
Para sequência de caracteres (%s), o carácter & não deverá ser usado.
Exemplo: Programa para ler e mostrar uma idade e o nome
/* Exemplo Le e Mostra Idade */

20
main()
{
int idade;
char nome[30];
scanf("%d",&idade);
scanf("%s",nome); /* Strings não utilizar '&' na leitura */
}
2. Função getchar()
A função getchar é usada unicamente para leitura de carácter. A utilização
desta função evita a presença do formato de leitura (%c), a variável não é passada como
parâmetro, assim a função getchar não precisa de & antes da variável. Exemplo:
int main()
{
char ch;
ch = getchar();
}
3. Função gets()
Função gets (get string) permite colocar na variável que recebe por
parâmetro, todos os caracteres introduzidos pelo utilizador. Ao contrário do scanf, esta
função não é limitada à leitura de uma única palavra. Exemplo:
int main()
{
char Nome[50];/* Nº de caracteres que o nome pode conter */
gets(Nome);
}

21
4.2. FUNÇÕES DE ENTRADA
1. Função printf()
Sintaxe: printf("expressão de controle”, argumentos);
É uma função de I/O, que permite escrever no dispositivo padrão (tela). A
expressão de controlo pode conter caracteres que serão exibidos na tela e os códigos de
formatação que indicam o formato em que os argumentos devem ser impressos. Cada
argumento deve ser separado por vírgula.
n nova linha %c carácter simples
t tab %d decimal
b retrocesso %e notação científica
"aspas %f ponto flutuante
barra %o octal
f salta formulário %s cadeia de caracteres
0nulo %u decimal sem sinal
%x hexadecimal
Ex:
main()
{
printf("Este é o numero dois: %d",2);
printf("%s está a %d milhões de milhasndo sol","Vênus",67);
}

22
Tamanho de campos na impressão:
Ex:
main()
{
printf("n%2d",350);
printf("n%4d",350);
printf("n%6d",350)
}
2. Função puts()
A função puts (put string) permite realizar a escrita de strings, sejam elas constantes
ou estejam armazenadas variáveis. O único aspecto a ter em consideração é que, depois
de escrita a string, a função puts faz a mudança automática de linha, isto é:
puts(“Eu sou programador”); = printf (“Eu sou programador n”);

23
EXERCÍCIOS
18. Faça um algoritmo que leia os valores de COMPRIMENTO, LARGURA e
ALTURA e apresente o valor do volume de uma caixa retangular. Utilize para o
cálculo a fórmula VOLUME = COMPRIMENTO * LARGURA * ALTURA.
19. Faça um algoritmo que leia um valor inteiro e apresente os resultados do
quadrado e do cubo do valor lido.
1.Considerando as variáveis declaradas na tabela abaixo e mais a variável
booleana TESTE, com valor FALSO, avalie as expressões a seguir, para cada
uma das três combinações de valores apresentadas:
1. Calcule o valor de cada expressão abaixo e indique o tipo do resultado (inteiro ou
real):
a) (20 - 15)/2 b) 20 - 15/2 c) 2*5/20 + 30/15*2
d) 2*(5/20) + 30/(15*2) e) 23 div 4 f) 23 mod 4
g) 35 div 6 + 2 h) 35 div 6 - 2 i) 35 div 6 * 2
j) sqrt(625) k) sqr(20) l) 2 + sqrt(21 div 5)
OBS.: sqrt(a) => (raiz quadrada de a); sqr(a) => (quadrado de a);

24
2 div 3 => (inteiro da divisão); 2 mod 3 => (resto da divisão).
1. Faz um programa que vai ler nome, endereço, telefone e imprimir
#include <stdio.h>
int main()
{
char nome[30], endereco[30], telefone[15];
printf("Informe seu nome: ");
gets(nome);
printf("Informe seu endereco: ");
gets(endereco);
printf("Informe seu telefone: ");
gets(telefone);
printf("nnNome: %snn",nome);
printf("Endereco: %snn",endereco);
printf("Telefone: %snn",telefone);
system("PAUSE");
return 0;
}
Tarefas :
a) Escreva um programa que leia um carácter digitado pelo usuário, imprima o
carácter digitado e o código ASCII correspondente a este carácter.
b) Escreva um programa que leia duas strings e as coloque na tela. Imprima também a
segunda letra de cada string.
2. Fazer um programa que imprima a média aritmética dos números 8,9 e 7. A
media dos números 4, 5 e 6. A soma das duas médias. A média das médias.

25
#include<stdio.h>
#include<stdlib.h>
main()
{
float n1=8, n2=9, n3=7, n4=4, n5=5,n6=6, somam, media3;
printf("nn A media dos numeros 8, 9 e 7 e = %2.2fnn",float((n1+n2+n3))/3 );
printf("nn A media dos numeros 4, 5 e 6 e = %2.2fnn",float((n4+n5+n6))/3 );
somam=((n1+n2+n3)/3)+((n4+n5+n6)/3);
printf("nn A soma das duas medias e = %2.2fnn",somam );
media3=(((n1+n2+n3)/3)+((n4+n5+n6)/3))/2;
printf("nn A media das medias e = %2.2fnn",media3);
printf("nn");
system("pause");
return (0);
}
3. Receber um nome no teclado e imprimi-lo dez vezes.
#include<stdio.h>
#include<stdlib.h>
main()
{
char nome[30];
int t=0, cont=1;
printf("ntDigite um nome: ");
gets(nome);
t=t+1;
printf("tnMostrar nome dez vezes:");

26
printf("nn");
for(t=1;t<=10;t++)
{
printf("n %d - %s",cont,(nome));
cont=cont+1;
}
printf("nn");
system("pause");
return( 0);
}
1. Ler um número inteiro e imprimir seu sucessor eseu antecessor.
#include<stdio.h>
#include<stdlib.h>
main()
{
int x, n1, n2;
printf("nn Digite um numero: ");
scanf("%d",&x);
n1=x+1;
n2=x-1;
printf("nnSeu sucessor e : %d",n1);
printf("nnSeu antecessor e : %d",n2);
printf("nn");
system("pause");
return (0);
}

27
5. Receber um valor qualquer do teclado e imprimir esse valor com reajuste de 10%..
#include<stdio.h>
#include<stdlib.h>
main()
{
float va;
printf("ntDigite um numero: ");
scanf("%f",&va);
printf("ntValor reajustado em 10%% e: %2.2fn",va*110/100);
printf("nn");
system("pause");
return 0;
}
6. Informar três números inteiros e imprimir a média
#include <stdio.h>
#include <stdlib.h>
int main()
{
int a,b,c;
printf("Informe um numero inteiro: ");
scanf("%d",&a);
scanf("%d",&b);
scanf("%d",&c);
printf("A media dos tres numeros informados e: %4.2fnn",float((a+b+c))/3);
system("PAUSE");

28
return 0;
}
7. Informe o tempo gasto numa viagem (em horas), a velocidade média e calcule o
consumo.
#include <stdio.h>
#include <stdlib.h>
main()
{
int horas, velmedia;
float distancia, consumo;
printf("Informe o tempo gasto na viagem em horas: ");
scanf("%d", &horas);
printf("Informe a velocidade média do veículo: ");
scanf("%d", &velmedia);
distancia = horas * velmedia;
consumo = distancia / 12;
printf("Foram gastos %4.2f de combustível",consumo);
system("pause");
return 0;
}

29
8. Ler um número inteiro e imprimir seu quadrado.
#include <stdio.h>
#include <stdlib.h>
int main()
{
float a;
scanf("%f",&a);
printf("O quadrado do numero informado e: %3.0fnn",pow(a,2)); // para usar a
potencia, usa-se pow(numero, potencia)
system("PAUSE");
return 0;
}
9. Calcule e imprima o valor em reais de cada kW o valor em reais a ser pago o
novo valor a ser pago por essa residência com um desconto de 10%. Dado: 100
quilo watts custa 1/7 do salário mínimo. Quantidade de kW gasto por residência
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main()
{
float SM, kwgasto, umkw;
printf("Informe o valor do salario minimo: ");
scanf("%f",&SM);
printf("nnInforme total Kw gasto na residencia: ");
scanf("%f",&kwgasto);

30
umkw = SM/7/100;
printf("nnO valor de 1 Kw e: %3.2fnn",umkw);
printf("nO valor a ser pago pela residencia e: %4.2f",kwgasto * umkw);
printf("nnNovo valor a ser pago com desconto de 10%% e: %3.2fnn",(kwgasto
* umkw) * 0.90);
system("PAUSE");
return 0;
}
10. Cálculo de um salario líquido de um professor. Serão fornecidos valor da hora
aula, número de aulas dadas e o % de desconto do INSS.
#include <stdio.h>
#include <stdlib.h>
int main()
{
float vha,nad,inss, salario, desconto;
printf("Informe o valor da hora aula: ");
scanf("%f",&vha);
printf("Informe o numero de aulas dadas: ");
scanf("%f",&nad);
printf("Informe o valor do percentual de desconto do INSS: ");
scanf("%f",&inss);
salário = vha * nad;
desconto = salario * inss /100;
printf("nnSalario liquido e: %3.2fnn",salário - desconto);
system("PAUSE");
return 0; }

31
11. Ler uma temperatura em graus Célsius e transformá-la em graus Fahrenheit.
12. Informar um preço de um produto e calcular novo preço com desconto de 9%

32
Capítulo 5. ESTRUTURAS EM C
As estruturas de controlo de fluxo são fundamentais para qualquer
linguagem de programação. Sem elas só haveria uma maneira do programa
ser executado: de cima para baixo comando por comando. Não haveria
condições, repetições ou saltos.
A linguagem Cpossui diversos comandos de controlo de fluxo. É
possível resolver todos os problemas sem utilizar todas elas, mas devemos nos
lembrar que a elegância e facilidade de entendimento de um programa
dependem do uso correcto das estruturas no local certo.
1. ESTRUTURAS DE DECISÃO
Objectivos:
- Identifcar o tipo de estrutura de decisão a utilizar para um determinado
problema;
- Descrever cada estrutura repetitiva.
1. Comando If
Sua forma geral é: if (condição) declaração;
A expressão na condição, será avaliada. Se ela for zero, a declaração não será
executada.
Se a condição for diferente de zero a declaração será executada. Aqui
apresentamos o exemplo de um uso do comando if:
#include <stdio.h>
int main ()
{
int num;
printf ("Digite um numero: ");
scanf ("%d",&num);
if (num>10)

33
printf ("nn O numero e maior que 10");
if (num==10)
{
printf ("nn Voce acertou!n");
printf ("O numero e igual a 10.");
}
if (num<10)
printf ("nn O numero e menor que 10");
return(0);
}
2. O comando else
Podemos pensar no comando else como sendo um complemento do comando if. O
comando if completo tem a seguinte forma geral:
if (condição)
Declaração_1;
else
declaração_2;
A expressão da condição ser avaliada. Se ela for diferente de zero a declaração 1 será
executada. Se for zero a declaração 2 será executada. É importante nunca esquecer que,
quando usamos a estrutura if-else, estamos garantindo que uma das duas declarações
será executada. Nunca serão executadas as duas ou nenhuma delas. Abaixo está um
exemplo do uso do if-else que deve funcionar como o programa da secção anterior.

34
#include <stdio.h>
int main ()
{
int num;
scanf ("%d",&num);
if (num==10){
printf ("nnVoce acertou!n");
printf ("O numero e igual a 10.n");
}
else {
printf ("nnVoce errou!n");
printf ("O numero e diferente de 10.n");
}
return(0);
}

35
3. O Comando if-else-if
A estrutura if-else-if apenas uma extensão da estrutura if-else. Sua forma geral pode ser
escrita como sendo:
if (condição_1) declaração_1;
else
else
else
if (condição_n) declaração_n;
else declaração_default;
A estrutura acima funciona da seguinte maneira: o programa começa a testar as
condições começando pela 1 e continua a testar até que ele ache uma expressão cujo
resultado dá diferente de zero. Neste caso ele executa a declaração correspondente. Só
uma declaração será executada, ou seja, só será executada a declaração equivalente à
primeira condição que der diferente de zero. A última declaração (default) é a que será
executada no caso de todas as condições darem zero e é opcional. Um exemplo da
estrutura acima:
#include <stdio.h>
int main ()
{
int num;
scanf ("%d",&num);
if (num>10)
printf ("nnO numero e maior que 10");
else if (num ==10)
{

36
printf ("nnVoce acertou!n");
printf ("O numero e igual a 10.");
}
else if (num<10)
printf ("nnO numero e menor que 10");
return(0);
}
4. O operador?
Uma expressão como:
if (a>0) B=-150;
else B=150;
Pode ser simplificada usando-se o operador ?da seguinte maneira:
B = a > 0 ? -150 : 150;
De uma maneira geral expressões do tipo:
if (condição)
expressão_1;
else
expressão_2;
podem ser substituídas por:
Condição ?Expressão_1: expressão_2;
O operador ?é limitado (não atende a uma gama muito grande de casos) mas pode ser
usado para simplificar expressıes complicadas. Uma aplicação interessante é a do
contador
circular. Veja o exemplo:

37
#include <stdio.h>
int main()
{
int index = 0, contador;
char letras[5] = "Joao";
for (contador=0; contador < 1000; contador++)
{
printf("n%c",letras[index]);
(index==3) ?index=0: ++index;
}
}
O nome João é escrito na tela verticalmente até a variável contador determinar o
término do programa. Enquanto isto a variável index assume os valores 0, 1, 2, 3, , 0, 1,
... progressivamente.

38
5. O Comando switch
O comando if-else e o comando switch são os dois comandos de tomada de decisão.
Sem dúvida alguma o mais importante dos dois é o if, mas o comando switch tem
aplicações valiosas. Mais uma vez vale lembrar que devemos usar o comando certo no
local certo. Isto assegura um código limpo e de fácil entendimento. O comando switch
próprio para se testar uma variável em relação a diversos valores pré-estabelecidos. Sua
forma geral é:
switch (variável)
{
case constante_1:
declaração_1; break;
case constante_2:
declaração_2; break;
…
case constante_n:
declaração_n; break;
default
declaração_default;
}
Podemos fazer uma analogia entre o switch e a estrutura if-else-if apresentada
anteriormente. A diferença fundamental é que a estrutura switch não aceita expressões.
Aceita apenas constantes. O switch testa a variável e executa a declaração cujo case
corresponda ao valor atual da variável. A declaração default é opcional e será executada
apenas se a variável, que está sendo testada, não for igual a nenhuma das constantes.
O comando break, faz com que o switch seja interrompido assim que uma das
declarações seja executada. Mas ele não é essencial ao comando switch. Se após a
execução da declaração não houver um break, o programa continuará executando. Isto

39
pode ser útil em algumas situações, mas eu recomendo cuidado. Veremos agora um
exemplo do comando.
switch:
#include <stdio.h>
int main ()
{
int num;
scanf ("%d",&num);
switch (num)
{
case 9: printf ("nnO numero e igual a 9.n"); break;
default: printf("nnO numero nao e nem 9 nem 10 nem 11.n");
}
return(0);
}
Tarefa: Escreva um programa que pede para o usuário entrar um número
correspondente a um dia da semana e que então apresente na tela o nome do dia.
Utilizando o comando switch.

40
Exercícios
1. Ler um numero e se for maior que 20 imprimir a metade desse numero.
#include <stdlib.h>
#include <stdio.h>
int main()
{
float numero;
printf("Informe um numero: ");
scanf("%f",&numero);
if (numero > 20)
printf("A metade desse numero e %3.2f", numero/2);
system("PAUSE");
return 0;
}
2. Ler 2 números inteiros e soma-los. Se a soma for maior que 10, mostrar o
resultado da soma.
#include <iostream.h>
#include <stdio.h>
int main()
{
float numero1, numero2;
printf("Informe o primeiro numero: ");
scanf("%f",&numero1);
printf("Informe o segundo numero: ");
if ((numero1 + numero2) > 10)

41
printf("nA soma dos numeros informados e %3.2fnn", numero1 +
numero2);
system("PAUSE");
return 0;
}
3. Ler 2 números inteiros e soma-los. Se a soma for maior que 10, mostrar o
resultado da soma.
#include <stdlib.h>
#include <stdio.h>
int main()
{
float numero1, numero2, soma;
printf("Informe o primeiro numero: ");
printf("Informe o segundo numero: ");
soma = numero1 + numero2;
if (soma > 20)
printf("nA soma dos numeros informados mais8 e %3.2fnn", soma + 8);
else
printf("nA soma dos numeros informados menos 5 e %3.2fnn", soma -5);
system("PAUSE");
return 0;
}

42
4. Ler 1 número. Se positivo, imprimir raiz quadrada senao o quadrado.
#include <stdlib.h>
#include <stdio.h>
int main()
{
float numero1;
printf("Informe um numero: ");
if (numero1 > 0)
printf("nA raiz quadrado do numero e %3.2fnn", sqrt(numero1));
else
printf("nO quadrado do numero e %3.2fnn", pow(numero1,2));
system("PAUSE");
return 0;
}
5. Informe o tipo de carro (A, B e C). Informe o percurso rodado em km e calcule o
consumo estimado, conforme o tipo, sendo (A=8, B=9 e C=12)km/litro
#include <stdio.h>
#include <stdlib.h>
main()
{
float percurso;
char tipo;
printf("Informe o tipo do carro: ");
scanf("%c", &tipo);
printf("nInforme o percurso do carro: ");

43
scanf("%f",&percurso);
if (tipo == 'a' || tipo == 'A')
printf("O consumo estimado do carro Asera %3.2f litros.n",percurso/8);
else
if (tipo == 'b' || tipo == 'B')
printf("O consumo estimado do carro A sera %3.2f litros.n",percurso/9);
else
if (tipo == 'c' || tipo == 'C')
printf("O consumo estimado do carro A sera %3.2f litros.n",percurso/12);
system("pause");
return 0;
}
6. Solicitar salario, prestação. Se prestação for maior que 20% do salario, imprimir:
Empréstimo não pode ser concedido. Senão imprimir Empréstimo pode ser
concedido.
7. Ler um número e imprimir: maior que 20, igual a 20 ou menor que 20.
8. Ler um ano de nascimento e ano actual. Imprimira idade da pessoa.
9. Um comerciante comprou um produto e quer vendê-lo com lucro de 45% se o
valor da compra for menor que 20,00; caso contrário, o lucro será de 30%. Entrar
com o valor do produto e imprimir o valor da venda.
10. Ler a idade de uma pessoa e informar a sua classe eleitoral.
 Não - eleitor (abaixo de 16 anos)
 Eleitor obrigatório (entre 18 e 65 anos)
 Eleitor facultativo (entre 16 e 18 e maior de 65anos)

44
11. Receber um número e verificar se ele é triangular. (UM NÚMERO É
TRIANGULAR QUANDO É RESULTADO DO PRODUTO DE 3 NÚMEROS
CONSECUTIVOS. EXEMPLO: 24 = 2 * 3 * 4)
12. Ler 3 números e imprimir se eles podem ou não ser lados de um triângulo.
13. Ler 2 valores e somar os dois. Caso a soma seja maior que 10, mostrar a soma.
14. Entrar com um número e imprimir a raiz quadradado número. Caso ele seja
positivo. E o quadrado dele caso seja negativo.
15. Ler um número inteiro e verificar se está compreendido entre 20 e 80. Se tiver,
imprimir “parabéns”, senão imprimir “chimpanzé”.
16. Faça um algoritmo que leia um número N e imprima “F1”, “F2” ou “F3”, conforme
a condição:
• “F1”, se N <= 10
• “F2”, se N > 10 e N <= 100
• “F3”, se n > 100
17. Construa um algoritmo que receba como entrada três valores e os imprima em
ordem crescente.
18. Considere que o último concurso vestibular apresentou três provas: Português,
Matemática e Conhecimentos Gerais. Considerando que para cada candidato
tem-se um registro contendo o seu nome e as notas obtidas em cada uma das
provas, construa um algoritmo que forneça:
 nome e as notas em cada prova do candidato
 a média do candidato
 uma informação dizendo se o candidato foi aprovado ou não. Considere que
um candidato é aprovado se sua média for maior que 7.0 e se não apresentou
nenhuma nota abaixo de 5.0

45
19. Uma empresa irá dar um aumento de salário aos seus funcionários de acordo
com a categoria de cada empregado. O aumento seguirá a seguinte regra:
• Funcionários das categorias A, C, F, e H ganharão 10% de aumento sobre o salário;
• Funcionários das categorias B, D, E, I, J e T ganharão 15% de aumento sobre o
salário;
• Funcionários das categorias K e R ganharão 25% de aumento sobre o salário;
• Funcionários das categorias L, M, N, O, P, Q e S ganharão 35% de aumento sobre o
salário;
• Funcionários das categorias U, V, X, Y, W e Z ganharão 50% de aumento sobre o
salário.
Faça um algoritmo que escreva nome, categoria e salário reajustado de cada empregado.
20. Faça um algoritmo que leia 3 números inteiros distintos e escreva o menor deles.
21. Dados três valores X, Y e Z, verificar se eles podem ser os comprimentos dos lados
de um triângulo, e se forem, verificar se é um triângulo equilátero, isóscele ou escaleno.
Se eles não formarem um triângulo, escrever uma mensagem. Antes da elaboração do
algoritmo, torna-se necessário a revisão de algumas
propriedades e definições.
Propriedade – o comprimento de cada lado de um triângulo é menor do que a soma dos
comprimentos dos outros dois lados.
Definição 1 - chama-se de triângulo equilátero o que tem os comprimentos dos três
lados iguais;
Definição 2 - chama-se de triângulo isóscele o triângulo que tem os comprimentos de
dois lados iguais;
Definição 3 - chama-se triângulo escaleno o triângulo que tem os comprimentos dos
três lados diferentes.

46
BIBLIOGRAFIA BÁSICA
ALLEN I. Holub. Enough Rope to Shoot Yourself in the Foot: rules for C and C++
programming. McGraw-Hill, 1995.
BADGER, M. Scratch 1.4: Beginner’s Guide. New York: Packt Publishing, 2009.
FARRER, H. Algorítmos Estruturados. 3ª ed. Rio de Janeiro: Ltc-Livros Técnicos e
Científicos, 1999.
FORBELLONE, A. L. V.; EBERSPACHER, H. F. LOGICA De Programação: A
Construção de Algorítmos e Estrutura de Dados. 3ª ed. São Paulo: Pearson Prentice
Hall, 2008.
Victorine Viviane Mizrahi. Treinamento em Linguagem C. Prentice-Hall, Inc., 2ª
edition, 2008.
Bibliografia complementar
Brian W. Kernighan and Dennis M. Ritchie. A Linguagem de Programação C. Editora
Campus, 1986.
CORMEN, T. H. Algorítmos: Teoria e Prática. 2ª ed. Rio de Janeiro: Elsevier, 2002.
H. Schildt. C Completo e Total. Makron Books, 3a edition, 1997.
Wiener, Richard. Turbo C, passo a passo. Campus, Rio de Janeiro, 1991.

Meu fasciculo

Recomendados

Recomendados

Mais conteúdo relacionado

Semelhante a Meu fasciculo

Semelhante a Meu fasciculo (20)

Último

Último (6)

Meu fasciculo