Apostila de Introdução A Programacao - Silvia Campos

Introdução à Programação - IPRJ/UERJ
Professora: Sílvia Campos
Sumário
Conceitos básicos de programação ................................................................................................................. 1
Etapas para o desenvolvimento de um programa: ....................................................................................... 4
Tipos de algoritmos (os mais usados): ........................................................................................................ 5
Uma visão geral de C ................................................................................................................................. 7
Expressões e tipos de dados ................................................................................................................... 9
Identificadores: ...................................................................................................................................... 9
Variável:............................................................................................................................................... 10
Comandos de entrada e saída .............................................................................................................. 12
Variáveis locais X variáveis globais ....................................................................................................... 15
Funções matemáticas ............................................................................................................................... 17
Operadores: ............................................................................................................................................. 19
Lista de Exercícios 1 ................................................................................................................................ 22
Comandos de Controle do Programa ............................................................................................................ 24
1- Comandos de Seleção .......................................................................................................................... 24
Comando if: ......................................................................................................................................... 24
Estrutura switch/case:.......................................................................................................................... 26
2- Comandos de Iteração .......................................................................................................................... 29
2.1- O laço for ...................................................................................................................................... 29
Exemplo de execução:.......................................................................................................................... 31
2.2- O laço while .................................................................................................................................. 31
2.3- O laço do-while ............................................................................................................................. 32
3- Comandos de desvio ............................................................................................................................ 34
Vetor ........................................................................................................................................................... 37
Matriz.......................................................................................................................................................... 43
Lista de exercícios 5 ................................................................................................................................ 45
Funções: ...................................................................................................................................................... 46
Tipos de funções: ..................................................................................................................................... 46
1- Funções sem passagem de parâmetro e sem retorno ................................................................... 46
2- Funções com passagem de parâmetro e sem retorno ................................................................... 47
3- Funções sem passagem de parâmetro e com retorno ................................................................... 48
4- Funções com passagem de parâmetro e com retorno ................................................................... 49
Protótipo de função: ................................................................................................................................. 50
Passagem de parâmetros por valor:........................................................................................................... 50
Ponteiros.................................................................................................................................................. 52
Passagem de parâmetros por referência: ................................................................................................... 53
Manipulação de cadeia de caracteres .......................................................................................................... 59
Lista de exercícios 7 ................................................................................................................................. 69
Arquivos ...................................................................................................................................................... 71
Lista de exercícios 8 ................................................................................................................................. 78
Conceitos básicos de programação
Computador digital: dispositivo eletrônico que recebe, manipula e armazena informações (dados), capaz de
processar vários tipos diferentes de dados:numéricos, caracteres (nomes, endereços,...), gráficos (tabelas,
desenhos,...) e som. As aplicações técnicas e científicas preocupam-se fundamentalmente com dados
numéricos, enquanto aplicações comerciais normalmente envolvem processamento tanto numérico como de
caractere. Possui duas partes diferentes que trabalham juntas: o hardware (partes físicas) e o software
(programas).
Memória: dispositivo de armazenamento de informação. Toda informação armazenada dentro da memória

do computador é codificada como uma combinação de zeros e uns. Esses zeros e uns são chamados de bits
(dígitos binários). Cada bit é representado por um dispositivo eletrônico que está “ligado” (um) ou
“desligado” (zero).
Computadores pequenos têm memória organizada em múltiplos de 8 bits denominados bytes. Os bits
são numerados individualmente, começando com 0 (para o bit mais à direita) e estendendo-se até sete (para o
bit mais à esquerda). Normalmente, um caractere (por exemplo, uma letra, um dígito ou um símbolo de
pontuação) ocupará um byte de memória. Uma instrução pode ocupar 1, 2 ou 3 bytes. Uma quantidade
numérica pode ocupar de 1 a 8 bytes, dependendo da sua precisão (isto é, o número de posições significativas)
e do seu tipo (inteiro, ponto-flutuante, etc.).
Bit n. 7 6 5 4 3 2 1 0
Um byte
O tamanho da memória de um computador é normalmente expresso como algum múltiplo de 2 10 =

1.024 bytes. Esse número (1.024) é chamado de 1k (1 Kylobyte). Computadores pequenos mais antigos
tinham memória cujo tamanho típico variava de 64k até vários megabytes, onde um megabyte (1 MB)
equivale a 210 x 210= 1.024 kbytes. As memórias também podem ser expressas:em Gigabytes (GB), onde 1 GB
= 1.024 Mbytes; em Terabytes (TB), 1 TB = 1024 GB; emPetabytes (PB), 1 PB = 1024 TB.
1
Existem vários tipos de memória. A memória de acesso aleatório (RAM: Random Access Memory) é
um tipo de memória que permite a leitura e a escrita e é onde basicamente ficam armazenados os programas
básicos operacionais.
Memórias RAM
Cada célula ou byte tem um único endereço que indica sua posição relativa na memória e que permite
identificar a posição para armazenar ou recuperar informação. A informação armazenada em uma posição de
memória é o seu conteúdo.
Programa: conjunto de instruções que descreve uma tarefa a ser realizada por um computador, escrito numa
linguagem precisa chamada linguagem de programação.
As linguagens de programação servem para escrever programas que permitem a comunicação entre
usuário e máquina.Um programa armazenado na memória pode ser executado a qualquer momento.
Categorias principais de linguagem de programação:
1- Linguagem de máquina: linguagem utilizada para programação nos primeiros computadores. Tal
linguagem usa sequências de zeros e uns (bits) que representam instruções precisas para computação e acessos
de dados. O código de máquina é conhecido como código binário. As instruções em linguagem de máquina
dependem do hardware do computador e, portanto, mudam de um computador para outro.
2- Linguagem de baixo nível (linguagem Assemby: montadora): também dependente da máquina.

Composta de instruções conhecidas como mneumônicas – usam caracteres alfabéticos para representar as
configurações de bits da linguagem de máquina. As letras usadas descrevem as operações a serem realizadas.
Linguagens Assembly representam um nível mais alto de abstração do que as linguagens de máquina.
Exemplo de instruções: ADD, SUB, DIV...
Exemplo de instrução de soma: ADD, M, N, P. Significa: adicione o número contido na posição de
memória M ao número armazenado em N e coloque o resultado na posição de memória P.Em linguagem de
máquina seria: 0110 1001 1010 1011.
Um programa escrito em linguagem montadora não pode ser executado diretamente pelo computador
– essencialmente esta é a diferença para a linguagem de máquina. Requer uma fase de tradução para a
linguagem de máquina.
3- Linguagem de alto nível: assemelha-se à linguagem natural. Dados e operaçõessão representados por
declarações descritivas. Exemplo: adicionar dois números e depositar a soma em um terceiro número, em
linguagem C: c = a + b;
Os operandos a e brepresentam os dois números a serem adicionados e a variável c representa o total.
O operador “=”é o operador de atribuição. Ele significa que a soma dos valores em a e b será atribuída a c (ou
seja, c recebe a + b). Uma variável representa um espaço de memória para armazenar um dado.
Exemplo de linguagens de alto nível: C, C++, Pascal, Fortran, Java.
Tradutores de linguagem: programas que traduzem os programas-fonte escritos em linguagem de alto nível
para código de máquina.
1- Interpretadores: obtêm um programa-fonte, o traduz e depois o executa. Ex: Basic. Ele recebe a primeira
instrução do programa fonte, confere para ver se está escrita corretamente, converte-a em linguagem de
máquina e então ordena ao computador que execute esta instrução. Depois repete o processo para a segunda
2
instrução, e assim sucessivamente, até a última instrução do programa fonte. Quando a segunda instrução é
trabalhada, a primeira é perdida, isto é, apenas uma instrução fica na memória em cada instante.
Se este programa fonte for executado uma segunda vez, novamente haverá uma nova tradução,
comando por comando, pois os comandos em linguagem de máquina não ficam armazenados para futuras
execuções.
Programa fonte Interpretador Tradução e execução linha a linha
2- Compiladores: os programas são transformados por inteiro em um conjunto de instruções que podem ser
fisicamente efetuadas por um computador.
Programa fonte Compilador Programa Objeto
O programa conversor recebe a primeira instrução do programa fonte, confere-a para ver se está
escrita corretamente, converte-a para linguagem de máquina em caso afirmativo e passa para a próxima
instrução, repetindo o processo sucessivamente até a última instrução do programa fonte. Caso tenha
terminado a transformação da última instrução do programa fonte e nenhum erro tenha sido detectado, o
computador volta à primeira instrução, já transformada para linguagem de máquina e executa-a. Passa à
instrução seguinte, executa-a, etc., até a última.
Vantagem: se este programa for executado uma segunda vez, não haverá necessidade de uma nova
tradução, uma vez que todos os comandos em linguagem binária foram memorizados em um novo programa
completo.
Fases da compilação:
Código-fonte ou programa-fonte. Programa e/ou subprogramas escritos pelo programador, através de algum
tipo de editor de texto, de acordo com as regras de cada linguagem de programação de alto nível.
Código-objeto ou programa-objeto. Programa-fonte traduzido pelo compilador. O compilador transcreve o

programa-fonte em uma linguagem de baixo nível (ex: assembler ou outro código diretamente interpretável
pela CPU). O programa-objeto não pode ainda ser executado; ainda precisa pela fase de linking(linkagem).
Linkeditor. Um programa que une funções compiladas separadamente em um programa. Ele combina as
funções da biblioteca C padrões com o código escrito pelo programador. A saída do linkeditor é um programa
executável.
Programa executável: programa a ser executado pelo programador.
Programa fonte Compilador (tradutor) Programa objeto
Linkeditor Programa executável

em linguagem de máquina
Tempo de compilação:os eventos que ocorrem enquanto o seu programa está sendo compilado. Uma
ocorrência comum em tempo de compilação é um erro de sintaxe.
Tempo de execução:os eventos que ocorrem enquanto o seu programa é executado.
Velocidade e confiabilidade. Por sua alta velocidade, um computador pode executar, em apenas poucos
minutos, cálculos que poderiam exigir muito mais tempo, se feitos manualmente. Tarefas simples, como
adição de vários números podem ser executadas em uma fração de um microssegundo (10 -6segundos) ou
menos. Essa alta velocidade é acompanhada por um alto nível de confiabilidade. Um computador
praticamente nunca comete um erro espontaneamente. Os altamente divulgados "erros de computadores",
como uma pessoa recebendo uma conta de telefone errada, são resultados de erros programação ou erros de
entrada de dados e não erros causados pelo computador propriamente dito.
3
A execução de um programa produz os seguintes efeitos:
1. Um conjunto de informações, denominados dados de entrada, é inserido no computador (através de teclado,

pen drive, etc..) e armazenado em uma parte da memória do computador.
2. Os dados de entrada são, então, processados para produzir os resultados desejados, conhecidos como dados
de saída.
3. Os dados de saída, e talvez alguns dos dados de entrada, são impressos em papel ou mostrados na tela do
vídeo, ou ainda armazenados em arquivos.
Os dados de entrada são convertidos em informação significativa:
DADOS: valores brutos e números. INFORMAÇÃO: dados processados.
Exemplo: Um computador foi programado para calcular a área de um círculo utilizando a fórmula 𝐴 = 𝜋𝑟 2 .
O valor numérico do raio 𝑟 é o dado de entrada. Os seguintes passos serão executados:
1. Ler o valor numérico do raio do círculo (r).
2. Calcular o valor da área (A), utilizando a fórmula dada(esse valor será armazenado, juntamente com o
dado de entrada, na memória).
3. Imprimir (ou mostrar na tela) o valor do raio (r) e a área correspondente (A).
Cada um desses passos exigirá uma ou mais instruções de um programa.
Etapas para o desenvolvimento de um programa:
Análise – nesta etapa estuda-se o enunciado do problema para definir os dados de entrada, o processamento e
os dados de saída.
Algoritmo – é uma ferramenta do tipo: descrição narrativa, fluxograma ou português estruturado
(pseudocódigo). Usado para descrever o problema e suas soluções.
Codificação – O algoritmo é transformado em códigos da linguagem de programação escolhida para se
trabalhar.Portanto, um programa é a codificação de um algoritmo em uma linguagem de programação.
Algoritmo:
Processo sistemático para a resolução de um problema. Significa descrever, de forma lógica, os passos
a serem executados no cumprimento de determinada tarefa. Um algoritmo correto deve possuir 3
qualidades:
1- Cada passo no algoritmo deve ser uma instrução que possa ser realizada.
2- A ordem dos passos deve ser precisamente determinada.
3- O algoritmo deve ter fim.
Exemplo de um procedimento que não é um algoritmo (por não satisfazer a condição 3):
Procedimento para contar:
Passo 1: Faça 𝑁 igual a zero

Passo 2: Some 1 a 𝑁.
Passo 3: Volte ao passo 2
Exemplos de algoritmos corretos (que satisfazem as três condições):
4
1) Procedimento para contar até 100:
Passo 1: Faça 𝑁 igual a zero

Passo 2: Some 1 a 𝑁.
Passo 3: Se N é menor que 100, volte ao Passo 2, senão pare.
2) Procedimento para somar três números:
Passo 1 - Receber os três números.

Passo 2 - Somar os três números.
Passo 3 - Mostrar o resultado obtido.
3) Procedimento para sacar dinheiro no Banco 24 horas
Passo 1 - Ir até um banco 24 horas.

Passo 2 - Colocar o cartão.
Passo 3 - Digitar a senha.
Passo 4 - Solicitar a quantia desejada.
Passo 5 - Se o saldo for maior ou igual à quantia desejada, sacar;
Caso contrário, mostrar mensagem de impossibilidade de saque.
Passo 6 - Retirar o cartão.
Passo 7 - Sair do banco 24 horas.
Obs: um mesmo problema pode ser resolvido de diversas maneiras e gerar a mesma resposta, ou seja,
podem existir vários algoritmos para solucionar o mesmo problema!!
Tipos de algoritmos (os mais usados):
1- Descrição narrativa: consiste em analisar o enunciado do problema e escrever utilizando uma linguagem
natural (ex: a língua portuguesa), os passos a serem seguidos para a sua resolução.
2- Fluxograma: utiliza símbolos gráficos pré-definidos. Principais símbolos:
Terminação. Símbolo utilizado para indicar o início e o fim do algoritmo.
Sentido. Permite indicar o sentido do fluxo de dados. Serve exclusivamente para

conectar os símbolos ou blocos existentes
Processo. Símbolo utilizado para indicar cálculos e atribuição de variáveis.
Dados. Símbolo utilizado para representar a entrada de dados.
Documento, Símbolo utilizado para representar a saída de dados.
Decisão. Símbolo utilizado para indicar que deve ser tomada uma decisão,
apontando a possibilidade de desvios.
3- Pseudocódigo (Pseudolinguagem ou Portugol): utiliza regras pré-definidas que facilitam a passagem do

algoritmo para qualquer linguagem de programação.
VisuAlg (https://visualg3.com.br/): programa para editar e implementar algoritmos.
5
Na definição de uma linguagem, precisamos fixar: sua sintaxe: como escrever os comandos e seus
componentes (tipos, variáveis, etc) e a sua semântica: o significado de cada comando e conceito.
Exemplos de algoritmos com os três tipos citados acima:
Exemplo1: Faça um algoritmo para mostrar o resultado da multiplicação de dois números:
1- Algoritmo em descrição narrativa:
PASSO 1 – Receber os dois números que serão multiplicados.

PASSO 2 – Multiplicar os dois números.
PASSO 3 – Mostrar o resultado obtido na multiplicação.
2- Algoritmo em fluxograma: 3- Algoritmo em pseudocódigo:
ALGORITMO
DECLARE N1, N2, M NUMÉRICO
ESCREVA "Digite dois números"
LEIA N1, N2
M ⟵ N1 * N2
ESCREVA "Multiplicação = ", M
FIM_ALGORITMO.
Exemplo2: Faça um algoritmo para mostrar o resultado da divisão de dois números.
PASSO 1- Receber os dois números para divisão: numerador e o denominador.

PASSO 2- Verificar se o denominador é zero.
PASSO 3- Se o denominador for zero, apresentar uma mensagem de que é impossível dividir;
senão, dividir os números e mostrar o resultado da divisão.
2- Algoritmo em fluxograma 3- Algoritmo em pseudocódigo
ALGORITMO
DECLARE N1, N2, D NUMÉRICO
ESCREVA "Digite dois números"
LEIA N1, N2
SE (N2 = 0)
ENTÃO ESCREVA "Impossível dividir"
SENÃO
INÍCIO
D ⟵ N1/N2
ESCREVA "Divisão = ", D
FIM
FIM_ALGORITMO.
Exemplo 3: Faça um algoritmo para calcular a média aritmética entre duas notas de um aluno e mostrar a sua
situação, que pode ser aprovado ou reprovado.
PASSO 1 - Receber as duas notas.
6
PASSO 2 - Calcular a média aritmética.
PASSO 3 - Mostrar a média aritmética.
PASSO 4 - Se a média aritmética for maior ou igual a 7, então a situação do aluno é aprovado;
senão, a situação é reprovado.
2- Algoritmo em fluxograma: 3- Algoritmo em pseudocódigo:
ALGORITMO
DECLARE N1, N2, Media NUMÉRICO
ESCREVA "Digite as duas notas"
LEIA N1, N2
Media ⟵ (N1 + N2)/2
ESCREVA "Média = ", Media
SE M >=7
ENTÃO ESCREVA "Aprovado"
SENÃO
ESCREVA "Reprovado"
FIM_ALGORITMO.
Uma visão geral de C
A linguagem C foi inventada e implementada por Dennis Ritchie em um DEC PDP-11 que utilizava o
sistema operacional UNIX.
C uma linguagem de médio nível para computadores: combina elementos de linguagens de alto nível
com a funcionalidade da linguagem Assembly. A linguagem C permite a manipulação dos bits, bytes e
endereços - elementos básicos para o funcionamento do computador. Um código escrito em C é muito
portável. Portabilidade: possibilidade de adaptar um software escrito para um tipo de computador a outro.
Linguagens de alto nível - conceito de tipo de dado: conjunto de valores que uma variável pode
armazenar e o conjunto de operações que pode ser executado com essa variável. Ex: inteiro, caractere e real.
Bloco de código: grupo de comandos de programa conectado logicamente e tratado como uma
unidade, entre chaves. Exemplo:
Em pseudocódigo:
7
Palavras-chave (ou palavras reservadas) da linguagem C
:
Observações:
- Todas as palavras-chave são minúsculas.
- Maiúsculas e minúsculas são diferentes: else é uma palavra-chave, mas ELSE não é!
- Uma palavra-chave não pode ser usada com nenhum outro propósito, como uma variável ou nome de uma
função.
Todo o programa em C consiste em uma ou mais funções.Uma função contém instruções que
especificam as operações a serem executadas e as variáveis armazenam valores usados durante a computação.
Função main(): precisa estar presente em todos os programas - primeira função a ser chamada quando
a execução do programa começa.
Forma geral de uma programa em C (onde f1() a fn() são funções definidas pelo usuário):
Obs: um bloco de código inicia-se em abre-chaves ( { ) e termina em fecha-chaves ( } ).
8
Exemplo de um programa em C:
As bibliotecas são arquivos contendo várias funções que podem ser incorporadas aos programas
escritos em C. A diretiva #include faz com que o texto contido na biblioteca especificada seja inserida no
programa. Exemplo: as bibliotecas stdio.h e conio.h permitem a utilização de diversos comandos de entrada e
saída.
Todo comando deve ser finalizado com o sinal de ponto e vírgula (;).
Expressões e tipos de dados
As expressões são formadas pelos elementos mais básicos de C: dados e operadores. Os dados são
representados por variáveis ou constantes.
Os dados numéricos podem ser números inteiros ou reais, positivos ou negativos. Os números inteiros
não possuem parte fracionária (Ex.: -23, 34, 0). Os números reais possuem parte fracionária (Ex.: 100.13, -23,
3.0). Os caracteres podem ser letras maiúsculas ou minúsculas, e os caracteres especiais (Ex.: &,#,@,?,+).
Existem cinco tipos básicos de dados: caractere (char), inteiro (int), ponto flutuante (float), ponto
flutuante de precisão dupla (double) e sem valor (void).
O tamanho e a faixa desses tipos de dados variam de acordo com o tipo de processador e com a
implementação do compilador C. O padrão ANSI (American National Standard Institute) estipula apenas a
faixa mínima de cada tipo de dado, não o seu tamanho em bytes.
Tipos básicos:
Identificadores:
Nomes escolhidos para rotular os nomes das variáveis, dos programas, das constantes, procedimentos,
funções, etc.
Regras:
 O primeiro caractere deve ser sempre uma letra ou o caractere sublinhado (_).
 Os demais caracteres podem ser: números, letras maiúsculas, letras minúsculas e o caractere
sublinhado.
 Os nomes escolhidos devem explicitar seu conteúdo.
9
 Não podem ser usadas palavras reservadas, ou seja, palavras que pertençam à linguagem de
programação.
 Não são permitidos espaços em branco e caracteres especiais (@, $, + , - , %, !).
Exemplos de identificadores válidos:
A, idade, Dia, nota1, media_total
Exemplos de identificadores inválidos:
8ab - começa com um número,

e 12 - contém espaço em branco,
nota(10) - contém caracteres especiais ()
set - palavra reservada,
case - palavra reservada,
x+y - contém caractere especial
Variável:
Representa uma posição nomeada de memória, usada para guardar um valor que pode ser modificado
pelo programa.
 Possui nome e tipo;
 O conteúdo pode variar ao longo do tempo, durante a execução de um programa;
 Pode assumir valores diferentes, mas só pode armazenar um valor a cada instante;
 Todas as variáveis devem ser declaradas antes de serem usadas.
Declaração de variáveis:
Forma geral de declaração de variável: tipo lista_de_variáveis;
onde tipo deve ser um tipo de dado válido em Ce lista_de_variáveis pode consistir em um ou mais
nomes de identificadores separados por vírgula.
C não possui tipo de dados boolean (que pode assumir os valores verdadeiro ou falso), pois considera
verdadeiro qualquer valor diferente de 0 (zero).
C Não possui um tipo especial para armazenar cadeias de caracteres (strings). Deve-se utilizar um
vetor contendo vários elementos do tipo char.
Exemplo de algumas declarações:
int numero, valor, opcao;Declara três variáveis em que podem ser armazenados três números inteiros.
floatX; Declara uma variável chamada X em que pode ser armazenado um número real.
unsigned int x; Declara uma variável em que pode ser armazenado um valor inteiro sem sinal.
char letra; Declara uma variável letra em que pode ser armazenado um caractere.
char nome[50]; Declara uma variável nome em que podem ser armazenados até 50 caracteres.
Todo computador possui uma tabela de alocação que contém o nome da variável, seu tipo (para saber
quantos bytes ocupará) e seu endereço inicial de armazenamento. Dessa maneira, para buscar algum dado na
memória, basta sabermos o nome da variável, e o computador, por meio da tabela de alocação, busca
automaticamente.
10
Comando de atribuição: Utilizado para conceder valores ou operações à variáveis. Representado por = (sinal
de igualdade).
Exemplos: x = 4; x = x + 2; y = 2.5; sexo = 'F';
Os caracteres são representados entre apóstrofos ( ' ).
As cadeias de caracteres são representadas entre aspas ( " ). Para armazenar uma cadeia de
caracteres dentro de uma variável, deve-se utilizar uma função para manipulação de caracteres. Ex: strcpy
(nome, "Joao");
Para que seja possível a utilização da função strcpy, deve-se inserir no programa, por meio da diretiva
include, a biblioteca string.h.
Declaração e inicialização de variáveis:
Forma geral:
tipo nome_da_variável = constante;
Exemplos:
char ch='a';
int first = 0;
float balance = 123.44;
Constantes:
Valores fixos que o programa não pode alterar. Podem ser de qualquer um dos tipos de dados básicos.
A maneira como cada constante é representada depende do seu tipo.
Constantes inteiras: números sem componentes fracionários. Ex: 200, 23.
Constantes de caractere: envolvidas por aspas simples ('). Ex: 'a', 'z', '7', '%'.
Constantes em ponto flutuante: requerem o ponto decimal seguido pela parte fracionária do número
ou notação científica. Ex: 100.23.
Constantes String: conjunto de caracteres colocados entre aspas duplas. Ex: "Cálculo de uma area".
O C não possui formalmente um tipo de dado string.
E possível especificar precisamente o tipo da constante numérica por meio de um sufixo:
Tipo de dado Exemplos de constantes
int 1 223 25444 -34
long int 45333L -34L
short int 10 -22 90
unsigned int 20000U 888U 4000
float 123.33F 4.34e-3F
double 123.33 -0.9856432
long double 2000.2L
11
Constantes caractere de barra invertida. Exemplo:
Código Códigos de barra invertida

\n nova linha
\t tabulação horizontal
\v tabulação vertical
\" aspas duplas
\' aspas simples
\\ barra invertida
Por exemplo, o programa seguinte envia à tela um caractere de nova linha e uma tabulação e, em
seguida, escreve a string Testando o programa.
#include <stdio.h>
int main()
{
printf ("\n\tTestando o programa");
return 0;
}
Modificadores do tipo const indicam variáveis que não podem ser modificadas pelo programa, mas
podem receber um valor inicial.
Exemplo: const int a=10;
cria uma variável inteira chamada a, com um valor inicial 10, que o programa não pode modificar.
Comandos de entrada e saída

Uma função de entrada/saída pode ser acessada de qualquer ponto de um programa, escrevendo-se o nome da
função seguido ou não por uma lista de argumentos colocados entre parênteses, dependendo da função. Os
argumentos representam dados que são enviados para a função. Para a maioria das funções, é necessário
incluir a biblioteca stdio.h: #include <stdio.h>.
Comandos de entrada: são usados para receber dados digitados pelo usuário, por exemplo, via teclado. Os
dados recebidos são armazenados em variáveis. Exemplos:
Comando Definição
cin>> x; Um valor digitado pelo usuário será armazenado na variável x.
Armazena os caracteres até que seja encontrado o primeiro espaço em branco (os
caracteres posteriores são descartados).
Uso apenas em C++.
getchar(); Uso: variável caractere = getchar();
A função devolve um caractere individual inserido em um dispositivo de entrada padrão
(ex.: um teclado)
gets(nome); Um ou mais caracteres digitados pelo usuário serão armazenados na variável nome.
Este comando geralmente é usado quando se deseja digitar uma cadeia de caracteres
contendo espaços em branco. Ex: Maria Jose.
Obs: esse comando não é recomendável.
scanf("%d",&x); Um valor numérico inteiro digitado pelo usuário será armazenado na variável x.
12
Função scanf
Sintaxe: scanf (string de controle, arg1, arg2, ..., arg n)
onde string de controle refere-se a uma string que contém certas informações de formato necessárias, e arg1,
arg2, ..., argn são argumentos que representam os dados de entrada individuais. Os argumentos são variáveis
ou matrizes, cujos tipos combinam com o grupo de caracteres correspondente na string de controle. Cada
nome de variável deve ser precedido por um ampersand (&). Os argumentos são, na verdade, ponteiros que
indicam onde os dados estão armazenados na memória do computador. Nomes de matrizes não devem
começar com um ampersand (obs: esses conceitos de ponteiros e matrizes serão vistos detalhadamente mais
adiante neste material).
A string de controle contém grupos de caracteres individuais com um grupo de caractere para cada
dado de entrada. Na sua forma mais simples, um grupo de caractere deve começar com um sinal de
porcentagem (%) seguido por um caractere de conversão, que indica o tipo do dado correspondente.
Caracteres mais utilizados para conversão de entrada de dados:
Caractere de conversão Significado

c O item de dados é um caractere único
d O item de dados é um inteiro decimal
e, f ou g O item de dados é um valor em ponto-flutuante
i O item de dados é um inteiro decimal, hexadecimal ou octal
o O item de dados é um inteiro decimal, octal
s O item de dados é uma string seguida por um espaço em branco (o caractere \0
será adicionado automaticamente no final)
u O item de dados é um inteiro decimal sem sinal
x O item de dados é um inteiro hexadecimal
[^\n] O item de dados é uma string que pode incluir espaços em branco
Exemplo de entrada de duas cadeias de caracteres que permitem espaço em branco. Obs: a variável que
representa a string NÃO é precedida de & na função scanf!
#include <stdio.h>
int main()
{
char nome[50], endereco[50];
printf("Entre com o nome e o endereço:\n");
scanf ("%[^\n] ", nome); //atenção ao espaço antes da segunda chave!
scanf ("%[^\n]", endereco);
printf("\n nome=%s", nome);
printf("\n endereco=%s", endereco);
return 0;
}
Os caracteres não-brancos consecutivos que compõem um dado definem um campo. É possível

limitar o número desses caracteres especificando um tamanho de campo máximo para o dado. Para isso, é
colocado um inteiro sem sinal indicando o tamanho do campo na string de controle, entre o sinal de
porcentagem % e o caractere de conversão. Quaisquer caracteres que apareçam além do tamanho do
campo especificado não serão lidos. Esses caracteres que não foram lidos podem ser incorretamente
interpretados como componentes do próximo dado.
13
Comandos de Saída: usados para exibir dados e informações, por exemplo, na tela ou na impressora.
Exemplos:
Comando Definição
cout<< x; Mostra o valor armazenado na variável x.
Uso apenas em C++
cout<< "Conteudo de x = ", << x; Mostra a mensagem "Conteúdo de x= " e em seguida o valor
armazenado na variável x.
putchar(variável caractere) Transmite um caractere individual para um dispositivo de saída
padrão (por exemplo, um monitor de vídeo)
printf ("%d",y); Mostra o número inteiro armazenado na variável y.
printf ("Conteudo de y = %d",y); Mostra a mensagem "Conteúdo de y= " e em seguida o número
inteiro armazenado na variável y.
printf ("%f",x); Mostra o número real armazenado na variável x.
printf("%5.2f", x); Mostra o número real na variável x de comprimento total cinco e
com duas casas decimais.
Função printf
Sintaxe: printf (string de controle, arg1, arg2, ..., arg n)
onde string de controle refere-se a uma string que contém informações de formato e arg1, arg2, ... ,arg n são
argumentos que representam os dados de saída individuais. Obs: os argumentos da função printf não
representam endereços de memória e, portanto, não são precedidos por ampersand (&).
A string de controle contém grupos de caracteres individuais com um grupo de caractere para cada dado
de saída. Na sua forma mais simples, um grupo de caractere individual é formado por um sinal de
porcentagem (%) seguido por um caractere de conversão, que indica o tipo do dado correspondente
Obs.: Nas funções scanf e printf, é preciso indicar o tipo de variável que está sendo considerada. Alguns dos
tipos mais comuns:
 %f: para variáveis que armazenam números reais;
 %d:para variáveis que armazenam números inteiros decimais;
 %c: para variáveis que armazenam um único caractere;
 %s: para variáveis que armazenam um conjunto de caracteres.
Exemplo de um programa C que utiliza diversas rotinas de entrada/saída da biblioteca padrão do C:
14
Exemplo de saída:
Variáveis locais X variáveis globais
Declaração das variáveis:

- dentro de funções (variáveis locais),
- na definição dos parâmetros das funções (parâmetros formais) e
-fora de todas as funções (variáveis globais).
Variáveis locais:
- só podem ser referenciadas por comandos que estão dentro do bloco no qual as variáveis foram
declaradas, ou seja, não são reconhecidas fora do seu próprio bloco de código.
- existem apenas enquanto o bloco de código em que foram declaradas está sendo executado, ou seja,
ela é criada na entrada de seu bloco e destruída na saída. O seu conteúdo é perdido quando o bloco deixa de
ser executado.
- o bloco de código mais comum em que as variáveis locais foram declaradas é a função. Ex:
void func1(void)
{
int x;
x = 10;
}
void func2(void)
{
int x;
x = -190;
}
A variável inteira x é declarada duas vezes, uma vez em func1() e outra em func2(). O x em func1()
não tem nenhuma relação ou correspondência com o x em func2(). Cada x é reconhecido apenas pelo código
que está dentro do mesmo bloco da declaração de variável.
Também podem ser declaradas dentro de qualquer bloco de código. Vantagem: a memória para ela só
será alocada se necessário. Isso acontece porque variáveis locais não existirão até que o bloco em que elas são
declaradas seja iniciado. Exemplo:
void f(void)
15
{
int t;
printf("Entre com um valor inteiro:");
scanf("%d", &t);
if (t==1) {
char s[40]; //Criada apenas na entrada do bloco
printf("Entre com o nome:");
scanf(" %[^\n]",s);
printf("Nome digitado = %s", s);
}
/* algumas outras instruções... */
}
Neste, exemplo, a variável local s é criada na entrada do bloco de código if e destruída na saída. Além
disso, s é reconhecida apenas dentro do bloco if e não pode ser referenciada em qualquer outro lugar.
Devem serdeclaradas no início do bloco em que elas são definidas, antes de qualquer comando do
programa. Exemplo:
/* Define i e j no início do bloco da função. */

void f(void)
{
int i;
int j;
i=10;
j=100;
...
}
Exemplo de um programa para Calcular a área de um círculo:
#include <stdio.h>
int main()
{
float raio, area; //Declaração de variáveis
printf(“Raio = ?”); //Instrução de saída
scanf(“%f”, &raio); //Instrução de entrada
area = 3.14159 * raio * raio; //Instrução de entrada
printf(“\nArea = %f”, area); //Instrução de saída
return 0;
}
Variáveis globais:
- Variáveis reconhecidas pelo programa inteiro e podem ser usadas por qualquer pedaço de código.
- Guardam os seus valores durante toda a execução do programa.
- São declaradas fora de qualquer função.
- Podem ser acessadas por qualquer expressão, independentes do bloco de código que contém a
expressão.
Exemplo:
16
Observações:
1) Apesar de nem main() nem func1() terem declarado a variável count, ambas podem usá-la.
2) A função func2() declarou uma variável local chamada count. Quando ela referencia count, ela
referencia apenas a sua variável local, não a variável global.
Se uma variável global e uma variável local possuem o mesmo nome, todas as referências ao nome da
variável dentro do bloco onde a variável local foi declarada dizem respeito à variável local e não tem efeito
algum sobre a variável global.
Úteis quando o mesmo dado é usado em muitas funções no programa. Porém, deve-se evitar usar
variáveis globais desnecessárias, pois ocupam memória durante todo o tempo em que o programa está sendo
executado, e não apenas quando são necessárias!
Usar um grande número de variáveis globais pode levar a erros no programa devido a efeitos
colaterais desconhecidos e indesejáveis. Problema: mudança acidental no valor de uma variável porque ela é
usada em algum outro lugar do programa.
Funções matemáticas
Exemplos de algumas funções matemáticas da biblioteca math.h:
Função Exemplo O que faz Retorno

𝑑𝑜𝑢𝑏𝑙𝑒 𝑐𝑒𝑖𝑙 (𝑑𝑜𝑢𝑏𝑙𝑒 𝑥) 𝑐𝑒𝑖𝑙 (𝑥) Calcula o menor valor inteiro Retorna o menor inteiro maior que 𝑥.
maior que x. Ex: ceil (3.2)
Embora inteiro, o valor é retornado
retorna 4.0 como double.
𝑑𝑜𝑢𝑏𝑙𝑒 𝑓𝑙𝑜𝑜𝑟 (𝑑𝑜𝑢𝑏𝑙𝑒 𝑥) 𝑓𝑙𝑜𝑜𝑟 (𝑥) Calcula o maior valor inteiro Retorna o maior inteiro menor que 𝑥.
menor que x. Ex: floor (3.2) é 3.
Embora inteiro, o valor é retornado
como double.
𝑑𝑜𝑢𝑏𝑙𝑒 𝑐𝑜𝑠 (𝑑𝑜𝑢𝑏𝑙𝑒 𝑥) 𝑐𝑜𝑠 (𝑥) Calcula o cosseno de 𝑥 ( 𝑥 em O cosseno do arco 𝑥, um valor no
radianos). intervalo [-1,+1].
𝑑𝑜𝑢𝑏𝑙𝑒 𝑠𝑖𝑛 (𝑑𝑜𝑢𝑏𝑙𝑒 𝑥) 𝑠𝑖𝑛 (𝑥) Calcula o seno de 𝑥 ( 𝑥 em O seno do arco 𝑥 , um valor no
17
radianos). intervalo [-1,+1].
𝑑𝑜𝑢𝑏𝑙𝑒 𝑡𝑎𝑛 (𝑑𝑜𝑢𝑏𝑙𝑒 𝑥) 𝑡𝑎𝑛 (𝑥) Calcula a tangente de 𝑥 ( 𝑥 em O valor da tangente do arco x como
radianos). um número de dupla precisão
(double).
𝑖𝑛𝑡 𝑎𝑏𝑠 (𝑖𝑛𝑡 𝑥) 𝑎𝑏𝑠(𝑥) Calcula o valor absoluto do O inteiro que representa o valor
argumento 𝑥, onde 𝑥 é um inteiro. absoluto do argumento 𝑥.
𝑑𝑜𝑢𝑏𝑙𝑒𝑓𝑎𝑏𝑠 (𝑑𝑜𝑢𝑏𝑙𝑒 𝑥) 𝑓𝑎𝑏𝑠(𝑥) Calcula o valor absoluto do O double que representa o valor
argumento 𝑥 , onde 𝑥 é um absoluto do argumento 𝑥.
double.
𝑑𝑜𝑢𝑏𝑙𝑒 𝑒𝑥𝑝 (𝑑𝑜𝑢𝑏𝑙𝑒 𝑥) 𝑒𝑥𝑝(𝑥) Obtém o logaritmo natural O valor de 𝑒 𝑥 em precisão dupla.
elevado à potência 𝑥.
𝑑𝑜𝑢𝑏𝑙𝑒 log(𝑑𝑜𝑢𝑏𝑙𝑒 𝑥) 𝑙𝑜𝑔(𝑥) Obtém o logaritmo natural de 𝑥 O valor de log 𝑒 𝑥 em precisão dupla.
(logaritmo neperiano).
𝑑𝑜𝑢𝑏𝑙𝑒 𝑙𝑜𝑔10 (𝑑𝑜𝑢𝑏𝑙𝑒 𝑥) 𝑙𝑜𝑔10(𝑥) Obtém o logaritmo de base 10 de O valor de log10 𝑥 em precisão
𝑥 (logaritmo decimal). O valor de dupla.
𝑥 deve ser positivo. Se
y = log 10 𝑥, então 𝑥 = 10𝑦
𝑑𝑜𝑢𝑏𝑙𝑒 𝑚𝑜𝑑𝑓 𝑚𝑜𝑑𝑓(𝑥, &𝑦) Calcula a parte fracionária de 𝑥 e Retorna o valor da parte fracionária
(𝑑𝑜𝑢𝑏𝑙𝑒 𝑥, 𝑑𝑜𝑢𝑏𝑙𝑒 ∗ 𝑦) coloca a parte inteira em 𝑦. de x em dupla precisão.
𝑑𝑜𝑢𝑏𝑙𝑒 𝑝𝑜𝑤 𝑝𝑜𝑤(𝑥, 𝑦) Calcula a potência 𝑥 . Se 𝑥 ou 𝑦 O valor de 𝑥 𝑦 em dupla precisão.
𝑦
(𝑑𝑜𝑢𝑏𝑙𝑒 𝑥, 𝑑𝑜𝑢𝑏𝑙𝑒 𝑦) for 0, o resultado é 0. Se qualquer

um dos dois for negativo, pode
ocorrer um erro.
𝑑𝑜𝑢𝑏𝑙𝑒 𝑠𝑞𝑟𝑡(𝑑𝑜𝑢𝑏𝑙𝑒 𝑥) 𝑠𝑞𝑟𝑡(𝑥) Calcula a raiz quadrada de 𝑥, isto O valor da raiz quadrada de 𝑥 em
1
é 𝑥 2. dupla precisão (double).
𝑀_𝑃𝐼 𝑀_𝑃𝐼 Constante que define o valor de O valor de 𝜋.

𝑀_𝑃𝐼
18
As funções sin, cos e tan esperam receber argumentos no formato de radianos; para receberem argumentos
em graus, siga o exemplo a seguir:
Exemplo com o valor de 𝜋:

valorPI = 3.1415;
scanf("%d", &x); // x em graus
y = sin ((valorPI * x)/180);
ou usando a função M_PI:

scanf("%d", &x); // x em graus
y = sin((M_PI*x)/180);
Operadores:
Classes de operadores definidas pelo C: aritméticos, relacionais, lógico e bit a bit.
Operadores aritméticos:
Operador Exemplo Comentário

+ x+y Soma o conteúdo de x e de y.
- x–y Subtrai o conteúdo de x e de y.
* x*y Multiplica o conteúdo de x pelo conteúdo de y.
/ x/y Obtém o quociente de divisão de x por y. (y deve ser diferente de 0).
% x%y Obtém o módulo da divisão (resto) de x por y (obs: apenas para números inteiros)
+= x += y Equivale a x = x + y.
-= x -= y Equivale a x = x - y.
*= x *= y Equivale a x = x * y.
/= x /= y Equivale a x = x / y.
%= x %= y Equivale a x = x % y.
++ x++ Incremento. Soma 1 ao seu operando.
Equivale a x = x + 1.
++ y= ++x Usado como prefixo.
Equivale a x = x + 1 e depois y=x.
++ y= x++ Usado como sufixo.
19
Equivale a y = x e depois x=x+1.
-- x-- Decremento. Subtrai 1 do seu operando.
Equivale a x = x - 1.
-- y= --x Usado como prefixo.
Equivale a x = x - 1 e depois y=x.
-- y= x-- Usado como sufixo.
Equivale a y = x e depois x=x-1.
As operações são feitas na precisão dos operandos: o operando com tipo de menor expressividade é
convertido para o tipo do operando com tipo de maior expressividade.
A divisão entre inteiros trunca a parte fracionária. Ex: 5/2 será igual a 2 em uma divisão inteira.
Exemplos dos operadores % e /:
int x, y;
x=5;y=2;
printf("%d", x/y); //mostrará 2.
printf("%d", x%y); //mostrará 1, o resto da divisão inteira.
x=1;y=2;
printf("%d%d", x/y, x%y); /*imprime 0 e 1 porque 1/2 em uma divisão inteira é 0 com resto 1.*/
int a;
double b, c;
a = 3.5; /* a recebe o valor 3 */
b = a / 2.0; /* b recebe o valor 1.5 */
c = 1/3 + b; /* 1/3 retorna 0 pois a operação será sobre inteiros */
/* c recebe o valor de b */
x%2 /* o resultado será 0, se x for par; caso contrário, será 1 */
Exemplo dos operadores ++ e --:

x=10;
y=++x; //coloca 11 em y.
x=10;
y=x++; //coloca 10 em y.
Nos dois casos, x recebe 11. A diferença está em quando isso acontece.
A maioria dos compiladores C produz código-objeto para as operações de incremento e decremento
muito mais rápidas e eficientes comparado ao uso da sentença de atribuição equivalente.
Precedência dos operadores aritméticos:
Mais alta: ++ --
- (menos unário)
*/%
Mais baixa: +-
Operadores do mesmo nível de precedência são avaliados pelo compilador da esquerda para a direita.
Parênteses podem ser usados para alterar a ordem de avaliação, pois forçam uma operação, ou um conjunto de
operações, a ter um nível de precedência maior.
a + b * c / d é equivalente a (a + ((b * c) / d))
Operadores relacionais e lógicos
Operador relacional: relação que os valores podem ter uns com os outros.
20
Operador lógico: maneira como essas relações podem ser conectadas.
A ideia de verdadeiro e falso é a base desses conceitos. Em C, qualquer valor diferente de zero é
verdadeiro. Falso é zero. As expressões que usam operadores relacionais ou lógicos devolvem zero para falso
e 1 para verdadeiro.
Operadores relacionais:
Operador Exemplo Comentário

== x == y IGUAL. O conteúdo de x é igual ao conteúdo de y.
!= x != y DIFERENTE. O conteúdo de x é diferente do conteúdo de y.
<= x <= y MENOR QUE OU IGUAL.
O conteúdo de x é menor ou igual ao conteúdo de y.
>= x >= y MAIOR QUE OU IGUAL.
O conteúdo de x é maior ou igual ao conteúdo de y.
< x<y MENOR QUE. O conteúdo de x é menor que o conteúdo de y.
> x>y MAIOR QUE. O conteúdo de x é maior que o conteúdo de y.
Operadores lógicos:
Operador Comentário
&& AND.
|| OR.
! NOT.
Tabela verdade usando 0s e 1s:
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
Os operadores relacionais e lógicos são menores em precedência em comparação aos operadores

aritméticos. Ou seja, uma expressão 10 > 1+ 12 é avaliada como se fosse escrita como 10 > (1+12) e o
resultado seria falso.
É permitido combinar diversas operações em uma expressão. Exemplo:
10 > 5 && !(10 < 9) || 3 <= 4

Resultado: verdadeiro
Precedência dos operadores relacionais e lógicos:

Maior: !
>>= <<=
== !=
&&
Menor: ||
Parênteses também podem ser usados para alterar a ordem de avaliação de uma expressão relacional
e/ou lógica. Exemplos:
!0 && 0 || 0 é falso
!(0 && 0) || 0 é verdadeiro
21
int a, b;
int c = 23;
int d = c + 4;
a = (c < 20) || (d > c); /* retorna 1 - as duas sub-expressões são avaliadas */
b = (c < 20) && (d > c); /* retorna 0 - apenas a primeira sub-expressão é avaliada */
Lembrar: toda expressão relacional e lógica produz como resultado 0 ou 1.
Exemplo de um fragmento de código para imprimir o número 1 na tela:
int x;
x=100;
printf ("%d", x>10);
Operadores bit a bit:
 Considere duas variáveis inteiras de 8 bits sem sinal:

 A = 0001 0001 (17)
 B = 0110 0011 (99)
Operador Descrição Exemplo Resultado
& AND bit-a-bit A&B 0000 0001 (1)

| OR bit-a-bit A|B 0111 0011 (115)
^ XOR bit-a-bit A^B 0111 0010 (114)
~ complemento de 1 ~A 1110 1110 (238)
desloca N bits à
<< A << 2 0100 0100 (68)
esquerda
Desloca N bits à
>> A >> 2 0000 0100 (4)
direita
Conversão de tipo:
A conversão de tipo é automática na avaliação de uma expressão e pode ser requisitada

explicitamente. Exemplos:
float f = 3;
//O valor 3 é convertido automaticamente para “float” - passa a valer 3.0F, antes de ser atribuído a f
int g, h; //Declara as variáveis g e h do tipo int
g = (int) 3.5; // 3.5 é convertido (e arredondado) para “int” * antes de ser atribuído à variável g
h = (int) 3.5 % 2; // e antes de aplicar o operador módulo “%”
Lista de Exercícios 1
1) Suponha que:
22
𝑎 = 3; 𝑏 = 𝑎 / 2 e 𝑐 = 𝑏 + 3.1.
Qual é o valor de 𝑐? Defina as variáveis 𝑎, 𝑏 e 𝑐 para obter as possíveis respostas:

c=4.6 ou c=4.1 ou c=4.
2) Faça um programa que...
1. receba quatro números, calcule e mostre a soma desses números.
2. receba dois números, calcule e mostre a soma, a divisão, a multiplicação e a subtração desses
números. Por exemplo, para exibir o resultado na forma abaixo (com os números 4 e 3):
Soma: 4+3=7
Divisão: 4/3= 1.33
Multiplicação: 4*3=12
Subtração: 4-3=1
3. receba três notas, calcule e mostre a média aritmética entre elas.
4. receba três notas e seus respectivos pesos, calcule e mostre a média ponderada dessas notas.
5. receba o salário de um funcionário, calcule e mostre o novo salário, sabendo-se que este sofreu um
aumento de 25%.
6. receba o salário de um funcionário e o percentual de aumento, calcule e mostre o valor do aumento e

o novo salário.
7. receba um número positivo e maior que zero, calcule e mostre:

a)o número digitado ao quadrado;
b) o número digitado ao cubo;
c) a raiz quadrada do número digitado;
d) a raiz cúbica do número digitado.
8. receba uma hora formada por hora e minutos (um número real), calcule e mostre a hora digitada
apenas em minutos. Lembre-se de que:
- para quatro e meia, deve-se digitar 4.30;
- os minutos vão de 0 a 59.
9. receba o valor dos catetos de um triângulo, calcule e mostre o valor da hipotenusa.
10. receba o raio, calcule e mostre:

a) o comprimento de uma esfera; sabe-se que 𝐶 = 2 ∗ 𝜋 ∗ 𝑅;
b) a área de uma esfera; sabe-se que 𝐴 = 𝜋 ∗ 𝑅2 ;
4
c) o volume de uma esfera; sabe-se que 𝑉 = 3 ∗ 𝜋 ∗ 𝑅3 .
11. receba uma temperatura em Celsius, calcule e mostre essa temperatura em Fahrenheit. Sabe-se que
𝐹 = 1.8𝐶 + 32.
12. recebe seu nome, endereço, CEP e telefone. Ele deve imprimir seu nome completo na primeira linha,
seu endereço na segunda, e o CEP e telefone na terceira.
13. receba quatro nomes e quatro notas e produza a seguinte saída na tela:
ALUNO(A) NOTA
======= =====
23
MARIA 9.0
JOÃO 7.5
ANTÔNIO 5.6
SILVANA 8.5
Comandos de Controle do Programa
1- Comandos de Seleção
A linguagem C suporta dois tipos de comandos de seleção: if e switch.
Comando if:
Estrutura condicional simples if:
if (condição)
comando;
O comando só será executado se a condição for verdadeira. Uma condição é uma comparação que
possui dois valores possíveis: verdadeiro ou falso.
Exemplo de um trecho de código:
if (media >=7.0)
printf(“Aprovado com media = %f”, media);
if (condição) {
comando1;
comando2;
comando3;
}
if (media >=7.0) {
printf(“Parabens\n”);
}
Em C/C++, torna-se obrigatória a utilização de chaves quando existe mais de um comando a

executar. Os comandos entre chaves {} só serão executados se a condição for verdadeira.
Estrutura condicional compostaif-else:
if (condição)
comando1;
else
comando2;
Se a condição for verdadeira, será executado o comando1; caso contrário, será executado o
comando2.
24
if (media >=7.0)
printf(“Aprovado com média = %f”, media);
else
printf(“Reprovado com média = %f”, media);
Outro exemplo:
if (condição) {
comando1;
comando2;
}
else{
comando3;
comando4;
}
Se a condição for verdadeira, o comando1 e o comando2 serão executados; caso contrário, o

comando3 e o comando4 serão executados.
if (media >=7.0) {
printf(“Parabens\n”);
}
else {
printf(“Tente novamente\n”);
printf(“Reprovado com media = %f”, media);
}
Obs: o comando else sempre se refere ao comando if mais próximo. Exemplo:
if (i) {
if (j) comando_1;
if (j) comando_2; /* este if */
else comando_3; /* está associado a este else */
}
else comando_4; /* associado a if(i) */
25
Estrutura condicional composta if-else-if:
if (expressão1)
comando_1;
elseif (expressão2)
comando_2;
elseif (expressão3)
comando_3;
...
else
comando_n;
As condições são avaliadas de cima para baixo. Assim que uma condição verdadeira é encontrada, o
comando associado a ela é executado e desvia do restante. Caso nenhuma das condições seja verdadeira (se
todos os outros testes condicionais falham), então o último else é executado.
Estrutura switch/case:
Em alguns programas, existem situações mutuamente exclusivas, isto é, se uma situação for
executada, as demais não serão. Neste caso, um comando seletivo é o mais indicado:
switch (variável) {
case valor1:
Sequência de comandos;
break;
case valor2:
Sequência de comandos;
break;
default: //Sequência de comandos;
}
O comando switch (variável) avalia o valor de uma variável para decidir qual case será executado.
Cada case está associado a UM possível valor da variável, que deve ser, obrigatoriamente, do tipo char,
unsigned char, int, unsigned int, short int, long ou unsigned long. É frequentemente usado para processar
uma entrada, via teclado, como em uma seleção por menu.
26
O comando break deve ser utilizado para impedir a execução dos comandos definidos nos cases
subsequentes. Quando o valor da variável não coincidir com aqueles especificados nos cases, será executado
então o default.
Exemplo:
#include <stdio.h>
#include <conio.h>
int main() {
int i;
clrscr();
printf("Digite um número: ");
scanf("%d", &i);
switch(i) {
case 1: printf("Número 1");
break;
case 2: printf("Número 2");
break;
default: printf("Número diferente de 1 e 2");
}
getch();
return 0;
}
Obs: O comando switch difere do comando if porque switch só pode testar igualdade, enquanto if
pode avaliar uma expressão lógica ou relacional.
Duas constantes case no mesmo switch não podem ter valores idênticos.
A função menu() abaixo mostra o menu de um programa de validação de ortografia e chama os
procedimentos apropriados.
27
Faça um programa que...
1) receba dois números e mostre o maior.
2) receba três números e mostre-os em ordem crescente. Suponha que o usuário digitará três números
diferentes.
3) receba um número inteiro e verifique se é par ou ímpar.
4) mostre o menu de opções a seguir, receba a opção do usuário e os dados necessários para executar cada
operação.
Menu de opções:
1- Soma de dois números

2- Raiz quadrada de um número
3- Divisão de dois números.
Digite a opção desejada.
Exibir uma mensagem caso o número seja diferente das opções apresentadas. Na opção 2, lembrar
que o número não pode ser negativo. Na opção 3, lembrar que o denominador deve ser diferente de zero.
5) receba quatro notas de um aluno, calcule e mostre a média aritmética das notas e a mensagem de aprovado
ou reprovado, considerando para aprovação média 7.0.
6) receba duas notas, calcule e mostre a média aritmética e a mensagem a seguir:
7) A nota final de um estudante é calculada a partir de três notas atribuídas, respectivamente, a um trabalho de
laboratório, a uma avaliação semestral e a um exame final. A média das três notas mencionadas obedece aos
pesos a seguir:
NOTA PESO
Trabalho de laboratório 2
Avaliação semestral 3
Exame final 5
Faça um programa que receba as três notas, calcule e mostre a média ponderada e o conceito que segue a
tabela:
8) receba o código correspondente ao cargo de um funcionário e seu salário atual e mostre o cargo, o valor do
aumento e seu novo salário. Os cargos estão na tabela abaixo:
28
Código Cargo Percentual
1 Escriturário 50%
2 Secretário 35%
3 Caixa 20%
4 Gerente 10%
5 Diretor Não tem aumento
9) resolva equações do 2º Grau.
10) Dados três valores X, Y e Z, verifique se eles podem ser os comprimentos dos lados de um triângulo e, se
forem, verifique se é um triângulo equilátero, isósceles ou escaleno. Se eles não formarem um triângulo,
escreva uma mensagem. Considere que:
- O comprimento de cada lado de um triângulo é menor do que a soma dos outros dois lados.
- Chama-se equilátero o triângulo que tem três lados iguais.
- Denomina-se isósceles, o triângulo que tem o comprimento de dois lados iguais.
- Recebe o nome de escaleno o triângulo que tem os três lados diferentes.
11) receba a altura e o peso de uma pessoa. De acordo com a tabela a seguir, verifique e mostre a
classificação dessa pessoa.
12) calcule a quantidade de litros de combustível gasta em uma viagem, utilizando-se um automóvel que faz
12 km por litro. Para obter o cálculo, o usuário deverá fornecer o tempo gasto na viagem em horas e a
velocidade média durante a mesma. Desta forma, será possível obter a distância percorrida com a fórmula:
DISTANCIA = TEMPO * VELOCIDADE.
Tendo o valor da distância, basta calcular a quantidade de litros de combustível utilizada na viagem com a
fórmula: LITROS_USADOS = DISTANCIA / 12. O programa deverá apresentar os valores da velocidade
média, tempo gasto na viagem, a distância percorrida e a quantidade de litros utilizada na viagem.
2- Comandos de Iteração
Também chamados de laços, permitem que um conjunto de instruções seja executado até que ocorra
uma certa condição. Esta condição pode ser pré-definida (como no laço for) ou com o final em aberto (como
nos laços while e do-while).
2.1- O laço for
29
Forma geral: for (inicialização; condição; incremento) comando;
Permite muitas variações.

A inicialização é, geralmente, um comando de atribuição que é usado para colocar um valor na
variável de controle do laço.
A condição é uma expressão relacional que determina quando o laço acaba.
O incremento define como a variável de controle do laço varia cada vez que o laço é repetido.
As três seções principais devem ser separadas por pontos-e-vírgulas (;).
Uma vez que a condição se torne falsa, a execução do programa continua no comando seguinte ao for.
Por exemplo: o programa a seguir imprime os números de 1 a 100 na tela:
Neste programa, x é inicialmente ajustado para 1. Como x é menor que 100, printf() é executado e x
é incrementado em 1 e testado para ver se ainda é menor ou igual a 100. Este processo se repete até que x
fique maior que 100; nesse ponto, o laço termina. Neste exemplo, x é a variável de controle do laço, que é
alterada e testada toda vez que o laço se repete.
Exemplo de um laço for com múltiplos comandos:
Tanto a multiplicação de x por si mesmo como a função printf() são executadas até que x seja igual a
65. Neste caso o laço é executado de forma inversa: x é inicializado com 100 e será subtraído de 5 cada vez
que o laço se repetir.
Nos laços for,o teste condicional sempre é executado no topo do laço, ou seja, o código dentro do laço
pode não ser executado se todas as condições forem falsas logo no início.Por exemplo, em:
o laço nunca executará, pois x e y já são iguais desde a sua entrada. Já que a expressão condicional é avaliada
como falsa, nem o corpo do laço nem a porção de incremento do laço são executados. Logo, y ainda tem o
valor 10 e a saída é o número 10 escrito apenas uma vez na tela.
30
Exemplo de execução:
2.2- O laço while
Forma geral: while (condição) comando;
onde comando é um comando vazio, um comando simples ou um bloco de comandos.

A condição pode ser qualquer expressão, e verdadeiro é qualquer valor não-zero. O laço se repete
enquanto a condição for verdadeira. Quando a condição for falsa, o controle do programa passa para a linha
após o código do laço. Para quando tivermos um conjunto de instruções, usamos as { }.
Exercício: reescrever os códigos acima escritos com o laço for usando o laço while.
31
O exemplo seguinte mostra uma rotina de entrada pelo teclado que se repete até que o usuário digite a
letra A.
Primeiro, ch é inicializado com nulo. O laço while verifica se ch não é igual a A. Como ch foi
inicializado com nulo, o teste é verdadeiro e o laço começa. Cada vez que o usuário pressiona uma tecla, o
teste é executado novamente. Uma vez digitado A, a condição se torna falsa, porque ch fica igual a A, e o
laço termina.
Assim como os laços for, os laços while verificam a condição de teste no início do laço, o que
significa que o código do laço pode não ser executado. Isso elimina a necessidade de se efetuar um teste
condicional antes do laço. Exemplos:
/*Exibir os inteiros de 0 a 9 */
/* Calcular a media de n números */
2.3- O laço do-while
Ao contrário dos laços for e while, que testam a condição do laço no começo, o laço do-while verifica
a condição ao final do laço. Isso significa que um laço do-while sempre será executado ao menos uma vez.
32
Forma geral:
Embora as chaves não sejam necessárias quando apenas um comando está presente, elas são
geralmente usadas para evitar confusão com o while. O laço do-while repete até que a condição se torne
falsa.
Exemplo:
/* Exibir os inteiros de 0 a 9 */
#include <stdio.h>
int main() {
int digito=0;
do {
printf("%d\n", digito++);
} while (digito <= 9);
return 0;
}
O seguinte laço do-while lerá números do teclado até que se encontre um número menor ou igual a
100.
Um uso comum do laço do-while é em uma rotina de seleção por menu. Quando o usuário entra com
uma resposta válida, ela é retornada como o valor da função. Respostas inválidas provocam um repetição do
laço. Exemplo:
33
Aqui, o laço do-while foi uma boa escolha, porque você sempre deseja que uma função do menu seja
executada ao menos uma vez. Depois que as opções forem mostradas, o programa será executado até que
uma opção válida seja selecionada.
/* Calcular a média de n numeros */

#include <stdio.h>
int main()
{
int n, cont = 1; //cont: variável usada como um contador
float x, media, soma=0;
/*ler o valor de n */
printf("Quantos numeros? ");
scanf("%d", &n);
/*ler os numeros */
do {
printf("x = ");
scanf("%f", &x);
soma += x; //soma: variável usada como um acumulador
++ cont;
} while (cont<= n);
/*Calcular a media e imprimir a resposta */

media = soma/n;
printf("\nAmedia = %f\n", media);
return 0;
}
3- Comandos de desvio
3.1 - O comando return
Usado para retornar de uma função. Ele é um comando de desvio porque faz com que a execução
retorne (salte de volta) ao ponto em que a chamada à função foi feita. Se return tem um valor associado a ele,
esse valor é o valor de retorno da função.
Forma geral: return expressão;
Podem ser usados vários comandos return dentro de uma função. Contudo, a função parará de
executar quando encontrar o primeiro return.
Uma função declarada como void não pode ter um comando return que especifique um valor.
3.2 - O comando break
Pode ser usado para terminar um case em um comando switch ou para forçar uma terminação
imediata de um laço, evitando o teste condicional normal do laço.
34
Quando o comando break é encontrado dentro de um laço, o laço é imediatamente terminado e o
controle do programa retorna no comando seguinte ao laço. Exemplo:
Escreve os números de 0 até 10 na tela. O laço termina porque o break provoca uma saída imediata
do laço, não respeitando o teste condicional t<100.
Um comando break provoca uma saída apenas do laço mais interno. Exemplo:
Escreve os números de 1 até 10 na tela 100 vezes. Cada vez que o compilador encontra break,
transfere o controle de volta para a repetição for mais externa.
Um break usado em um comando switch somente afetará esse switch. Ele não afeta qualquer
repetição que contenha o switch.
3.3 - O comando continue
Trabalha de forma semelhante ao break. Em vez de forçar a terminação, porém, continue força que
ocorra a próxima iteração do laço, pulando qualquer código intermediário. Para o laço for, continue faz com
que o teste condicional e a porção de incremento do laço sejam executados. Para os laços while e do-while, o
controle do programa passa para o teste condicional. Exemplo:
/* Calcular a media dos números nao-negativos de uma lista de numeros */
#include <stdio.h>
int main() {
int n, cont, nmedia=0;
float x, media, soma=0;
/*ler o valor de n */
printf("Quantos numeros? ");
scanf("%d", &n);
/*ler os numeros */
for (cont=1 ;cont<= n ; ++cont) {
printf("x = ");
scanf("%f", &x);
if (x < 0) continue;
soma += x;
++nmedia;
}
/*Calcular a media e imprimir a resposta */
media = soma/nmedia;
35
printf("\nAmedia = %f\n", media);
return 0;
}
Quando o programa é executado com valores não-negativos de x, ele se comporta exatamente com a
versão anterior apresentada. Quando são atribuídos valores negativos a alguns dos x, eles são ignorados no
cálculo da média.
Exemplo de execução do programa acima:
Quantos números? 6
x=1.0
x=-10.4
x=2.0
x=-12.8
x=3.0
x=-43
A media = 2.000000
Essa é a média correta dos números positivos.
1) monte os N primeiros termos da sequência de Fibonacci:
0-1-1-2-3-5-8-13-21-34-55.....
2) receba duas notas de seis alunos, calcule e mostre:
A média aritmética das duas notas de cada aluno;
A mensagem que está na tabela a seguir, de acordo com a média calculada anteriormente:
Média Aritmética Mensagem

De 0 a 3 Reprovado
Entre 4 e 7 Exame
De 7 a 10 Aprovado
O total de alunos aprovados;

O total de alunos de exame;
O total de alunos reprovados;
A média da classe.
Obs: validar todas as notas, ou seja, apenas valores de 0 a 10.0 podem ser aceitos.
3) receba um número inteiro maior que 1, verifique se o número fornecido é primo ou não e mostre mensagem
de número primo ou de número não primo. Um número é primo quando é divisível apenas por 1 e por ele
mesmo.
4) receba um número, calcule e mostre a tabuada desse número.
5) mostre as tabuadas dos números de 1 a 10.
36
6) Faça um programa para calcular a área de um triângulo, que não permita a entrada de dados inválidos, ou
seja, medidas menores ou iguais a 0.
7)Uma loja utiliza o código V para transação à vista e P para transação a prazo. Faça um programa que receba
o código e o valor de quinze transações, calcule e mostre:
O valor total das compras à vista;
O valor total das compras a prazo;
O valor total das compras efetuadas;
8) receba a idade, a altura e o peso de 25 pessoas, calcule e mostre:

A quantidade de pessoas com idade superior a 50 anos;
A média das alturas das pessoas com idade entre 10 e 20 anos;
A percentagem de pessoas com peso inferior a 40 quilos entre todas as pessoas analisadas.
9) receba a idade, o peso, a altura, a cor dos olhos (A-azul, P-preto, V-verde, C-castanho) e a cor dos cabelos
(P-preto, C-castanho, L-louro e R-ruivo) de vinte pessoas, e que calcule e mostre:
A quantidade de pessoas com idade superior a 50 anos e peso inferior a 60 quilos;
A média das idades das pessoas com altura inferior a 1,50 metros;
A percentagem de pessoas com olhos azuis entre todas as pessoas analisadas;
A quantidade de pessoas ruivas e que não possuem olhos azuis.
10) receba 10 números, calcule e mostre a soma dos números pares e dos números primos.
11) receba 10 números inteiros positivos e mostre a quantidade de números primos dentre os números que
foram digitados.
12) Cada espectador de um cinema responde a um questionário no qual constava sua idade e sua opinião em
relação ao filme: 3-ótimo, 2-bom, 1-regular. Faça um programa que receba a idade e a opinião de 15
espectadores, calcule e mostre:
A média das idades das pessoas que respondeu ótimo;
A quantidade de pessoas que respondeu regular;
A percentagem de pessoas que respondeu bom, entre todos os espectadores analisados.
13) receba 20 números inteiros positivos e mostre uma tabela contendo o valor lido e o fatorial desse valor, na
forma:
Número fatorial
------------------------------
2 2
5 120
... .
Vetor
Definição: variável composta homogênea unidimensional – conjunto de variáveis de mesmotipo, que

possuem o mesmo identificador (nome) e são alocadas sequencialmente na memória. Como as variáveis têm
o mesmo nome, o que as distingue é um índice que referencia sua localização dentro da estrutura.
Em C, os índices utilizados para identificar as posições de um vetor começam sempre em 0 (zero) e
vão até o tamanho do vetor menos uma unidade.
Declaração:
Os vetores são identificados pela existência de colchetes logo após o nome da variável no momento da
declaração. Dentro dos colchetes deve-se colocar o número de posições do vetor.
37
Exemplos:
1) O vetor chamado vet possui dez posições, começando pela posição 0 e indo até a posição 9
(tamanho do vetor -1). Em cada posição poderão ser armazenados números inteiros, conforme
especificado pelo tipo int na declaração.
2) O vetor chamado x possui cinco posições, começando pela posição 0 e indo até a posição 4 (tamanho
do vetor -1). Em cada posição poderão ser armazenados caracteres, conforme especificado pelo tipo
char na declaração.
OBS: em C/C++ não existe o tipo de dados string, como ocorre na linguagem Pascal. Dessa forma,
para poder armazenar em uma cadeia de caracteres, por exemplo, o nome completo de uma pessoa, deve-se
declarar um vetor de char, em que cada posição equivale a um caractere ou a uma letra do nome. Toda vez
que se faz uso de um vetor para armazenar uma cadeia de caracteres, deve-se definir uma posição a
mais que a necessária para armazenar a marca de finalização de cadeia (\0).
Atribuição de valores ao vetor:
É necessário informar em qual de suas posições o valor ficará armazenado.

Lembrando-se sempre que a primeira posição de um vetor em C/C++ tem índice 0.
vet[0]=1; atribui o valor 1 à primeira posição do vetor.

x[3]='b'; atribui a letra b à quarta posição do vetor.
Preenchimento de um vetor:
Significa atribuir valores a todas as suas posições. Assim, deve-se implementar um mecanismo que
controle o valor do índice.Exemplo:
for (i=0; i<10; i++){

printf(“\n Entre com o elemento %d do vetor:”, i);
scanf(“%d”, &vetor[i]);
}
A estrutura de repetição for foi utilizada para garantir que a variável i assuma todos os valores
possíveis para o índice do vetor (de 0 a 9). Assim, para cada execução da repetição, será utilizada uma
posição diferente do vetor.
Mostrar os elementos do vetor:
Também exige a utilização do índice.Exemplo:

for (i=0; i<10; i++) {
38
printf(“\n vetor[%d]=%d”, i, vetor[i]);
}
A estrutura de repetição for foi utilizada para garantir que a variável i assuma todos os valores
possíveis para o índice do vetor (de 0 a 9). Assim, para cada execução da repetição, será utilizada uma
posição diferente e, dessa forma, todos os valores do vetor serão mostrados.
Exemplo: Faça um programa que preencha um vetor com 10 números inteiros, calcule e mostre os números
primos e as suas respectivas posições.
#include <stdio.h>
#define TAMANHO 10
intmain ()
{
intvet[TAMANHO], cont, i, var;
// Entrar com os valores dos vetores
for (i=0; i<TAMANHO; i++) {
printf(“\nEntre com o valor da posicao %d: ”, i);
scanf(“%d”, &vet[i]);
}
//Varrer todo o vetor e verificar qual desses valores são primos e indicar as posições:
cont=0;
//Verificação dos números primos:
for (var=1; var<=vet[i]; var++) {
if (vet[i]%var==0)
cont ++;
}
if (cont==2){
printf(“\n O número %d é primo e encontra-se na posicao %d do vetor”,
vet[i], i);
}
}
return 0;
}
1) preencha um vetor com nove números inteiros, calcule e mostre os números primos e suas respectivas
posições.
39
2) preeencha dois vetores de dez elementos numéricos cada um e mostre o vetor resultante da intercalação
deles.
3) preencha um vetor com oito números inteiros, calcule e mostre dois vetores resultantes. O primeiro
vetor resultante deve conter os números positivos; segundo deve conter os números negativos. Cada
vetor resultante vai ter, no máximo, oito posições, que poderão não ser completamente utilizadas.
40
4) preencha dois vetores, X e Y, com dez números cada. Calcule e mostre os seguintes vetores
resultantes:
a) A soma entre X e Y. (Soma de cada elemento de X com o elemento de mesma posição em Y).
b) O produto entre X e Y. (Multiplicação de cada elemento de X com o elemento de mesma posição
em Y).
5) preencha um vetor com dez números inteiros, calcule e mostre o vetor resultante de uma ordenação
decrescente.
6) preencha um vetor com dez números inteiros, calcule e mostre os números superiores a cinquenta e
suas respectivas posições. O programa deverá mostrar mensagem se não existir nenhum número nesta
condição.
41
7) receba seis números inteiros e mostre:
- os números pares digitados;
- a soma dos números pares digitados;
- os números ímpares digitados;
- a quantidade de números ímpares digitados.
8) leia um vetor com cinco posições para números reais e, depois, um código inteiro. Se o código for
zero, finalize o programa; se for 1, mostre o vetor na ordem direta; se for 2, mostre o vetor na ordem
inversa.
9) gere os dez primeiros números primos acima de 100 e armazene-os em um vetor. Escreva no final o
vetor resultante.
10) preencha um vetor com dez números reais, calcule e mostre a quantidade de números negativos e a
soma dos números positivos desse vetor.
11) receba dez números inteiros e armazene-os em um vetor, calcule e mostre dois vetores resultantes: o
primeiro com os números pares e o segundo com os números ímpares.
12) receba cinco números e mostre a saída como no exemplo a seguir:
42
13) preencha um vetor com quinze números, determine e mostre:
- o Maior número e a posição por ele ocupada no vetor;
- o Menor número e a posição por ele ocupada no vetor;
14) leia um vetor com quinze posições para números inteiros. Depois da leitura, divida todos os seus
elementos pelo maior valor do vetor.
Matriz
Definição: Variável composta homogênea multidimensional. Ela é formada por uma sequência de variáveis,
todas do mesmo tipo, com o mesmo identificador (mesmo nome), e alocadas sequencialmente na memória.
Como as variáveis têm o mesmo nome, o que as distingue são índices que referenciam sua localização dentro
da estrutura. Uma variável do tipo matriz precisa de um índice para cada uma de suas dimensões.
A linguagem C/C++ permite a declaração de matrizes unidimensionais (vetores), bidimensionais e
multidimensionais.
Declaração:
Tipo_dos_dados nome_variável [dimensão 1] [dimensão 2] [...] [dimensãoN];
onde
tipo_dos_dados é o tipo de dados que serão armazenados na matriz;
nome_variável é o nome dado à variável do tipo matriz;
[dimensão1] representa o tamanho da 1ª dimensão da matriz;
[dimensão2] representa o tamanho da 2ª dimensão da matriz;
[dimensãoN] representa o tamanho da n-ésima dimensão da matriz;
Exemplos de matrizes bidimensionais:
floatX[2][6];
Com esta declaração, a variável X contém duas linhas (0 e 1) com seis colunas cada (0 e 5), capazes de
armazenar números reais.
43
char MAT[4][3];
Esta declaração cria uma variável chamada MATcontendo quatro linhas (0 a 3) com três colunas cada (0 a 2),
capazes de armazenar símbolos.
Atribuição de valores a uma matriz:

Significa armazenar informação em um de seus elementos, identificado de forma única por meio de seus
índices.
X[1][4]=5; //Atribui o valor 5 à posição indicada pelos índices 1 (2ª linha) e 4 (5ª coluna)
MAT [3][2]=’D’ // Atribui a letra D à posição identificada pelos índices 3 (4ª linha) e 2 (3ª coluna)
Preenchimento de uma matriz:

Significa percorrer todos os seus elementos, atribuindo-lhes um valor. Este valor pode ser recebido do
usuário, por meio do teclado, ou pode ser gerado pelo programa. Exemplo:
for (i=0; i<4; i++)

{
for (j=0; j<3; j++)
scanf(“%c”, &MAT[i][j]);
}
Mostrando os elementos de uma matriz:

Significa percorrer todos os elementos de uma matriz acessando o seu conteúdo. Exemplo:
for (i=0; i<4; i++)

{
for (j=0; j<3; j++)
44
printf(“%c”, MAT[i][j]);
}
Como a matriz possuiquatro linhas e três colunas, o forexterno deve variar de 0 a 3 (percorrendo,
assim, as quatro linhas da matriz) e o for interno de 0 a 2 (percorrendo, assim, as três colunas da matriz).
Exemplo anterior completo, com mensagem na entrada e mostrando os dados no formato de matriz no
resultado:
#include <stdio.h>
intmain() {
char MAT[4][3]; inti,j;
for (i=0; i<4; i++) {
for (j=0; j<3; j++) {
printf("\n Entre com a informação na linha %d e coluna %d: ", i, j);
scanf(" %c", &MAT[i][j]);
}
}
for (i=0; i<4; i++) {
for (j=0; j<3; j++)
printf("%c\t", MAT[i][j]);
printf("\n");
}
return 0;
}
Lista de exercícios 5
1- Faça um programa que preencha uma matriz M (2x2), calcule e mostre a matriz R, resultante da
multiplicação dos elementos de M pelo seu maior elemento.
2- Crie um programa que preencha uma matriz 3x4 com números inteiros e some cada uma das linhas,
armazenando o resultado em um vetor. Apresentar o vetor resultante.
3- Faça um programa que preencha uma matriz 3x5 com números inteiros, calcule e mostre a quantidade
de elementos entre 15 e 20 (inclusive). E também calcule a mostre a média dos elementos pares da
matriz.
4- Elabore um programa que preencha uma matriz 6X3 de números reais, calcule e mostre:
a. O maior elemento da matriz e sua respectiva posição, ou seja, linha e coluna;
b. O menor elemento da matriz e sua respectiva posição, ou seja, linha e coluna.
5- Faça um programa que preencha e mostre a média dos elementos da diagonal principal de uma matriz
10x10.
45
Funções:
Estruturação de um programa em sub-rotinas.
Sub-rotinas – subprograma – programação modularizada

Definição: as sub-rotinas são blocos de instruções que realizam tarefas específicas.
O código de um subprograma é carregado uma vez e executado várias vezes. O problema pode ser
dividido em pequenas tarefas, com isso os programas tendem a ficar menores e mais organizados.
Os programas em geral são executados linearmente, uma linha após a outra, até o fim. Em geral,
quando usamos sub-rotinas, é possível realizar desvios na execução dos programas. Estes desvios são
efetuados quando uma função e chamada pelo programa principal.
Modularização: recurso das linguagens de programação – particionar um programa em sub-rotinas bastante

específicas.
Variáveis locais: variáveis declaradas dentro das sub-rotinas. Quando a execução desta chega ao fim, essas
variáveis são destruídas e seus conteúdos são perdidos.
Variáveis globais: variáveis declaradas fora de qualquer sub-rotina. Qualquer ponto do programa, incluindo
as sub-rotinas, pode utilizá-las. Elas são destruídas quando a execução do programa chega ao fim.
Obs: não é aconselhável a utilização excessiva de variáveis globais, pois torna difícil a manutenção e a busca
por erros nos programas.
Sub-rotinas em C (funções):
Um programa escrito na linguagem C tem, no mínimo, uma função chamada main, que indica o início
da execução. Existe uma série de outras funções predefinidas, por exemplo: clrscr(), gets(), strcpy(), printf(),
scanf(), pow(), etc. Estas funções são adicionadas aos programas pela diretiva #include, no momento da
“linkedição”.
O usuário pode criar quantas funções quiser, dependendo do problema que estiver sendo resolvido
pelo programa.
As funções podem, quando houver necessidade, receber valores externos, chamados parâmetros, e
também podem devolver algum valor produzido para o ambiente externo, denominado retorno.
Os parâmetros são representados por uma lista de variáveis colocadas dentro de parênteses, logo
após o nome da função.
Caso haja retorno, a última linha da função deverá incluir o comando return, seguido do valor ou
variável que será devolvido a quem chamou a função. O tipo do valor retornado deverá ser exatamente igual
ao tipo informado antes do nome da função. A palavra void deverá ser digitada caso a função não retorne
valor.
Tipos de funções:
1- Funções sem passagem de parâmetro e sem retorno
Tipo mais simples de função, pois não recebe nenhuma informação no momento de sua chamada e
também não repassa nenhum valor para quem a chamou.
Exemplo: Função que leia dois números e execute a soma entre eles.
1 #include <stdio.h>
2 #include <conio.h>
3 voidsoma()
4 {
5 int num1, num2, soma;
6 printf(“\n Digite o primeiro numero:”);
7 scanf(“%d”, &num1);
46
8 printf(“\n Digite o segundo numero:”);
10 soma = num1 + num2;
11 printf(“\n Soma=%d”, soma);
12 getch();
13 }
14 voidmain()
15 {
16 soma();
17 }
Explicação do programa:
- A execução sempre começa pela função main. A execução se inicia na linha 14.
- Na linha 16, existe uma chamada à função soma, onde o fluxo da execução é desviado para a linha 3.
Depois são executadas as linhas 4 até a 12. Quando a execução atinge a linha 13, a marca de final da função é
encontrada. Neste momento, o fluxo da execução retorna para a linha 17, exatamente abaixo de onde ocorreu
o desvio para a função soma.
- Na linha 17 está a marca de finalização da função main, e o programa é concluído.
Obs.1: no momento em que a função soma foi chamada, na linha 16, nenhum valor ou variável foi
colocado entre parênteses, indicando que não houve passagem de parâmetros.
Obs.2: dentro da função soma não foi utilizado o comando return, indicando que ela não retornou
nenhum valor para quem a chamou, logo, o seu tipo é void.
Exemplo: Faça uma sub-rotina que leia cinco valores inteiros, determine e mostre o maior e o menor
deles.
#include <stdio.h>
#define TAMANHO 5
void verifica (){
intvet[TAMANHO], maior, menor, i;
//Entrar com os valores do vetor:
scanf(“%d”, &vet[i]);
}
maior = vet[0];
menor= vet[0];
if (vet[i]>maior ) maior=vet[i];
if (vet[i]<menor ) menor=vet[i];
}
printf(“\n Maior valor do vetor: %d”, maior);
printf(“\n Menor valor do vetor: %d”, menor);
}
intmain()
{
verifica();
return 0;
}
2- Funções com passagem de parâmetro e sem retorno
47
Tipo de função representado por aquelas que recebem valores no momento em que são chamadas
(parâmetros), mas que, no final, não devolvem valor para quem a chamou (retorno).
Exemplo: Função que recebe dois valores e calcula a média entre eles.
3 voidcalcula_media(int numero1, int numero2)

4 {
5 float media;
6 media = (numero1 + numero2) / 2.0;
7 printf(“\n Media=%f”, media);
8 getch();
9 }
10 voidmain()
11 {
12 int num1, num2;
13 printf(“\n Digite o primeiro numero:”);
15 printf(“\n Digite o segundo numero:”);
17 calcula_media(num1, num2);
18 }
- A execução do programa começa na linha 10 (função main). Em seguida, são executadas

sequencialmente as linhas 12 a 17.
- Nas linhas 14 e 16, dois valores são recebidos e armazenados nas variáveis num1 e num2. Serão
executadas então as linhas 3 a 9, onde está a marca de encerramento da função.
- O fluxo de execução retorna à função main, na linha 18, imediatamente abaixo do ponto de chamada da
função calcula_media. A execução do programa é concluída.
- Obs.1: no momento em que a função calcula_media foi chamada, na linha 17, duas variáveis foram
colocadas entre parênteses, indicando que houve passagem de parâmetros. Os valores delas são copiados para
as variáveis numero1 e numero2, conforme descrito no cabeçalho da função, na linha 3.
- Obs.2: na função calcula_media, não foi utilizado o comando return, indicando que ela não retornou
valor para quem a chamou. Logo, seu tipo foi definido como void.
3- Funções sem passagem de parâmetro e com retorno
Tipo de função representado por aquelas que não recebem valores no momento em que são chamadas
(parâmetros), mas que, no final, devolvem um valor para quem as chamou (retorno).
Exemplo: Função que leia dois valores e retorne o resultado da multiplicação ao programa principal.
3 floatmultiplicacao ()
4 {
5 float multiplicando, multiplicador, produto;
6 printf(“\n Digite o valor do multiplicando:”);
7 scanf(“%f”, &multiplicando);
48
8 printf(“\n Digite o valor do multiplicador:”);
9 scanf(“%f”, &multiplicador);
10 produto = multiplicando * multiplicador;
11 return produto;
12 }
13 intmain ()
14 {
15 float resposta;
16 resposta = multiplicacao ();
17 printf(“\n O produto = %f”, resposta);
18 getch();
19 return 0;
20 }
- A execução do programa começa na linha 13 (função main).

- Na linha 16, o fluxo de execução é desviado para a função multiplicacao(na linha 3). As linhas 3 a 12
são executadas. Ao chegar à linha 11, o comando return é encontrado. Isto significa que a execução da
função chegou ao fim e que o conteúdo da variável produto será devolvido para quem a chamou.
- O fluxo de execução retorna à função main, na linha 16. O valor retornado é atribuído à variável
resposta. As linhas 17, 18 e 19 são executadas e o programa encerrado.
Obs.1: no momento em que a função multiplicacao foi chamada, na linha 16, nenhum valor ou variável
foi colocada entre parênteses, o que indica que não houve passagem de parâmetros.
Obs.2: na função multiplicacao foi utilizado o comando return produto, o que significa que o valor da
variável produto foi devolvido a quem a chamou. Logo, o tipo da função é float, exatamente igual ao tipo do
valor retornado.
4- Funções com passagem de parâmetro e com retorno
Tipo de função representado por aquelas que recebem valores no momento em que são chamadas
(parâmetros) e que, no final, devolvem um valor para quem a chamou (retorno).
Exemplo: Função que recebe dois valores e retorna a divisão entre eles.
3 floatdivisao (float dividendo, float divisor)
4 {
5 float q;
6 q = dividendo / divisor;
7 return q;
8 }
9 voidmain ()
10 {
11 float n1, n2, resposta;
12 printf(“\n Digite o valor do dividendo ”);
13 scanf(“%f”, &n1);
14 do {
15 printf(“\n Digite o valor do divisor ”);
16 scanf(“%f”, &n2);
17 } while (n2==0);
49
18 resposta = divisao(n1, n2);
19 printf(“\n O resultado da divisao = %f”, resposta);
20 getch();
21 }
- A execução do programa começa na linha 9 (função main).
- As linhas 11 a 17 são executadas sequencialmente. Nas linhas 13 e 16 dois valores são recebidos e
armazenados nas variáveis n1 e n2, respectivamente. Nas linhas 14 a 17 é utilizada uma estrutura de repetição
do-while para validar a variável n2 que não pode assumir valor zero.
- Na linha 18, o fluxo de execução é desviado para a função divisao, com os valores das variáveis n1 e n2.
As linhas 3 a 6 são executadas. Na linha 7, o comando return é encontrado e a execução da função divisao
termina. O conteúdo da variável q será devolvido para quem a chamou.
- Na linha 18, o fluxo da execução retorna à função main e o valor retornado é atribuído à variável
resposta. As linhas 19, 20 e 21 são executadas e o programa encerrado.
Obs.1: quando a função divisao foi chamada na linha 18, duas variáveis foram colocadas entre parênteses,
indicando que houve passagem de parâmetros. Assim, os valores destas variáveis são copiados,
respectivamente, para as variáveis dividendo e divisor, descritas no cabeçalho da função, na linha 3.
Obs.2: na função divisao foi utilizado o comando return q, indicando que o valor da variável q será
devolvido a quem a chamou. Portanto, o tipo da função é exatamente igual ao valor retornado.
Protótipo de função:
Em qualquer programa, podemos escrever funções antes ou depois da função main. Caso as funções
sejam escritas abaixo da função main, devemos fazer uso dos protótipos de função.
Definição: protótipo de função é uma linha exatamente igual ao cabeçalho da função (terminando com um
ponto e vírgula) que sempre deverá ser escrita antes da função main. Essa linha é responsável por informar
ao compilador quais outras funções serão encontradas ao término da função main.
floatdivisao (float dividendo, float divisor); //Esta linha descreve o protótipo da função.
Passagem de parâmetros por valor:
Significa que a função trabalhará com cópia dos valores passados no momento de sua chamada.
Exemplo:
2 #include<conio.h>
3 intsoma_dobro (inta, int b);
4 voidmain()
5 {
6 int x, y, res;
7 printf(“\nDigite o primeiro numero:”);
8 scanf(“%d”, &x);
9 printf(“\nDigite o segundo numero:”);
10 scanf(“%d”, &y);
11 res = soma_dobro(x, y);
12 printf(“\n A soma do dobro dos números %d e %d = %d”, x, y, res);
13 getch();
50
14 }
15 intsoma_dobro(int a, int b)
16 {
17 int soma;
18 a =2*a;
19 b=2*b;
20 soma = a+b;
21 return soma;
22 }
Representação gráfica:
- Supor que os valores armazenados nas variáveis x e y, pela execução das linhas 8 e 10, sejam,
respectivamente, 5 e 3.
- Quando a linha 11 é executada, esses valores são copiados para as variáveis a e b (pertencentes a
função soma_dobro).
- Nas linhas 18 e 19 os valores de a e b são multiplicados por 2.Na linha 20 é feita a soma.O resultado
dessa soma é devolvido à função main pela execução da linha 21, onde o valor calculado recai sobre a
variável res (retorno à linha 11).
- Quando a função soma_dobro chega ao fim, as variáveis a, b e soma são destruídas e, portanto, as
alterações realizadas pelas multiplicações por 2 são perdidas, ou seja, x continua valendo 5 e y continua
valendo 3.
51
Ponteiros
Um ponteiro é um endereço de memória. Seu valor indica onde uma variável está armazenada,
NÃO o que está armazenado. Proporciona um modo de acesso a uma variável sem referenciá-la diretamente.
São variáveis auxiliares que nos permitem acessar os valores de outras variáveis indiretamente. Assim como
todas as variáveis, também possuem dois atributos: um conteúdo e uma localização. Esta localização
pode ser armazenada em outra variável, o que torna então um ponteiro para um ponteiro.
Os ponteiros são usados para:

1- Manipular elementos de matrizes;
2- Receber argumentos em funções que necessitem modificar o argumento original;
3- Passar strings de uma função para outra;
4- Usá-los no lugar de matrizes;
5- Criar estruturas de dados complexas, como listas encadeadas e árvores binárias, onde um item deve
conter referências a outro;
6- Alocar e desalocar memória do sistema
Endereços de memória:
O endereço é a referência que o computador usa para localizar variáveis.

A memória do computador é dividida em bytes, numerados de 0 até o limite de memória de sua
máquina, chamados de endereços de bytes.Toda variável ocupa uma certa localização na memória, e seu
endereço é do primeiro byte ocupado por ela.
Operador de endereços &: Usado para se conhecer o endereço ocupado por uma variável.
Operador indireto (*): operador unário que resulta no valor da variável apontada.
Exemplo: uso do operador &
#include <stdio.h>
intmain(){
int i, j, k;
printf("\n Endereco de i: %x ", &i);
printf("\n Endereco de j: %x ", &j);
printf("\n Endereco de k: %x ", &k);
return 0;
}
Saída (valores em hexadecimal):
Endereco de i: 0x6dfefc
Endereco de j: 0x6dfef8
Endereco de k: 0x6dfef4
O endereço ocupado por essas variáveis dependerá de vários fatores, tais como: tamanho do
sistema operacional e se há ou não outros programas residentes na memória. Assim, diferentes valores
podem ser encontrados. Cada endereço difere do próximo por 4 bytes – já que inteiros geralmente ocupam
4 bytes de memória. Essa diferença depende do tipo da variável. Os endereços aparecem em ordem
descendente, pois variáveis automáticas são guardadas na pilha.
52
Exemplos de instruções contendo variáveis ponteiro e de como os valores são armazenados na
memória do computador (obs: neste exemplo o inteiro ocupa 2 bytes):
Uma variável aponta para outra variável quando a primeira contém o endereço da segunda.
Passagem de parâmetros por referência:
Passar parâmetros por referência significa que os parâmetros passados para uma função correspondem a
endereços de memória ocupados por variáveis. Toda vez que for necessário acessar determinado valor, isso
será feito por meio de referência, ou seja, apontamento ao seu endereço.
Exemplo:
2 #include<conio.h>
3 intsoma_dobro (int *a, int *b);
4 voidmain()
5 {
6 int x, y, res;
7 printf(“\nDigite o primeiro numero:”);
8 scanf(“%d”, &x);
9 printf(“\nDigite o segundo numero:”);
10 scanf(“%d”, &y);
11 res = soma_dobro(&x, &y);
12 printf(“\n A soma do dobro dos números %d e %d = %d”, x, y, res);
13 getch();
14 }
15 intsoma_dobro(int *a, int *b)
16 {
17 int soma;
18 *a=2*(*a);
19 *b=2*(*b);
20 soma = *a + *b;
21 return soma;
53
22 }
Representação gráfica:
- Supor que os valores armazenados nas variáveis x e y, pela execução das linhas 8 e 10, sejam,
respectivamente, 5 e 3.
- Quando a função soma_dobro é chamada, na linha 11, são passados como parâmetros para a função
os endereços de memória ocupados pelas variáveis x e y (isso é feito pelo operador & que obtém o endereço
de memória de uma variável), ou seja, do exemplo, os valores 800 (endereço ocupado por x) e 300 (endereço
ocupado por y). Os valores que recaem sobre as variáveis a e b (da função) são, respectivamente, 800 e 300
(isto é correto, já que a e b são ponteiros do tipo int).
- Nas linhas 18 e 19, os valores 5 e 3 são multiplicados por 2. Neste momento ocorre a ‘referência’
aos endereços de memória 800 e 300, para que sejam obtidos os valores iniciais e, após a realização das
multiplicações, os valores sejam alterados. Dessa forma, no endereço 800 passamos a ter o valor 10, e no
endereço 300 passamos a ter o valor 6.
- Na linha 20, é realizada a soma dos valores que estão nos endereços especificados por a e b (que já
foram multiplicados por 2).
- Na linha 21, o resultado da soma é devolvido à função main, recaindo sobre a variável res (linha 11)
e encerrando a função soma_dobro.
- Quando a função soma_dobrochega ao fim, as variáveis a,b e soma são destruídas. Entretanto, as
alterações decorrentes das multiplicações feitas são mantidas, pois cada alteração fez referência a endereços
de memória que estavam fora da área destinada à função. Assim, após a função soma_dobro, o valor de x será
10 e o de y, 6.
Observações:
A linguagem C/C++ não permite que vetores e matrizes sejam passados na íntegra como parâmetro
para uma função. Deve-se passar apenas o endereço da posição inicial do vetor ou da matriz. Esse endereço é
obtido utilizando-se o nome do vetor (ou da matriz) sem o índice entre colchetes.
É possível passar um vetor para uma função somente se essa passagem for por referência.
Exemplo: Fazer um programa com uma sub-rotina que receba um vetor de 5 números reais como
parâmetro e retorne a soma dos elementos desse vetor.
54
Resultado da execução:
Exemplos:
1) Faça uma sub-rotina que receba um vetor A de dez elementos inteiros como parâmetro. Ao final
dessa função, deverá ter sido gerado um vetor B contendo o fatorial de cada elemento de A. O vetor B deverá
ser mostrado no programa principal.
#include <stdio.h>
voidfatVet (int vet1[], int vet2[]);
intmain()
{
intvetA[10], vetB[10], i;
//Entrar com os valores do vetor
for (i=0; i<10 ; i++) {
do {
scanf(“%d”, &vetA[i]);
}while (vetA[i]<0);
}
fatVet(vetA, vetB);
//Mostra o vetor B resultante
55
for (i=0; i<10; i++) {
printf (“\n O fatorial de %d = %d”, vetA[i], vetB[i]);
}
return 0;
}
voidfatVet (int vet1[], int vet2[])
{
intfat, i, j;
// Varrer todo o vetor A
for (i=0; i<10; i++){
fat =1;
for (int j=1; j<=vet1[i]; j++){
fat = fat*j;
}
vet2[i] = fat;
}
}
Obs: outra opção seria declarar o vetor B como uma variável global e a função fatVet passaria apenas o
vetor A. O protótipo da função seria agora: voidfatVet (int vet1[]);
2) Faça uma sub-rotina que receba como parâmetro um vetor A com dez números reais e retorne esses
números ordenados de forma crescente.
#include <stdio.h>
voidordenaVet (floatvet[]);
intmain()
{
floatvetA[10]; int i;
//Entrar com os valores do vetor:
for (i = 0 ; i < 10 ; i++) {
scanf(“%f”, &vetA[i]);
}
ordenaVet(vetA);
//Mostra o vetor B resultante:
printf(“\n Vetor A em ordem crescente = ”);
for (i = 0 ; i < 10 ; i++) {
printf(“\n %f: ”, vetA[i]);
}
return 0;
}
voidordenaVet(floatvet[])
{
int i, j; floattemp;
for (i=1; i<10; i++)
{
for (j=0; j<9; j++)
{
if (vet[j]>vet[j+1])
{
temp=vet[j];
vet[j] = vet[j+1];
vet[j+1] = temp;
}
}
56
}
}
3) Faça uma sub-rotina que receba um vetor X de 30 elementos inteiros como parâmetro e retorne dois
vetores A e B. O vetor A deve conter os elementos de X que sejam maiores que zero e o vetor B, os elementos
menores ou iguais a zero.
Protótipo da função: void (intvetX[], intvetA[], intvetB[]);
Perguntas:
1- O que são sub-rotinas?
2- O que significa modularização?
3- Para que serve o comando return?
4- O que são parâmetros de funções? como são representados?
5- O que significa o tipo void usado em funções?
6- Quais são os quatro tipos de funções existentes? Explique dois tipos.
7- O que significa modularização?
8- Explique cada algoritmo apresentado.
9- Qual a diferença entre variáveis locais e globais?
10- Para que serve o comando return?
11- Para que serve o comando void?
12- O que é protótipo de função? Quando devemos usá-lo?
13- O que significa passagem de parâmetros por valor? Dê um exemplo.
14- O que significa passagem de parâmetros por referência? Dê um exemplo.
15- Como é feita a passagem de um vetor para uma função?
1) Faça uma sub-rotina que leia cinco valores inteiros, determine e mostre o maior e o menor deles.
Exemplo de pseudocódigo:
57
2) Faça uma sub-rotina que receba um valor inteiro e positivo, calcule e mostre o seu fatorial.
3) Crie uma sub-rotina que receba como parâmetro um valor inteiro e positivo e retorne a soma dos
divisores desse valor.
4) Faça um programa que receba dois números positivos por parâmetro e retorne a soma dos N números
existentes entre eles.
5) Crie uma função que receba três números inteiros a,b e c, sendo a maior que 1. A função deverá
somar todos os inteiros entre b e c que sejam divisíveis por a (inclusive b e c) e retornar o resultado
para a função principal.
6) Faça uma função que receba como parâmetro um inteiro no intervalo de 1 a 9 e mostre a seguinte
tabela de multiplicação (neste exemplo, n=9).
7) Elabore um programa contendo uma sub-rotina que receba as três notas de um aluno como parâmetros
e uma letra. Se a letra for A, a sub-rotina deverá calcular a média aritmética das notas do aluno; se for
P, deverá calcular a média ponderada, com pesos 5, 3 e 2. A média calculada deverá ser devolvida ao
programa principal para, então, ser mostrada.
8) Elabore uma sub-rotina que receba como parâmetro um valor N (inteiro e maior ou igual a 1) e
determine o valor de S:
58
1 1 1
𝑆 = 1+ + + ⋯..+
2 3 𝑁
Obs: A quantidade de parcelas que compõe S é igual a N.
9) Elabore uma sub-rotina que retorne ao programa principal um vetor com os três primeiros números
perfeitos. Um número é perfeito quando é igual à soma de seus divisores (exceto ele mesmo).
Exemplo: os divisores de 6 são: 1, 2 e 3, e 1+2+3=6. Logo, ele é perfeito.
Exemplo de pseudocódigo:
10) Faça um programa contendo uma sub-rotina que receba dois valores numéricos e um símbolo. Este
símbolo representará a operação que se deseja efetuar com os números. Se o símbolo for ‘+’ deverá
ser realizada uma adição, e se for ‘*’ deverá ser efetuada uma multiplicação. O resultado deverá ser
mostrado no programa principal.
11) Faça uma sub-rotina que receba um vetor A de dez elementos inteiros como parâmetro. Ao final
dessa função, deverá ter sido gerado um vetor B contendo cada elemento de A dividido pelo maior
valor de A. O vetor B deverá ser mostrado no programa principal.
12) Faça uma sub-rotina que receba como parâmetro um vetor A com dez números reais e retorne esses
números ordenados de forma decrescente.
13) Faça uma sub-rotina que receba um vetor X de 30 elementos inteiros como parâmetro e retorne dois
vetores: A e B. O vetor A deverá conter os elementos ímpares de X, e o vetor B deverá conter os
elementos pares de X.
Manipulação de cadeia de caracteres
A linguagem C/C++, para armazenar uma cadeia de caracteres, utiliza vetores, nas quais cada posição
representa um caractere.
Os compiladores da linguagem C/C++ identificam o fim de uma cadeia por meio do caractere nulo, ou
seja, por meio de ‘\0’. Logo, deve-se declarar sempre o vetor com uma posição a mais para armazenar o
caractere nulo (este caractere não precisa ser armazenado manualmente; isto é feito automaticamente pelo
59
compilador). Por exemplo, para armazenar a variável CADEIA deve-se declarar um vetor do tipo char com 7
posições (que ocuparão posições contíguas na memória).
char palavra[7];
Conformese observa na tabela anterior, a variável palavra, quando é declarada, pode ocupar qualquer
posição na memória; entretanto, todas as posições do vetor ocupam espaços de memória adjacentes, sendo
que cada caractere ocupa 1 byte.
Os caracteres armazenados em uma cadeia devem estar entre aspas e, quando apóstrofos, aspas ou
barras invertidas fizerem parte da cadeia de caracteres, deverão ter uma barra invertida antecedendo-os.
Exemplos de variáveis do tipo cadeia de caracteres:
char NOME[21]; A variável NOME poderá armazenar até 20 caracteres.

char SEXO[4]; A variável SEXO poderá armazenar até 3 caracteres.
char CURSO; A variável CURSO poderá armazenar apenas um caractere
Para manipular as cadeias de caracteres, a maioria das funções especificadas fazem parte da biblioteca
string.h. As mais comuns são:
Nome Função
strcpy(s1,s2) Copia s2 em s1
strcat(s1,s2) Concatena s2 ao final de s1
strlen(s1) Retorna o tamanho de s1
strcmp(s1,s2) Retorna 0 se s1 e s2 são iguais; menor que 0 se s1<s2; maior que 0 se s1>s2
strchr(s1,ch) Retorna um ponteiro para a primeira ocorrência de ch em s1
strstr(s1,s2) Retorna um ponteiro para a primeira ocorrência de s2 em s1
O que podemos fazer com strings?
1- Inicializar cadeias de caracteres
As variáveis que armazenam cadeias de caracteres podem ser inicializadas automaticamente pelo
programa ou podem receber um valor pelo teclado.
1.1- Inicialização no momento da declaração:
char nome[ ] = {‘P’, ‘A’, ‘T’, ‘R’, ‘I’, ‘C’, ‘I’, ‘A’, ‘\0’};
ou
char nome[ ] = “PATRICIA”;
No primeiro caso, a variável nome recebeu as letras separadamente (incluindo o caractere nulo). Por
isso, cada uma das letras estava entre apóstrofos (‘’) – esta é a maneira de identificar um caractere
isoladamente.
60
No segundo caso, a variável nome foi inicializada com uma palavra, recebendo automaticamente o
caractere nulo. Por isso, a palavra estava entre aspas (“”) – esta é uma forma de identificar uma cadeia de
caracteres.
Em ambos os casos não foi preciso expressar o número de posições de dentro dos colchetes, pois
esse número é definido automaticamente em função da inicialização.
Como armazenar uma barra invertida e um apóstrofo em cadeias sem gerar erro de compilação?
char local [ ] = ‘c:\\exemplos\\arquivo.txt’;

char texto [ ] = ‘curso d\’água’;
No primeiro caso, a variável local receberá a cadeia c:\exemplos\arquivo.txt’.

No segundo caso, a variável texto receberá a cadeia curso d’água.
1.2- Inicialização por meio da atribuição (depois da declaração):
char vet1[10], vet2[10]; //Declaração de dois vetores de caracteres de 10 posições.

strcpy(vet1, “Programa”); //A variável vet1 recebe um valor constante (a palavra Programa)
strcpy(vet2, vet1); //O conteúdo da variável vet1 é copiado na variável vet2
1.3-Inicialização por meio do teclado
scanf ("%[^\n] ", vet1);

A função scanf(), nesse formato, vai armazenar na variável vet1 todos os símbolos digitados até a
ocorrência do ENTER.
2- Copiar cadeias de caracteres (strcpy() e strcnpy())
strcpy (str1,str2); //copia a cadeia str2 para a cadeia str1.

strcnpy (str1, str2, n); //copia os n primeiros caracteres da cadeia str2 para a cadeia str1.
A função strcnpy() copia os n primeiros caracteres da cadeia str2 para a cadeia str1.
61
Exemplo:
3- Concatenar cadeias de caracteres(strcat() e strncat())
strcat(cadeia1, cadeia2); //concatena a cadeia2 na cadeia1.

strncat(cadeia1, cadeia2,n); //concatena os n primeiros caracteres da cadeia2 na cadeia1.
Exemplo:
62
4- Comparar cadeias de caracteres (strcmp(), stricmp(), strcmpi(), strncmp(), strnicmp(),
strncmpi())
resultado = strcmp (cadeia1, cadeia2);
A função strcmp() compara duas cadeias de caracteres e retorna um número inteiro, que poderá ser:
- zero se duas cadeias forem iguais;
- um número menor que zero se a cadeia1 for alfabeticamente menor que a cadeia2;
- um número maior que zero se a cadeia1 for alfabeticamente maior que a cadeia2.
Essa função considera letras maiúsculas símbolos diferentes de letras minúsculas.
resultado = stricmp(cadeia1,cadeia2);
resultado = strcmpi(cadeia1,cadeia2);
As funções stricmp() e strcmpi() comparam duas cadeias de caracteres e retorna um número inteiro,
que poderá ser:
- zero se duas cadeias forem iguais;
Essas funções consideram letras maiúsculas e letras minúsculas símbolos iguais.
Exemplo:
63
Outras funções:
resultado = strncmp(cadeia1,cadeia2,n);
A função strncmp() compara duas cadeias de caracteres da primeira posição, ou seja, da posição
zero, até a posição n ou até encontrar alguma diferença, e retornam um número inteiro, que poderá ser:
- zero se as duas cadeias forem iguais;

Essa função considera letras maiúsculas símbolos diferentes de letras minúsculas.
resultado = strnicmp(cadeia1,cadeia2,n);
64
resultado = strncmpi(cadeia1,cadeia2,n);
As funções strnicmp() e strncmpi() comparam duas cadeias de caracteres da primeira posição, ou

seja, da posição zero, até a posição n ou até encontrar alguma diferença, e retornam um número inteiro, que
poderá ser:
- zero se as duas cadeias forem iguais;

Essas funções consideram letras maiúsculas e letras minúsculas símbolos iguais.
5- Verificar o número de caracteres de uma cadeia (strlen())
tamanho = strlen(cadeia);
Essa função retorna para a variável tamanho o número de caracteres da cadeia.
6- Verificar a posição de uma cadeia de caracteres dentro de outra cadeia de caracteres

(strchr(), strrchr(), strstr())
posi = strchr(str1, ch);
A função strchr retorna para a variável posi um ponteiro com a posição da cadeia str1, em que o
caractere ché encontrado pela primeira vez. Se o caractere chnão for encontrado na cadeia str1, a variável
posi receberá null.
posi = strrchr(str1, ch);
A função strrchr() retorna para a variável posi um ponteiro com a posição da cadeia str1, em que o
caractere ch é encontrado pela última vez. Se o caractere chnão for encontrado na cadeia str1, a variável posi
receberá null.
posi = strstr (str1, str2);
A funçãostrstr retorna para a variável posi um ponteiro com a posição da cadeia str1, na qual a
cadeia str2 é encontrada pela primeira vez. Se a cadeia str2 não for encontrada na cadeia str1, a variável posi
receberá null.
Essas funções fazem distinção entre letras maiúsculas e minúsculas.
Exemplo com a função strstr()
65
7- Alterar os caracteres em uma cadeia de caracteres (strset(), strnset(), strrev())
strset(str1, ch);
A função strset() substitui todos os caracteres da cadeia str1 pelo caractere ch.
strnset(str1, ch, n);

A função strnset() substitui os n primeiros caracteres da cadeia str1 pelo caractere ch.
strrev(str1);
A função strrev() inverte todos os caracteres da cadeia str1.
Exemplo:
66
8- Converter um valor numérico inteiro em caractere (itoa())
itoa(valor numérico inteiro, cadeia de caracteres, base);
A função itoa() converte o valor numérico inteiro para a cadeia de caracteres utilizando a base
especificada. Essa função exige a utilização da biblioteca stdlib.h. O valor numérico inteiro deve estar
armazenado em uma variável do tipo int. A variável que armazenará a conversão deverá suportar o tamanho
do número, incluindo o caractere de final de cadeia, ou seja, ‘\0’, e a base numérica de conversão deverá estar
entre 2 e 36.
9- Converter caractere em valor numérico inteiro (atoi)
numero = atoi(cadeia de caracteres);
A função atoi() converte a cadeia de caracteres para um valor numérico inteiro, ou seja, a parte
fracionária será desprezada. A variável número deve ser do tipo int e a função atoi() exige a utilização da
biblioteca stdlib.h.
10- Converter caracteres para maiúsculo (toupper() e strupr())
cadeia[posição] = toupper(cadeia[posição]);
A função toupper() converte o caractere da cadeia da posição especificada para maiúsculo. Esta
função exige a utilização da biblioteca ctype.h.
strupr(cadeia);
A função strupr(cadeia) converte todos os caracteres da cadeia para maiúsculo. Usa a biblioteca
string.h.
11- Converter caracteres para minúsculo (tolower() e strlwr())
cadeia[posição] = tolower(cadeia[posição]);
A função tolower() converte o caractere da cadeia da posição especificada para minúsculo. Esta
função exige a utilização da biblioteca ctype.h.
67
strlwr(cadeia);
A função strlwr(cadeia) converte todos os caracteres da cadeia para minúsculo. Usa a biblioteca
string.h.
Obs.: As letras acentuadas e o ç não são convertidos.
Exemplos:
1- Faça um programa que receba uma frase, calcule e mostre a quantidade de vogais da frase digitada. O
programa deverá contar vogais maiúsculas e minúsculas.
Algoritmo:
1- Digitar uma frase
2- Pegar o tamanho da frase
3- Percorrer a frase, pegando caractere por caractere
4- Comparar cada caractere com as vogais (maiúsculas e minúsculas)
5- Quando encontrar uma vogal, acrescentar um na quantidade.
2- Faça um programa que receba uma frase, calcule e mostre a quantidade de palavras da frase
digitada.
Algoritmo:
1- Digitar uma frase.
68
2- Pegar o tamanho da frase.
3- Percorrer a frase, pegando caractere por caractere
4- Comparar cada caractere com espaço em branco.
5- Quando encontrar um espaço, acrescentar um na quantidade.
6- Como após a última palavra não tem espaço, acrescentar um na quantidade.
1- Faça um programa para criptografar uma frase dada pelo usuário. A cada ocorrência de uma vogal na
frase, trocar por *.
Exemplo:
Frase: Eu sou feliz
Saída: ** s** f*l*z
Algoritmo:
2- Pegar o tamanho da frase
3- Percorrer a frase, comparando cada caractere com as vogais
4- Quando encontrar uma vogal, substituí-la por um asterisco
2- Faça um programa que receba uma frase com letras minúsculas e converta a primeira letra de cada
palavra para maiúscula.
69
Exemplo:
Entrada: vamos estudar para aprender
Saída: Vamos Estudar Para Aprender
3- Faça um programa que receba uma frase e uma palavra, calcule e mostre a quantidade de vezes que a
palavra digitada aparece na frase.
Algoritmo:
2- Pegar o tamanho da frase digitada
3- Percorrer a frase, pegando caractere por caractere.
4- Cada vez que encontrar um espaço em branco ou o fim da frase, foi obtida uma palavra completa.
5- Se a palavra completa for igual à palavra digitada, acrescentar um ao contador.
4- Faça um programa que receba uma palavra e verifique se constitui um palíndromo, ou seja, a palavra
escrita do fim para o começo fica igual à palavra escrita do começo para o fim. (ignorar maiúsculas e
espaços)
Exemplo: Subi no ônibus
Algoritmo:
1- Digitar uma palavra
2- Pegar o tamanho da palavra digitada
3- Percorrer a frase, pegando cada caractere na direção da esquerda para a direita e comparando com
cada caractere da direita para a esquerda;
4- Repetir o passo 3 até a metade +1 do tamanho da palavra.
Exemplo:
0 1 2 3 4
A R A R A
Tamanho da palavra: 5 caracteres

Palavra[0] == Palavra [4] ?
Palavra[1]==Palavra[3] ?
Palavra[2]==Palavra[2] ?
Se sim é um palíndromo.
5- Faça um programa que receba uma frase e mostre cada palavra dela em uma linha separada
70
6- Faça um programa que receba uma frase e um caractere e verifique em que posição da frase o caractere
digitado aparece pela primeira vez e pela última vez.
7- Faça um programa que receba uma frase e converta as vogais de suas palavras para maiúsculo e as
consoantes para minúsculo.
8- Faça um programa que receba uma frase e faça a criptografia dela, substituindo as vogais pelos
seguintes números: a=1, e=2,i=3,o=4,u=5.
Arquivos
Arquivo:
- Estrutura de dados manipulada fora do ambiente do programa (ou seja, a memória principal, onde nem
sempre é possível ou conveniente manter certas estruturas de dados).
- armazenado em um dispositivo de memória secundária, como discos, por exemplo, pode ser lido ou
escrito por um programa e é formado por uma coleção de caracteres (arquivo texto) ou bytes (arquivo
binário).
Um sistema de banco de dados é composto por um ou vários arquivos. Cada um destes arquivos
possui programas de manutenção, que são: inclusão, exclusão (lógica ou física), alteração, consulta geral,
consulta específica e relatórios. Na exclusão física, após a eliminação de um registro, os demais registros são
deslocados; e na exclusão lógica, os registros possuem um campo adicional, identificando se estão ativos ou
inativos, isto é, se foram excluídos.
1- Declarar arquivos
Um arquivo C/C++ pode representar: arquivos em disco, uma impressora, um teclado, ou qualquer
dispositivo de entrada ou saída. Neste documento, serão considerados apenas arquivos em disco; para
manipular outros dispositivos, a interface é a mesma.
A biblioteca stdio.h fornece várias funções para manipulação de arquivos, define novos tipos de
dados a serem usados especificamente com arquivos, como o tipo FILE. Uma variável do tipo ponteiro FILE é
capaz de identificar um arquivo no disco, direcionando para ele todas as operações. Essas variáveis são
declaradas como qualquer outro tipo de ponteiro:
FILE *arq, *pont;
Na linguagem C/C++, os dados podem ser gravados em arquivos binários ou de texto. Arquivos de
texto podem ser lidos diretamente. Arquivos binários devem ser lidos por programas especiais, que
convertem a cadeia de bits em informações compreensíveis.
Arquivos binários – armazena dados como estão organizados na memória do computador (arquivos
executáveis, arquivos compactados)
Arquivos de texto – armazena dados como sequências de caracteres
2- Abrir arquivos
71
A função fopen() abre um arquivo, retornando o ponteiro associado a este arquivo. Sintaxe:
FILE *p;
p = fopen (nome_do_arquivo, modo_de_abertura);
onde:
p é uma variável que poderá armazenar o endereço inicial de memória ocupado por um arquivo (se,
por qualquer motivo, o arquivo não puder ser aberto, a variável p receberá o valor NULL);
nome_do_arquivorepresenta o nome do arquivo que se deseja abrir, podendo conter, inclusive, o
caminho (path) da pesquisa;
modo_de_abertura representa como o arquivo será aberto. A tabela a seguir descreve todos os
modos de abertura:
EXEMPLO 1:
FILE *arq;
arq = fopen("arquivo1.dat","w");
No exemplo, a função fopen() cria um arquivo chamado arquivo1.dat, onde poderão ser realizadas
operações de escrita (gravação), pois foi utilizado o modo de abertura w.
Quando a função fopen() é utilizada para abrir um arquivo no modo escrita (w e wb), duas situações
podem ocorrer:
 Se o arquivo não existir, ele será criado;
 Se o arquivo já existir, ele será sobreposto por um novo arquivo vazio.
Se a função fopen() for executada sem problemas, a variável arq receberá o endereço de memória
ocupado pelo arquivo. Caso algum erro ocorra, a variável arq receberá o valor NULL. Sendo assim, é
recomendável a realização de um teste para verificar se o arquivo foi aberto adequadamente.
EXEMPLO 2:
72
A função fopen() é utilizada para abrir um arquivo já existente somente no modo leitura(r). Se o
arquivo for encontrado no caminho especificado e aberto corretamente, a variável arq receberá o seu
endereço; caso contrário, receberá NULL.
Observação: a função fopen() não é capaz de criar pastas, pode apenas criar arquivos quando o
modo de abertura escolhido permitir. Caso não se tenha certeza de que a pasta já existe no disco, é possível
construí-la através do comando mkdir(). A sintaxe correta desse comando é:
mkdir(“caminho”);
Por exemplo: mkdir("c:\\exemplo\\teste");
Será criada a pasta exemplo e, dentro dela, a pasta teste. Se as pastas já existirem, nada será feito.
Observe que foi necessária a utilização de duplas barras invertidas para evitar que o compilador fizesse
confusão com caracteres de controle, como, por exemplo, a marca de nova linha \n ou de tabulação \t.
3- Fechar arquivos
A função fclose() fecha um arquivo. Quando ocorrer algum erro durante a execução da função,
poderá haver perda de dados ou até mesmo perda do arquivo. Sintaxe:
fclose(arq);
onde:
arq é a referência para o arquivo (arq é o ponteiro obtido quando o arquivo foi aberto).
Quando a função fclose() é executada, gera como resultado um número inteiro. Se este número for
igual a zero, significa que o arquivo foi fechado corretamente. Caso contrário, houve erro na operação.
EXEMPLO:
A função fopen() abriu o arquivo arquivo1.dat no modo escrita, associando seu endereço à variável
arq. A função fclose() fecha este arquivo associado à variável arq.
4- Capturar erros durante o uso de arquivos
A função ferror() detecta se ocorreu algum erro durante uma operação com arquivos. Sintaxe:
ferror(FILE *arq);
73
A função ferror() retorna um número inteiro, e deve ser chamada logo depois que qualquer outra função
for invocada. Se o número retornado for diferente de zero, isto significa que ocorreu um erro durante a
última operação realizada com o arquivo. Se esse número for zero, não ocorreu erro.
5- Gravar caracteres em um arquivo
A função fputc() escreve um caractere em um arquivo. Sintaxe:
fputc(char ch, FILE *arq);
onde:
ché o caractere que será escrito no arquivo;
arq é a referência para o arquivo onde o caractere será escrito.
EXEMPLO:
6- Ler caracteres de um arquivo
A função fgetc() lê um caractere em um arquivo. Sintaxe:
intfgetc(FILE *arq);
onde:
arq é a referência para o arquivo de onde o caractere será lido.
Se a execução da função fgetc() for bem sucedida, gerará como retorno o valor do caractere lido (este
valor poderá ser armazenado em uma variável int já que é o valor ASCII ou em uma variável char exigindo a
conversão do valor ASCII para o caractere) correspondente. Caso ocorra algum erro na leitura, o valor
devolvido será EOF.
EXEMPLO:
74
7- Gravar uma cadeia de caracteres em um arquivo
A funçãofputs() escreve uma cadeia de caracteres em um arquivo. Sintaxe:
fputs(char *cadeia, FILE *arq);
onde:
cadeia armazena a cadeia de caracteres que será escrita no arquivo.
arq é a referência para o arquivo em que a cadeia de caracteres será escrita.
EXEMPLO:
8- Ler uma cadeia de caracteres de um arquivo
75
A função fgets() lê uma cadeia de caracteres armazenada em um arquivo. A cadeia será formada por
todos os caracteres existentes, da posição atual do ponteiro do arquivo até uma marca de uma nova linha ou
até que tam-1 caracteres forem lidos (tam é um dos parâmetros utilizados pela função). Sintaxe:
fgets() (char *cadeia, inttam, FILE *arq);
onde:
cadeia armazena a cadeia de caracteres obtida do arquivo;
tam indica que a quantidade máxima de caracteres lidos será tam-1;
arq é a referência para o arquivo.
EXEMPLO:
9- Gravar e ler qualquer tipo de dado em um arquivo
As funções fprintf () e fscanf() são usadas, respectivamente, para gravar e ler qualquer tipo de dado de
interesse em/de um arquivo. Sintaxes:
onde 𝒇𝒑 é um ponteiro de arquivo devolvido por uma chamada a fopen(). fprintf() e fscanf() direcionam
suas operações de E/S para o arquivo apontado por𝒇𝒑 .
EXEMPLO: ler uma string e um inteiro do teclado e os grava em um arquivo em disco chamado test. O
programa então lê o arquivo e exibe a informação na tela. Após executar este programa, examine o arquivo
test.
76
10- Encontrar o fim de um arquivo
A função feof() descobre se o final do arquivo foi encontrado; ela retorna um número inteiro. Quando
este número for zero, significa que o fim do arquivo ainda não foi atingido. Qualquer outro valor significa
que o fim do arquivo foi encontrado. Sintaxe:
feof(arq);
onde
arq é a referência para o arquivo ser analisado.
11- Apagar um arquivo
A função remove() apaga um arquivo. Sintaxe:
remove(char *nome_arq);
onde
nome_arq indica o nome físico do arquivo que será removido, podendo ser incluído o caminho path.
Se a função remove() for executada com êxito, será devolvido o número zero. Caso contrário, será
devolvido qualquer valor. Além disso, é importante fechar o arquivo antes de removê-lo.
Exemplo: remove ("c:\\silvia\\cadeias.txt");
77
12- Renomear um arquivo
A função rename() troca o nome de um arquivo. Sintaxe:
rename (char *nome_atual, char *nome_novo);
onde:
nome_atualindica o nome físico atual do arquivo, podendo ser incluído o caminho (path);
nome_novo indica o novo nome físico que se pretende dar ao arquivo, podendo ser incluído o caminho
(path).
Exemplo 1:
Exemplo 2:
1- Escreva um programa C que leia o conteúdo de um arquivo texto e informe quantas linhas o arquivo
possui. Dessa forma, supondo que o arquivo texto tenha o seguinte conteúdo:
Ana Maria
Júlia
Alberto
Camila
Sua saída deverá ser parecida com: O arquivo contém 4 linhas
2- Escreva um programa que:

(a) Crie/abra um arquivo texto de nome “arq.txt”
(b) Permita que o usuário grave diversos caracteres nesse arquivo, até que o usuário entre com o caractere
‘0’
(c) Feche o arquivo
Agora, abra e leia o arquivo, caractere por caractere, e escreva na tela todos os caracteres armazenados.
3- Faça um programa que receba do usuário um arquivo texto e mostre na tela quantas letras são vogais.
4- Faça um programa que receba do usuário um arquivo texto e um caractere. Mostre na tela quantas
vezes aquele caractere ocorre dentro do arquivo.
5- Faça um programa no qual o usuário informa o nome do arquivo e uma palavra, e retorne o número de
vezes que aquela palavra aparece no arquivo.
78
6- Faça um programa que receba dois arquivos do usuário, e crie um terceiro arquivo com o conteúdo
dos dois primeiros juntos (o conteúdo do primeiro seguido do conteúdo do segundo).
7- Faça um programa que receba o nome de um arquivo de entrada e outro de saída. O arquivo de
entrada contém em cada linha o nome de uma cidade (ocupando 40 caracteres) e o seu número de
habitantes. O programa deverá ler o arquivo de entrada e gerar um arquivo de saída onde aparece o
nome da cidade mais populosa seguida pelo seu número de habitantes.
8- Faça um programa que recebe um vetor de 10 números, converta cada um desses números para
binário e grave a sequência de 0s e 1s em um arquivo texto. Cada número deve ser gravado em uma
linha.
Trabalho de strings e arquivos – grupos de 3 alunos irão escolher 2 questões (uma de string e um de arquivo)
– mostrar a solução na próxima aula – com documentação – valendo 2.0 pontos na nota2. Avaliação
individual (Ver questões no Apêndice).
79
Apêndice
O que fazer no trabalho?
- Mostrar um algoritmo em forma descritiva do exercício selecionado
- Mostrar a implementação e resultado
Propostas de exercícios de strings:
1- Faça um programa que receba uma frase e coloque as palavras da frase em ordem alfabética.
Exemplo:
Entrada: A informática está em constante evolução
Saída: A constante em está evolução informática
2- Faça um programa que receba uma frase, calcule e mostre a quantidade de vezes que a palavra
“aula” aparece na frase digitada.
Exemplo:
Entrada: A aula de informática é legal; eu gosto da aula de Química.
Saída: A palavra aula aparece 2 vezes na frase.
3- Faça um programa que receba uma frase e uma palavra, calcule e mostre a quantidade de vezes
que a palavra digitada aparece na frase.
Exemplo:
Entrada: EU ESTOU NO IPRJ NO CURSO DE ENGENHARIA DE COMPUTAÇÃO;
Palavra: CURSO
Saída: a palavra CURSO apareceu 1 vez na frase.
4- Faça um programa que receba uma frase e troque a palavra ALUNO por estudante e palavra
ESCOLA por UNIVERSIDADE.
Exemplo:
Entrada: EU SOU ALUNO DA ESCOLA
Saída: EU SOU ESTUDANTE DA UNIVERSIDADE
5- Faça um programa que receba uma frase com letras minúsculas e converta a primeira letra de
cada palavra da frase para maiúscula.
Exemplo:
Entrada: fazer exercícios faz bem
Saída: Fazer Exercícios Faz Bem
6- Faça um programa que se comporte como um vírus, ou seja, que duplique cada uma das palavras
digitadas pelo usuário.
Exemplo:
Entrada: EU ESTOU NA UNIVERSIDADE
Saída: EU EU ESTOU ESTOU NA NA UNIVERSIDADE UNIVERSIDADE
80
7- Faça um programa que receba o nome completo de uma pessoa e mostre os nomes intermediários
entre o primeiro nome e o último sobrenome abreviados.
Exemplo:
Entrada: João Carlos Gomes Nascimento
Saída: João C. G. Nascimento
8- Faça um programa que receba o nome completo de uma pessoa e reescreva-o de acordo com o
exemplo a seguir:
Exemplo:
Entrada: Maria Silva Costa
Saída: Costa, M.S.
9- Faça um programa que recebe um nome e gere um login e uma senha. O login deverá ser
composto pela primeira letra de cada nome em letras maiúsculas e as mesmas letras minúsculas; a
senha será composta pela representação ASCII de cada letra do login.
Exemplo:
Nome: Ana Beatriz Costa
Login: ABCabc
Senha: 656667979899
10- Faça um programa que receba uma frase e mostre quantas letras, quantos números e quantos
espaços existem nela.
11- Faça um programa que receba uma frase e, cada vez que aparecer nela um algarismo entre 0 e 9,
substitua-o, escrevendo-o por extenso.
Exemplo:
Frase: EU ESTOU NA POLTRONA 5
Saída: EU ESTOU NA POLTRONA CINCO.
12- Faça um programa que receba uma cadeia de caracteres e o número de repetições (limitado a 5) e
gere uma nova cadeia.
Exemplo:
Cadeia = Ai!
Número = 5
Nova cadeia = Ai! Ai! Ai! Ai! Ai!
81
O que fazer no trabalho?
- Mostrar um algoritmo em forma descritiva do exercício selecionado
- Mostrar a implementação e resultado
Propostas de exercícios de arquivos:
1- Faça um programa que receba dois arquivos do usuário, e crie um terceiro arquivo com o conteúdo dos
dois primeiros juntos (o conteúdo do primeiro seguido do conteúdo do segundo).
2- Faça um programa que receba o nome de um arquivo de entrada e outro de saída. O arquivo de entrada
contém, em cada linha, o nome de uma cidade (ocupando 40 caracteres) e o seu número de habitantes. O
programa deverá ler o arquivo de entrada e gerar um arquivo de saída onde aparece o nome da cidade
mais populosa seguida pelo seu número de habitantes.
3- Faça um programa que recebe um vetor de 10 números, converta cada um desses números para binário e
grave a sequência de 0s e 1s em um arquivo texto. Cada número deve ser gravado em uma linha.
4- Faça um programa para criar um arquivo chamado ALUNOS.dat. Cada linha do arquivo deverá conter as
informações de: nome, matrícula e telefone de 5 alunos. Obs: não pode haver alunos com o mesmo
número de matrícula. Após criar o arquivo, leia o arquivo e exiba na tela o seu conteúdo.
5- Faça um programa no qual o usuário informa o nome do arquivo e uma palavra, e retorne o número de
vezes que aquela palavra aparece no arquivo.
6- Faça um programa que permita que o usuário entre com diversos nomes e telefone para cadastro, e crie
um arquivo com essas informações, uma por linha. O usuário finaliza a entrada com ‘0’ para o telefone.
Abra depois esse arquivo e exiba na tela apenas os telefones;
7- Dado um arquivo contendo um conjunto de nome e data de nascimento (DD MM AAAA), isto é, 3
inteiros em sequência), faça um programa que leia o nome do arquivo e a data de hoje e construa outro
arquivo contendo o nome e a idade de cada pessoa do primeiro arquivo.
8- Faça um programa que leia um arquivo contendo o nome e o preço de diversos produtos (separados por
linha), e calcule o total da compra.
9- Faça um programa que leia o conteúdo de um arquivo e crie um arquivo com o mesmo conteúdo, mas
com todas as letras minúsculas convertidas para maiúsculas. Os nomes dos arquivos serão fornecidos, via
teclado, pelo usuário.
10- Faça um programa que receba do usuário um arquivo que contenha o nome e a nota de diversos alunos (da
seguinte forma: NOME: JOÃO NOTA: 8), um aluno por linha. Mostre na tela o nome e a nota do aluno
que possui a maior nota.
11- Escreva um programa que leia a profissão e o tempo de serviço (em anos) de cada um dos 5 funcionários
de uma empresa e armazene-os no arquivo “emp.txt”. Cada linha do arquivo corresponde aos dados de um
funcionário. Utilize o comando fprintf(). Em seguida, leia o mesmo arquivo utilizando fscanf(). Apresente
os dados na tela.
12- Faça um programa que peça 3 notas de um aluno (Matemática, Fisica e Portugues), e salve esses dados em
um arquivo chamado “notas.txt”, que deve ter, ao final, a média das 3 disciplinas.
Exemplo:
Matemática: 10.0
Fisica: 8.0
Portugues: 9.0
Média final: 8.0
13- Faça um programa que leia (do teclado) um cadastro de 10 alunos, indicando o nome, nota1, nota2.
Calcule a média aritmética simples dos 10 alunos e depois escreva em um arquivo texto os dados de cada
82
aluno: nome, nota1, nota2 e média. Lembre-se de que as notas e média deverão ser apresentadas como
valores que possuem até 2 casas após a vírgula.
83
Referências:
Livros:
1- Herbert Schildt (1997).C completo e total. Makrom Books. 3ª edição.

2- Brian W. Kernighan, Dennis M. Ritchie (1988). The C programming Language. Prentice Hall. 2ª
edição.
3- Ana Ascencio e Edilene Campos (2006). Fundamentos da Programação de Computadores –
Algoritmos, Pascal, C/C++ e Java. 2ª edição.
4- Byron S. Gottfried (1993). Programando em C. Makron Books.
84

Apostila de Introdução A Programacao - Silvia Campos

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila de Introdução A Programacao - Silvia Campos

Enviado por

Direitos autorais:

Formatos disponíveis

Introdução à Programação - IPRJ/UERJ

Professora: Sílvia Campos

Conceitos básicos de programação

Memória: dispositivo de armazenamento de informação. Toda informação armazenada dentro da memória

O tamanho da memória de um computador é normalmente expresso como algum múltiplo de 2 10 =

Categorias principais de linguagem de programação:

2- Linguagem de baixo nível (linguagem Assemby: montadora): também dependente da máquina.

Programa fonte Interpretador Tradução e execução linha a linha

Programa fonte Compilador Programa Objeto

Código-objeto ou programa-objeto. Programa-fonte traduzido pelo compilador. O compilador transcreve o

Programa executável: programa a ser executado pelo programador.

Programa fonte Compilador (tradutor) Programa objeto

Linkeditor Programa executável

Tempo de execução:os eventos que ocorrem enquanto o seu programa é executado.

1. Um conjunto de informações, denominados dados de entrada, é inserido no computador (através de teclado,

Os dados de entrada são convertidos em informação significativa:

DADOS: valores brutos e números. INFORMAÇÃO: dados processados.

Cada um desses passos exigirá uma ou mais instruções de um programa.

Etapas para o desenvolvimento de um programa:

Procedimento para contar:

Passo 1: Faça 𝑁 igual a zero

Exemplos de algoritmos corretos (que satisfazem as três condições):

Passo 1: Faça 𝑁 igual a zero

2) Procedimento para somar três números:

Passo 1 - Receber os três números.

3) Procedimento para sacar dinheiro no Banco 24 horas

Passo 1 - Ir até um banco 24 horas.

Tipos de algoritmos (os mais usados):

2- Fluxograma: utiliza símbolos gráficos pré-definidos. Principais símbolos:

Terminação. Símbolo utilizado para indicar o início e o fim do algoritmo.

Sentido. Permite indicar o sentido do fluxo de dados. Serve exclusivamente para

Dados. Símbolo utilizado para representar a entrada de dados.

Documento, Símbolo utilizado para representar a saída de dados.

3- Pseudocódigo (Pseudolinguagem ou Portugol): utiliza regras pré-definidas que facilitam a passagem do

VisuAlg (https://visualg3.com.br/): programa para editar e implementar algoritmos.

Exemplo1: Faça um algoritmo para mostrar o resultado da multiplicação de dois números:

1- Algoritmo em descrição narrativa:

PASSO 1 – Receber os dois números que serão multiplicados.

2- Algoritmo em fluxograma: 3- Algoritmo em pseudocódigo:

Exemplo2: Faça um algoritmo para mostrar o resultado da divisão de dois números.

1- Algoritmo em descrição narrativa:

PASSO 1- Receber os dois números para divisão: numerador e o denominador.

2- Algoritmo em fluxograma 3- Algoritmo em pseudocódigo

1- Algoritmo em descrição narrativa:

PASSO 1 - Receber as duas notas.

2- Algoritmo em fluxograma: 3- Algoritmo em pseudocódigo:

Uma visão geral de C

Obs: um bloco de código inicia-se em abre-chaves ( { ) e termina em fecha-chaves ( } ).

Expressões e tipos de dados

Exemplos de identificadores válidos:

A, idade, Dia, nota1, media_total

Exemplos de identificadores inválidos:

8ab - começa com um número,

Forma geral de declaração de variável: tipo lista_de_variáveis;

Exemplo de algumas declarações:

Declaração e inicialização de variáveis:

Código Códigos de barra invertida

Exemplo: const int a=10;

Comandos de entrada e saída

Sintaxe: scanf (string de controle, arg1, arg2, ..., arg n)

Caracteres mais utilizados para conversão de entrada de dados:

Caractere de conversão Significado

Os caracteres não-brancos consecutivos que compõem um dado definem um campo. É possível

/Calcular a media e imprimir a resposta /