PROFª. ANGELINA V.S. MELARÉ
[email protected]
Linguagem
C
10101
INFORMÁTICA II
2009
SUMÁRIO
Linguagem C ................................................................................................................................................................. 3
Processo de Compilação ............................................................................................................................................... 4
Ciclo de Vida do Programa ........................................................................................................................................... 4
Estrutura do Programa na Linguagem C ....................................................................................................................... 8
Variável ....................................................................................................................................................................... 11
Operadores Aritméticos .............................................................................................................................................. 14
Funções de Entrada e Saída Formatada ....................................................................................................................... 16
Exercício Resolvido .................................................................................................................................................... 18
Expressão Relacional e Lógica ................................................................................................................................... 19
Estruturas de Decisão (condicional) ............................................................................................................................ 21
Tipos de Estruturas de Condição................................................................................................................................. 24
Exercícios Resolvidos – .............................................................................................................................................. 27
Estrutura de Decisão ................................................................................................................................................... 27
Bibliografia Consultada .............................................................................................................................................. 54
LINGUAGEM C
AULA 1
A linguagem C foi desenvolvida por programadores, para programadores. Ela se popularizou
rapidamente devido sua portabilidade, velocidade, segurança e eficiência. Com ela é possível
desenvolver desde um simples sistema tradicional (sistema de recursos humanos) até mesmo um
programa de sistema (sistema operacional, aplicativos , entre outros).
Origens da linguagem C
A linguagem C foi criada por Dennis Ritchie em 1972. Sua origem foi através da linguagem
BCPL, desenvolvida por Martin Richards, que influenciou Ken Thompson a criar o B, que levou a
linguagem C. Com a popularização dos microcomputadores houve um aumento no desenvolvimento de
compiladores C, criando discrepâncias entre eles. Para resolver essa situação, o órgão americano de
padronização (American National Standards Institute), em 1983, criou C padrão ANSI, estabelecendo
uma definição padronizada da linguagem C. A maioria dos compiladores são compatíveis com esse
padrão.
A linguagem C++ foi construída sobre os fundamentos da linguagem C e dá suporte para a
programação orientada a objetos.
Existem vários ambientes de desenvolvimento para a linguagem C, como: DEV-C++, Visual
C++, Turbo C, C#.
Resumo histórico
•
1966 – BCPL (Martin Richards)
•
1970 - B (Ken Thompson)
•
1972 – C (Dennis Ritchie e Ken Thompson)
•
1978 - C K&R (Kernigham e Ritchie)
•
1983 - C padrão ANSI - órgão americano de padronização (American National Standards
Institute) – O padrão ANSI definiu o conteúdo e a forma da biblioteca padrão C.
•
1985 - C++ (é o C projetado para suportar Programação Orientada a Objetos).
Características e Vantagens:
•
Facilidade de aprendizagem de outras linguagens de programação, inclusive as orientadas a
objetos;
•
É constituído por funções (divisão de rotinas);
•
Linguagem estruturada
•
Ferramenta poderosa de desenvolvimento– pode usada para desenvolver um editor de texto ou
mesmo uma calculadora
•
Portabilidade
•
Linguagem compiladora
PROCESSO DE COMPILAÇÃO
E CICLO DE VIDA DO PROGRAMA
AULA 2
Linguagem C Compiladora ou Interpretadora?
A linguagem de programação pode ser compiladora ou interpretadora. O que as distingue é a
forma com que elas executam o programa .
O interpretador lê o código fonte linha a linha, executando-as em seguida; já o compilador, lê o
código fonte inteiro, e se este não tiver erros de sintaxe, será convertido em um código de máquina,
fazendo com que o processador consiga entendê-lo e executá-lo.
Se forem feitas alterações no programa, este terá que ser compilado novamente, gerando um novo
código de máquina.
Um computador só pode executar programas em linguagem de máquina. Cada programa
executável é uma seqüência de instruções que o processador interpreta e executa as operações
correspondentes.
O código fonte é a tradução dos comandos do pseudocódigo para as respectivas instruções da
linguagem de programação C. Essas instruções em C depois são traduzidas para a linguagem da máquina.
O arquivo objeto somente é gerado quando o arquivo fonte não possui erro de sintaxe.
Ciclo de Vida do Programa
Criação do programa
Depois de solucionado o problema e escrito o algoritmo em pseudocódigo, este deve ser passado
para uma linguagem de programação, ou seja, codificado. Na nossa disciplina será usada a linguagem de
programação C. O programa digitado se chama arquivo fonte, e deve ser salvo com a extensão .CPP (c
plus plus) ou .C. Se não for digitada a extensão, será assumirá a extensão padrão do compilador ( .cpp).
Para executar esse programa é necessário compila-lo e linka-lo. Na compilação as instruções
(linhas) são verificadas e interpretadas pela máquina (CPU), se não houver erros de sintaxe, será gerado o
arquivo executável (extensão .exe).
O linkeditor (linker), junta os arquivos das bibliotecas usados pela linguagem C com os arquivos
fontes criados pelo programador. Para ver o programa funcionando basta digitar seu nome ou dar um
duplo clique no ícone do programa, de acordo com o ambiente que você estiver (texto ou gráfico).
Os erros de lógica só podem ser detectados pelo programador e depois de gerado o arquivo
executável.
O ciclo de criação de um programa em C pode ser analisado abaixo, na seqüência de figuras
abaixo.
arquivo fonte
arquivo biblioteca
arquivo fonte
...
arquivo objeto
arquivo objeto
Linkedição
arquivo executável
Exemplo:
AMBIENTE DE DESENVOLVIMENTO DEV-C++
AULA 3
Ambiente integrado
O DEV-C++ é um ambiente integrado e visual de desenvolvimento para a linguagem de
programação C e C++, que inclui um local para digitação do programa (editor de texto), um compilador
(gcc - Gnu C Compiler) e o linkeeditor.
Pode-se digitar o programa em outro editor de texto, como por exemplo, o Word, devendo ter o
cuidado de salvá-lo como um arquivo texto, sem qualquer tipo de formatação.
O DEV-C++ pode ser adquirido gratuitamente pelo site http://www.bloodshed.net/devcpp.html.
A versão mencionada nesta apostila é a versão 4.9.8.0, em português.
Digitação do programa
Para a digitação do programa no DEV-C++ é necessário seguir os seguintes passos:
1. No menu escolha a opção Arquivo (File);
2. Escolha a opção Novo (New) e depois Arquivo Fonte (Source File) ou se preferir a tecla
de atalho <CTRL> e <N> simultaneamente;
3. Aparecerá uma nova janela, com o título: (*) Sem Título 1, onde deve ser feita a
digitação do programa fonte.
4. Dependendo da versão, ou mesmo da configuração pré-definida no editor, aparece um
programa inicial. Pode-se apagá-lo ou deixá-lo, aproveitando as linhas de código já
digitadas.
Gravação do programa
Após a digitação do programa, ele deverá ser salvo antes de ser executado, de acordo com as
etapas abaixo:
1. No menu Arquivo escolha a opção Salvar ou use a tecla de atalho <CTRL> e <S>
simultaneamente.
2. Escolha o diretório de trabalho, digite o nome do arquivo fonte e pressione o botão
Salvar. Observe que a extensão padrão do DEV-C++ é o .cpp.
Ao salvar o arquivo fonte, cuidado para não salva-lo com nome inválido ou com o mesmo do
Compilação e execução do programa
Existem diversas maneiras de ver se o programa está sem erros e funcionando, entre elas:
1. Escolhendo a opção Executar (Execute) do menu e dentro dela a opção Compilar e
Executar (Compile and Run); ou
2. Pressionando a tecla de função <F9> ou <F10>, dependendo da versão ou
3. Procurando na barra de ferramentas a opção Compilar e Executar.
Se você quiser apenas verificar se existem erros no programa, poderá inicialmente compila-lo
(através do menu Executar, opção Compilar) e futuramente executa-lo (através do menu Executar, opção
Executar).
Ao ser executado o programa, o compilador abrirá uma janela como na figura abaixo:
Configurando o ambiente e o editor
As configurações padrões do compilador, do ambiente e do editor de texto podem ser alteradas
indo no menu Ferramentas e escolhendo a opção a ser modificada, conforme a figura ao lado. Procure
personalizar o seu ambiente de trabalho, criando atalhos e facilidades no processo de digitação e
compilação.
Uma boa forma de configurar
o editor é criar um modelo inicial de
programa fonte, ou seja, toda vez que
for iniciado um novo arquivo irá
aparecer o modelo que você definiu.
As linhas de comandos e bibliotecas
mais comuns ficam digitadas neste
modelo.
Para criar o modelo de código padrão escolha a
opção Ferramentas, depois Opções do Editor e a guia Código.
Na parte inferior clique no Código Fonte Padrão e digite seu
código fonte.
ESTRUTURA DO PROGRAMA NA LINGUAGEM C
AULA 4
Um programa escrito na linguagem C tem uma estrutura um pouco diferente de um programa
escrito em outra linguagem, como Pascal. Em C, se trabalha com funções e bibliotecas. Um programa
precisa ter necessariamente uma função principal (main), que define onde é iniciada a execução do
programa. Veja o exemplo abaixo:
Estrutura básica
Um programa feito na linguagem C é constituído basicamente de:
Cabeçalho:
• Diretivas de pré-processamento, onde podem ser definidas constantes e incluídos
arquivos de cabeçalho.
• Declaração e inicialização de variáveis globais.
Bloco de instruções: um bloco principal (função main) e outros blocos de rotinas.
Documentação do programa: comentários.
Diretivas
As diretivas do pré-processador iniciam com o símbolo # e cada diretiva deve ser escrita em linha
distinta. As diretivas instruem o compilador dentro do código-fonte do programa em C. As diretivas do
padrão C ANSI a serem usadas são: #include, #define.
O pré-processador do C é um programa que examina o arquivo fonte e executa as devidas
modificações com base nas diretivas.
O compilador antes de tudo localiza a função na biblioteca e adiciona seu código ao código do
arquivo fonte.
#include
Essa diretiva quando lida faz a inclusão de um arquivo de cabeçalho ao arquivo-fonte.
Exemplo:
#include <stdio.h>
arquivo de cabeçalho: stdio.h
– Std standard padrão
–
–
–
–
I input
O output
Funções padrões de entrada e saída
Funções associadas: scanf(), printf()
#define
Essa diretiva define um identificador (constante simbólica) e uma string que o substituirá toda
vez que for encontrado no código-fonte.
Estrutura: #define identificador string
Exemplo:
#include <stdio.h>
#define ESCREVA printf
#define TEXTO “\nProgramação de Computadores”
main()
{
ESCREVA(TEXTO);
}
Ao ser executada a diretiva #define, o compilador associa a palavra escreva a palavra printf e
toda vez que aparecer a palavra escreva ele a substituída por printf e a palavra texto será substituída por
“\nProgramação de Computadores”.
Arquivos de Cabeçalho (header)
Cada função definida na biblioteca C tem seu respectivo arquivo de cabeçalho, ou seja, se você
utilizar uma função de entrada -scanf()- terá que incluir seu respectivo arquivo de cabeçalho (stdio.h) no
início do programa. Esse arquivo possui a definição de tipo e o protótipo da função.
Os arquivos com a extensão .h, são chamados de arquivos de cabeçalho, ou header files.
Arquivo de cabeçalho
stdio.h
conio.h
math.h
stdlib.h
time.h
string.h
Finalidade
Suporta entrada e saída com arquivos
Suporta E/S pelo console
Possui diversas funções matemáticas
Declarações miscelâneas
Funções de horário do sistema
Funções de string
Dica: O arquivo de cabeçalho feito pelo programador é colocados entre “ ”.
Exemplo: #include “funccondicao.h”
Exemplo: # include <stdio.h>
Essa diretiva faz com que o compilador insira o conteúdo do arquivo stdio.h dentro do programa
fonte antes de compila-lo. Esse arquivo possue declarações de funções úteis para entrada e saída de
dados padronizados. A biblioteca stdio significa: std=standard= padrão; io = input/output = entrada/
saída.
Explicação de execução e incorporação das funções
Uma biblioteca é uma coleção de funções. Um arquivo de biblioteca armazena o nome de cada
função, o código-objeto da função, mais as informações necessárias para o processo de linkagem.
Quando o programa se referencia a uma função, o linkeditor procura a função na biblioteca (que possui
várias) e adiciona apenas o seu código ao programa.
As funções padrões existentes na biblioteca do compilador C foram definidas pela ANSI.
Algumas empresas criaram funções novas e acrescentaram ao compilador, como por exemplo, a Borland,
acrescentou ao Turbo C a biblioteca CONIO (Console Input/Output).
Bloco de Execução
Todos os programas na linguagem C começam executando o conteúdo descrito na função
principal (main). Essa função determina a execução e ordem de execução das demais funções que
existirem.
As funções possuem um conjunto de instruções com uma tarefa específica, como por exemplo,
uma função para calcular o salário dos funcionários. Essa função pode ter uma instrução que calcula o
desconto alimentação, outra que calcula o desconto de transporte, entre outras instruções. Também
existem as funções de bibliotecas já mencionadas anteriormente, que podem ter a função de mostrar de
forma formatada uma mensagem na tela, ou mesmo buscar a data atual do computador.
O conteúdo da função é delimitado por chaves { }. O código que estiver dentro das chaves será
executado seqüencialmente quando a função for chamada.
Regras de Digitação e Dicas da Estrutura em C
• Espaços
em branco são desconsiderados
Dê preferência para um código limpo, fácil de entender, com alinhamento e identação. Como no exemplo
que segue:
Com espaços
Sem espaços
(correto e incompreensível)
(correto e compreensível)
#include
<stdio.h>
#include <stdio.h>
main() { ….}
main()
{
….
}
• Coloque
comentários explicativos
Para facilitar a compreensão coloque comentários ao decorrer do código. Como no exemplo abaixo:
/* Autor: Lorena Melaré
Data: 20/01/2008
Sistema: Cadastro de Fornecedores */
• Cuidado com as palavras reservadas, exemplo: include, printf, main
• Há diferenciação de letras maiúsculas e minúsculas (case sensitive)
A linguagem C é case sensitive, ou seja, diferencia letra maiúscula da minúscula. Exemplo:
NOME é diferente de Nome que é diferente de nome.
As palavras-chaves de C são minúsculas. (else é palavra-chave, mas ELSE ou Else não são).
• Os parênteses após o nome de uma função, como a função main() é obrigatório.
• As chaves { } servem para delimitar um bloco de instruções. As variáveis devem ser declaradas no
início.
• No C para indicar o final de uma instrução deve ser usado o ;(ponto-e-vírgula). Se for necessário
podem ser digitadas várias instruções numa mesma linha. Como por exemplo: printf
“Exemplo da Estrutura “; printf “de um Programa em C”;
VARIÁVEL
AULA 5
O que são variáveis?
Os dados armazenados no computador
podem ser apresentados de duas formas
diferentes: como constantes ou variáveis.
Os dados fornecidos pelos meios de
entrada ou mesmo os processados são
transferidos e armazenados numa área da
memória do computador chamada de Variável.
A variável é uma posição de memória
que é usada para armazenar um valor (tipo de
dado). Esse valor pode ser alterado a qualquer
momento no programa. Essas variáveis são
utilizadas como áreas de trabalho, ou seja, como
uma lousa, onde podemos escrever, modificar e
apagar quantas vezes for necessário.
Memória
Existem regras para a formação dos
nomes das variáveis, de acordo com a linguagem
de programação a ser usada. As regras
relacionadas abaixo são do C:
_ o primeira caracter tem que ser
obrigatoriamente uma letra ou um sublinhado;
_ o nome pode ser formado por
números, só que estes não podem ser colocados
na primeira posição.
_ o nome da variável não pode ter
caracteres especiais ou espaço, com exceção do
caracter _ (underline);
_ as letras maiúsculas e minúsculas são
tratadas diferentemente (case sensitive).
_ o nome da variável não pode ser igual
a uma palavra reservada da linguagem.
Declaração da variável
A declaração da variável deve ser feita
obrigatoriamente antes da sua utilização,
podendo ser declaradas em 3 lugares diferentes:
dentro da função (variável local), fora da função
(variável global), ou como parâmetro formal.
Variáveis
Mas em que parte da memória vão os dados?
Cada dado será armazenado em uma
posição da memória (variável) diferente. Essas
posições precisam ser identificadas, ou seja, ter
um nome definido. O nome da variável torna-se
o seu endereço. Imaginem como você
encontraria uma pessoa sem ter seu endereço ou
telefone?
Não se esqueça que ao definir o tipo de
variável está se determinado a quantidade de
espaço (bytes) que será alocado na memória e o
intervalo de valores que ela poderá armazenar.
Nome da variável (Identificador)
A melhor forma de nomear uma variável
é verificar qual será seu conteúdo e definir o
nome de acordo com ele. Por exemplo, se for
armazenar o sexo do paciente, o melhor nome
para a variável é SEXO e não SS.
Variáveis Locais: São variáveis declaradas
dentro de uma função e são visíveis apenas na
função em que foram criadas. Funções distintas
podem ter variáveis locais com o mesmo nome.
Observação:
Variáveis Globais: São variáveis definidas fora
de qualquer função e que estarão disponíveis
para serem utilizadas em todo o programa.
No pseudocódigo o símbolo  significa atribuição.
Na linguagem C ela é representada com o símbolo =.
Exemplos de Declaração de Variável:
tipo_de_variável
nome_variável, nome_variável;
Pseudocódigo
real salario;
inteiro num_filho;
caracter sexo;
real porc_aum 5.5;
inteiro
qtd_leite;
C
float salario;
int num_filho;
char sexo;
float porc_aum =5.5;
Dicas
Pode ser atribuído um conteúdo a variável quando
ela for declarada.
qtd_pao, int qtd_pao, qtd_leite; Podem ser declaradas diversas variáveis do mesmo
tipo ao mesmo tempo.
TIPOS DE DADOS
Defina de forma correta o tipo de dado, para que não ocorra falta de memória durante a execução
do programa ou lentidão de processamento. Quando você define o tipo de variável o computador reserva
um espaço de acordo com o tipo definido. Mesmo que o valor recebido e armazenado seja menor que o
espaço reservado o computador conserva o mesmo tamanho.
Na linguagem C os tipos básicos de dados são: caracter (char), inteiro (int), ponto flutuante
(float) e sem valor (void).
Caracter
Esse tipo de dado é usado para
armazenar uma letra (a..z, A..Z), um número
(0..9) ou um caracter especial (º, ^, &, =, #, :).
Na linguagem C, não existe um tipo de
variável para armazenar uma cadeia de
caracteres (string), como em muitas outras
linguagens de programação. Para armazenar um
conjunto de caracteres usaremos a estrutura de
vetor que será explicada depois.
Quando for um único caracter
colocamos seu conteúdo obrigatoriamente entre
apostrofe (‘). Quando for uma cadeia de
caracteres, colocamos entre aspas (“).
Exemplos:
char sexo;
char estado_civil = ‘c’;
Numéricas
As variáveis numéricas armazenam
apenas números. Esses números podem ser:
inteiros ou reais (ponto flutuante).
Numéricas Inteiras
Contém números que não possuem a
parte decimal, podendo ser positivos, negativos
ou nulos. Os numéricos inteiros (2 bytes)
ocupam menos memória que os numéricos reais
(4 bytes).
Exemplos:
int idade;
int num_filho;
Numéricas Reais:
Esse tipo contém tanto números inteiros
quanto números reais. Todos os números não
importando o tamanho, sinal ou mesmo o
número
de casas decimais podem ser definidos
como tipo real.
Exemplos:
float salario;
float porc_aumento = 15.50;
float salário, aumento;
Lógicas
As variáveis definidas como lógicas
(booleanas) podem guardar apenas um dos dois
estados: Verdadeiro ou Falso, sempre
armazenando apenas um dígito. Na linguagem C
não existe um tipo específico para a
representação de valores lógicos. O dígito 0
representa o valor lógico falso e 1 representa o
valor lógico verdade.
Espaço Alocado de Memória
Tipo de
Variável
char
int
float
void
Tamanho
(bytes)
1
2
4
0
Exemplo de
Conteúdo
‘f’
14
15.655
Curiosidade: ao se atribuir um caracter a
uma variável, internamente o conteúdo a
ser armazenado é um código ASCII (na
tabela padrão o valor varia de 0 a 127).
Recordando:
O nome da variável serve de
referência ao dado armazenado em
um espaço de memória e o tipo da
variável determina a natureza do
dado que será armazenado.
CONSTANTES
Quando nos referimos a um dado que não pode ser alterado temos uma constante, que significa
constantemente com o mesmo valor (valor fixo). Dentro de um programa podem existir várias constantes,
como por exemplo, o ano atual, o valor de PI.
Exemplos:
const int ANO_ATUAL = 1990;
const float PI = 3.1415;
O programa irá criar uma variável chamada PI, com o valor 3.1415, que não poderá ser
modificada pelo programa.
AULA 6
OPERADORES ARITMÉTICOS
Os operadores aritméticos da linguagem C são: +, -, *, / e %. O ponto (.) representa separador
decimal e a vírgula (,) separador de milhar.
Operado
r
+
*
/
%
-++
Ação
Exemplo
Adição
Subtração
Multiplicação
Divisão
Módulo
Decremento
Incremento
1+1 =2
1–1 =0
2*2 =4
2/2 =1
2%2=0
--x
é x=x-1
++x é x = x + 1
**Cuidado, ao ser usado o
operador de divisão a um
tipo inteiro, será retornado
um valor inteiro. Por
exemplo, 5/2 será igual a 2.
A precedência (maior prioridade) de operadores segue a ordem: *, /, %, +, -. Os operadores com
a mesma precedência são executados da esquerda para a direita.
Módulo: O operador resto da divisão (módulo) somente deve ser usado com números inteiros.
Exemplo:
5%2=1
Resto da Divisão
5
2
1
2
Parte Inteira da Divisão
(Quociente)
Forma de usar os operadores de Incremento e Decremento
Esses operadores podem ser usados como prefixo ou sufixo, como, ++n1 ou n1++. Quando o
operador precede a variável ((++n1), ele executa a operação (incremento ou decremento) antes de usar o
conteúdo da variável. Se o operador estiver depois da variável (n1++), o computador primeiro usa o valor
armazenado na variável para depois executar a operação.
Exemplos:
n1 = 10
n1 = 10
n2 = ++ n1
n2 = n1++
resultado n2 = 11
resultado n2 = 10 somente a próxima vez o x vale 11
Operadores Aritméticos de Atribuição ou C Reduzido
Na linguagem C pode ser feito usado de um operador aritmético com o comando de atribuição,
dessa forma simplificando a programação.
Exemplo:
num = num + 2
pode ser escrito da seguinte maneira: num+=2;
num2 = num1 = 10 o valor 10 é atribuído a num1 e, em seguida o valor de num1 é
atribuído da num2 (da direita para a esquerda).
No exemplo acima o operador += acrescenta 2 ao valor da variável num e o armazena a variável
num.
Podendo ser usado qualquer operador aritmético, como: num-=2, num*=2, num/=2, num%=2.
Conversão de Tipo
A linguagem C oferece o recuso de conversão automática de valores. A conversão pode ser feita
usando o operador cast (operador de molde de tipo). Esse operador é colocado entre parênteses antes do
valor a ser convertido.
Exemplo:
a) float x = 5;
o valor de x é convertido para 5.0;
b) 5 / 2.0
o valor de 5 é convertido para 5.0, porque o segundo operando é 2.0. O resultado
da expressão é 2.5
c) int a, b;
a = (int) 3.5; -- é atribuído o valor 3 para a variável a
b = (int) 3.5 % 2; -- é convertido o valor 3.5 para 3 para depois fazer a
operação módulo, que só pode ser feita com valores do tipo inteiro.
Curiosidade:
Na linguagem C é usada a função pow() para fazer exponenciação.
pow(2,3) ---- O resultado é 8, ou seja, o 2³
FUNÇÕES DE ENTRADA E SAÍDA FORMATADA
AULA 7
Função de Saída - printf()
A função printf() realiza a saída de dados em vários formatos, de acordo com a configuração feita
pelo programador. O protótipo da função está no arquivo de cabeçalho STDIO.H. Com essa função é
possível exibir mensagens, resultados de cálculos, endereços de memória.
O protótipo do printf() é:
printf(“string_de_controle”, lista_de_argumentos);
•
Na string de controle é definido tudo que será exibido na tela: cadeia de caracteres, o formato
das variáveis (usando-se o comando de formato - %) e os caracteres de controle (usando o
símbolo \).
•
Na lista de argumentos definem os formatos que serão exibidos os valores.
•
Deve haver o mesmo número de argumentos e de comandos de controle.
Comandos de Formato mais usados
Código Formato
%c
caracter
%d
inteiros decimais com sinal
%i
inteiros decimais com sinal
%f
ponto flutuante decimal
%s
string de caracteres
%x
hexadecimal sem sinal
%u
inteiros decimais sem sinal
%p
apresenta um ponteiro
%%
escreve o símbolo %
Código
\a
\b
\n
\r
\t
\”
Caracteres de Controle mais usados
Formato
soa o alarme do microcomputador
o cursor retrocede uma coluna
o cursor avança para uma nova linha
o cursor retrocede para a primeira coluna da linha
o cursor avança para próxima marca de tabulação
exibe uma aspas
É possível especificar o tamanho dos campos que serão exibidos. Como nos exemplos abaixo:
%4d
_ _ 3 3
%7.2f
_ _ _ 5.3 0
7 possíveis no total, sendo fixadas 2 para o número de casas decimais
Dicas:
Comando
printf("%8i", 10);
Exibição
(
10)
printf("%-8i", 10);
(10
printf("%08i", 10);
(0000010)
printf(“%.1f”,1910.10)
1910.1
)
Explicação
As posições definidas a mais são preenchidas
com espaço em branco e o valor é alinhado à
direita do campo.
Se o tamanho do campo for precedido por um (menos), então, o valor será alinhado à esquerda
do campo.
Se o tamanho do campo for precedido com o 0
(zero), então as posições excedentes são
preenchidas com zeros.
Deve ser colocada a quantidade de casas
decimais a serem exibidas junto com o comando
de formato, como no exemplo %.1f
printf(“O resultado da soma
é:”);
soma =4.51;
printf(“O resultado da soma é:
%6.2f”, soma);
printf (“Mostra o símbolo %%
%%")
printf ("Um tipo caractere é %c
e um tipo inteiro é %i",‘A',20)
printf ("%s é um exemplo de
string","Este")
printf ("%s%d%%","Juros de
",10)
O resultado da soma é
O resultado da soma é
4.51
%%
Um tipo caractere é A
e um tipo inteiro é 20
Este é um exemplo
string
Juros de 10%
Função de Entrada – scanf()
A função scanf() é usada para fazer entrada de dados. Essa função captura o valor digitado no
teclado e armazená-o em uma variável . Os valores capturados são convertidos para o formato interno
apropriado. O protótipo dessa função está no arquivo de cabeçalho STDIO.H.
Sua estrutura e: scanf(“string_de_controle”, &lista_de_argumentos);
•
Primeiro se define o tipo de variável a ser recebido
•
Deve ser colocado o operador & (endereço de memória) antes de cada uma
das variáveis da lista de argumentos (exceto para strings).
•
Deve ser colocado o mesmo número de argumentos e de string de controle.
•
Num tipo string, o espaço em branco finaliza a entrada.
Podem ser recebidos vários valores ao mesmo tempo, usando como separador de entrada um
espaço em branco ou o caracter dois pontos ( : ) . Os especificadores %d, %f, %e pulam automaticamente
os brancos que precedem os valores numéricos.
Comandos de Formato mais usados
Código
Formato
%c
caracter
%d , %i
inteiros decimais com sinal
%f , %e, %g
ponto flutuante decimal
%s
string de caracteres
Exemplo:
float nota1, nota2;
scanf(“%f”, &nota1);
scanf(“%f”, &nota2);
ou
float nota1, nota2;
scanf(“%f %f ”, &nota1, &nota2);
EXERCÍCIO RESOLVIDO
AULA 8
Uma loja de telefone celular paga aos seus vendedores um salário fixo mais uma comissão de R$
50,00 por cada aparelho vendido. Faça um programa que receba o número de aparelhos vendidos
e calcule o salário total do vendedor.
Entrada:
• nome do vendedor
• número de aparelhos vendidos
• valor do salário fixo (mesmo não sendo pedido no enunciado, o valor do salário fixo deve ser
recebido para o cálculo do salário total)
Processamento:
• calcular o valor da comissão
_ quantidade de aparelhos vendidos * 50
• calcular o salário total
_ o valor da comissão + o valor do salário fixo
Saída:
• mostrar o salário total do vendedor
Pseudocódigo
INÍCIO
Inteiro quant;
real sal_bruto, comis, sal_total;
escreva (“Quant de aparelhos vendidos?”);
leia (quant);
escreva (“Qual o valor do salário fixo?”);
leia (sal_bruto);
comis  quant * 50;
sal_total  sal_bruto + comis;
escreva (“O salário final é:”, sal_total);
FIM
Linguagem C
#include <stdio.h>
#include <stdlib.h>
main()
{
int quant;
float sal_bruto, comis, sal_total;
printf(“\Quant de aparelhos vendidos?”);
scanf(“%i”,&quant);
printf(“\nQual o valor do salário fixo?”);
scanf(“%f”,&sal_bruto);
comis = quant * 50;
sal_total = sal_bruto + comis;
printf(“O salário final é %.2f”, sal_total);
system(“pause”);
}
EXPRESSÃO RELACIONAL E LÓGICA
AULA 9
Operadores Relacionais
Os operadores relacionais são utilizados em expressões de comparação (de valores, de conteúdo
de variáveis) e podem ser usados juntamente com os operadores aritméticos. Esses operadores relacionais
geram um resultado lógico (Verdadeiro ou Falso) quando aplicados nas operações.
Operador (pseudocódigo)
=
>
<
<=
>=
<>
Expressão em
pseudocódigo
3=5
15 > 5
5+ 6 = 11
7 < 4-5
‘s’ = ‘n’
Significado
Igual
Maior
Menor
Menor ou igual
Maior ou igual
Diferente
Expressão
Em C
3==5
15 > 5
5 + 6 = = 11
7 < 4-5
‘s’ = = ‘n’
C
==
>
<
<=
>=
!=
Resultado
0 - Falso
1- Verdadeiro
1- Verdadeiro
0 - Falso
0 - Falso
Na linguagem C não existe o tipo lógico (booleano) com os valores true e false (verdadeiro ou
falso). Ao verificar uma expressão, o compilador compara e retorna o valor zero ou um. O valor zero
representa o falso e, qualquer valor diferente de zero, no caso o valor um, representa o verdadeiro.
Expressão Lógica
As expressões lógicas são aquelas que operam com valores lógicos e resultam também num valor
lógico. Elas podem ser utilizadas em testes de variáveis, tomada de decisão e expressões matemáticas. A
função do operador lógico “NÃO” pode modificar valores e expressões, pois, ele serve para negar a
expressão.
Operador
Operação Prioridade
C
Negação
1
NÃO
!
Conjunção
2
E
&&
Disjunção
3
OU
||
E
OU
NÃO
V e V = V V ou V = Não F = V
VeF=F
V
Não V =F
F e V = F V ou F = V
F e F = F F ou V = V
F ou F = F
Exemplos:
Pseudocódigo
Não ( Idade = 5 )
Número1  5
Número2  6
Número1 > 7 E Número2 > 5
C
! ( Idade = = 5 )
Explicação
Nessa expressão temos o
resultado “Falso”, pois o
operador lógico “NÃO” negou a
expressão contida dentro do
parênteses.
Número1 = 5;
O resultado dessa expressão é
Número2 = 6;
“Falso”, pois o operador “E”
exige que as duas condições
Número1 > 7 && Número2 > sejam verdadeiras para o
resultado ser
“Verdadeiro”.
5
Veja que a primeira condição
está indicando que o Número1 é
maior que 7, mas isso não é
verdadeiro, pois o valor do
Número1 é 5, e 5 é menor que 7.
A
segunda
condição
é
verdadeira, pois 6 é maior que 5.
Número1  5
Número2  6
Número1 = 5;
Número2 = 6;
Número1 > 7 OU Número2 > 5
Número1 > 7 || Número2 > 5
O resultado dessa expressão é
“Verdadeiro”, pois o operador
“OU” indica que apenas uma das
condições precisa ser verdadeira
para
o
resultado
ser
“Verdadeiro”.
Observem
a
diferença do operador “OU” com
o operador anterior “E”.
ESTRUTURAS DE DECISÃO (CONDICIONAL)
Os programas são desenvolvidos com
a única função de facilitar a vida do homem,
resolvendo problemas mais rapidamente e com
mínimas chances de existência de erros.
Todas as complexidades de um
problema não podem ser passadas no
computador baseadas apenas numa estrutura
linear, pois esta estrutura - formada por
entradas, processamentos e saídas - não prevê
a possibilidade de desvios de instruções. Para
o desenvolvimento de programas mais
completos estudaremos a partir de agora uma
nova estrutura, a de decisão.
Muitas vezes em nossa vida temos que
fazer uma escolha, que pode ser de diferentes
níveis, desde as mais importantes até as mais
simples como: a escolha da profissão ou a cor
do carro. Com essas decisões podemos ter
vários caminhos diferentes a tomar.
AULA 10
Os testes estão presentes em quase todos os
programas, devido a grande flexibilidade e poder
de ação que tais estruturas proporcionam. As
decisões possuem somente dois caminhos
conforme resultado obtido, a do verdadeiro ou
a do falso. Conforme o resultado final do teste,
um dos caminhos deve ser seguido, sendo
obrigatório existir o verdadeiro e não sendo
obrigatório a existência do caminho falso.
Na verdade a decisão é uma condição ou
expressão lógica que é testada e verificada,
podendo ser verdadeira ou falsa. Se depois de
avaliada a condição o resultado for verdadeiro
então ela seguirá um caminho diferente daquele
seguido se fosse falsa.
Existem diversas estruturas condicionais:
simples, encadeada, múltipla escolha.
Algoritmos (Descrição Narrativa)
Estrutura Linear
Estrutura Condicional
INÍCIO
Pegar o doce
Tirar da embalagem
Comer o doce
FIM
INÍCIO
Pegar o doce
Tirar da embalagem
SE o doce estiver estragado
então
Jogar fora o doce
SENÃO
Comer o doce
FIM
NÚMERO
>
100
SENHA
<>
“AJUM”
IDADE
>
60
Fluxograma Estrutura Linear
Fluxograma com Estrutura de Condição
INÍCIO
INÍCIO
PEGAR O DOCE
PEGAR O DOCE
TIRAR DA EMBALAGEM
TIRAR DA EMBALAGEM
COMER O DOCE
F
ESTÁ
ESTRAGADO?
V
FIM
JOGAR FORA O DOCE
COMER O DOCE
FIM
No exemplo acima podemos ver facilmente a importância da estrutura de decisão. Na primeira
estrutura, a linear, existe apenas três procedimentos e não há verificação das informações. Na segunda
estrutura foi possível fazer a verificação de possíveis falhas na seqüência de processos, onde, foi
constatada a falta do procedimento que verificasse se o doce estava ou não estragado.
Exercício Resolvido
Elabore um programa que receba dois números e no final mostre o número maior.
Entrada:
Receber dois números
Processamento:
Verificar qual o número maior
Saída:
Mostrar o número maior
Pseudocódigo
Inicio
Declare
Real num1, num2;
Escreva (“Digite o primeiro número”);
Leia num1;
Escreva (“Digite o segundo número”);
Leia num2;
SE (num1 > num2) então
Escreva (“O maior número é: ”, num1);
Senão
Escreva (“O maior número é: ”, num2);
Fim
Teste de Mesa
MEMÓRIA
VALORES
SIMULADOS
100
5
PROCESSAMENTO
NUM1
NUM2
100
5
SAÍDA
ENTRADA
100
Linguagem C
#include <stdio.h>
#include <stdlib.h>
main()
{
float num1, num2;
printf(“\nDigite o primeiro número”);
scanf(“%f”,&num1);
printf(“\nDigite o segundo número”);
scanf(“%f”,&num2);
if (num1 > num2)
printf(“O maior número é %f”, num1);
else
printf(“O maior número é %f”, num2);
}
TIPOS DE ESTRUTURAS DE CONDIÇÃO
AULA 11
Existem várias estruturas de decisão, abaixo serão destacas e explicadas algumas. Não esqueça
que quando colocamos o termo condição estamos nos referindo a uma comparação, que pode resultar em
um dos dois valores: Verdadeira ou Falsa.
Estrutura Condicional Simples:
A instrução somente será executada se a condição testada for Verdadeira. Quando for mais de
uma instrução a ser executada deve ser delimitado o bloco de instruções com o seu início e fim.
SE condição ENTÃO
instrução;
SE condição ENTÃO
Início
instrução 1;
instrução 2;
instrução n;
Fim
Estrutura Condicional Composta:
A condição será testada e de acordo com o seu resultado (verdadeiro ou falso) será executado um
caminho (instrução) diferente.
SE condição ENTÃO
instrução;
SENÃO
instrução;
SE condição ENTÃO
Início
instrução 1;
instrução n;
Fim
SENÃO
Início
Instrução 1;
Instrução n;
Fim
Estrutura Encadeada:
Pode ser executada uma condição simples ou composta dentro de outra condição.
instrução;
SE condição ENTÃO
SENÃO
Início
Início
instrução;
SE condição ENTÃO
SE condição ENTÃO
Início
instrução;
Instrução 1;
Fim
Instrução n;
SENÃO
Fim
Início
Fim
Instrução 1;
Instrução n;
Fim
Fim
SE condição ENTÃO
Exemplos de Estrutura Condicional em C
Condição Simples:
if (condição)
instrução;
Condição Composta:
if (condição)
instrução;
else
instrução;
Estrutura Encadeada:
if (condição)
instrução;
else if (condição)
{
instrução 1;
instrução n;
}
else if (condição)
instrução;
if (condição)
{
instrução 1;
instrução n;
}
if (condição)
{
instrução 1;
instrução n;
}
else
{
Instrução 1;
Instrução n;
}
if (condição)
{
instrução 1;
instrução n;
}
else
if (condição)
Instrução;
Operador ? (ternário)
Em C existe o operador ? (operador condicional) que facilita a verificação de sentenças simples.
Estrutura: condição ? expressão1 : expressão2;
A condição é avaliada;
Se ela for verdadeira o resultado é o valor da expressão1;
Se a condição for falsa o resultado é o valor da expressão2.
Exemplo:
sal = 1000;
salnovo = sal>1000 ? 1000 : 1000;
Seleção Múltipla
As linguagens de programação possuem um comando exclusivo para seleção múltipla
(escolha...caso). Nessa estrutura o computador fará um teste sucessivo, verificando o valor da expressão
numa lista seqüencial de constantes, ao encontrá-lo ele executará o bloco de comandos associados a ela.
Essa estrutura é usada para verificação de menu de opções
Pseudocódigo:
verifique <valor da expressão>
início
caso <lista de valores 1> então <instruções>
caso <lista de valores 2> então <instruções >
....
senão < instruções>
fim-verifique
Estrutura em C:
switch( expressão )
{
case <lista de valores1>:
instruções;
break;
case <lista de valores 2>:
instruções;
break;
...
default:
instruções;
}
O comando default é executado se nenhuma coincidência for encontrada, ou seja, se o
computador não encontrar o valor da expressão na lista de constantes. O uso do default é opcional.
O comando break serve como um desvio de execução. Ao ser executado dentro do switch ele
finaliza a seqüência de instruções do case e sai do switch. Se não for usado o break o computador
continuará dentro do switch executando as demais instruções dos outros case.
Exemplo:
case ‘/’ :
if( n2 = = 0 )
printf(“Não existe divisão por zero”);
else
r= n1 / n2;
break;
Curiosidade:
Pode existir case sem instrução associada.
Caso isso ocorra o computador executará
as instruções do próximo case.
EXERCÍCIOS RESOLVIDOS –
ESTRUTURA DE DECISÃO
AULA 12
PARTE I
Receba uma idade qualquer e mostre uma mensagem de acordo com ela. Se a idade for igual ou
menos de 5 anos a criança deve ser vacinada.
Pseudocódigo
Inicio
Inteiro idade;
Escreva (“Digite idade”);
Leia idade;
SE idade <= 5 então
Escreva (“Deve ser vacinada”);
Fim
Linguagem C
#include <stdio.h>
#include <stdlib.h>
main()
{
Int idade;
printf(“\nDigite idade”);
scanf(“%i”,&idade);
if (idade <=5)
printf(“Deve ser vacinada”);
}
Receba a idade de uma pessoa e mostre uma mensagem de acordo com ela. As pessoas que tem
mais de 11 anos e menos de 18 são consideradas adolescentes.
Pseudocódigo
Inicio
Inteiro idade;
Escreva (“Digite sua idade”);
Leia idade;
SE idade >= 11 então
SE idade =< 18 então
Escreva (“Adolescente”);
Fim
Linguagem C
#include <stdio.h>
#include <stdlib.h>
main()
{
Int idade;
printf(“\nDigite idade”);
scanf(“%i”,&idade);
if (idade >= 11)
if (idade =<18)
printf(“Adolescente”);
}
Receba a idade de uma pessoa e mostre uma mensagem de acordo com ela. As pessoas que tiverem
menos de 18 anos e mais de 85 não estão aptas a dirigir e devem ser alertadas com uma mensagem.
Forma 1:
Pseudocódigo
Inicio
Inteiro idade;
Escreva (“Digite sua idade”);
Leia idade;
SE idade < 18 então
Escreva (“Não pode dirigir”);
SE idade > 85 então
Escreva (“Não pode dirigir”);
Fim
Linguagem C
#include <stdio.h>
#include <stdlib.h>
main()
{
Int idade;
printf(“\nDigite idade”);
scanf(“%i”,&idade);
if (idade < 18)
printf(“Não pode dirigir”);
if (idade > 85)
printf(“Não pode dirigir”);
}
Forma 2:
Pseudocódigo
Inicio
Inteiro idade;
Escreva (“Digite sua idade”);
Leia idade;
SE idade < 18 ou idade > 85 então
Escreva (“Não pode dirigir”);
Fim
Linguagem C
#include <stdio.h>
#include <stdlib.h>
main()
{
Int idade;
printf(“\nDigite idade”);
scanf(“%i”,&idade);
if (idade < 18 || idade > 85)
printf(“Não pode dirigir”);
}
CUIDADO: NÃO SE ESQUEÇA DE IDENTIFICAR A VARIÁVEL EM
CADA EXPRESSÃO LÓGICA!
NÃO EXISTE A EXPRESSÃO: SE IDADE < 18 OU > 85 ENTÃO
PARTE II
01) Faça um programa que classifique as máquinas conforme a produção de cabo para telefones. Veja a
tabela abaixo:
Produção
Classificação
maior ou igual a 60.000
“Boa”
menor que 60.000 e maior que 40.000
“Regular”
menor ou igual a 40.000
“Ruim”
Pseudocódigo
Início
Real quantpro;
Leia quantpro;
SE quantpro >= 60000 então
Escreva (“Produção Boa”);
SENÃO SE quantpro > 40000 então
Escreva (“Produção Regular”);
SENÃO
Escreva (“Produção Ruim”);
Fim
Linguagem C
#include <stdio.h>
#include <stdlib.h>
main()
{
Float quantpro;
printf(“\nDigite a quantidade produzida”);
scanf(“%f”,&quantpro);
if (quantpro >= 60000)
printf (“Produção Boa”);
else if (quantpro > 40000)
printf(“Produção Regular”);
else
printf(“Produção Ruim”);
}
02) A companhia de gás entrega a conta para seus consumidores no primeiro dia do mês. Se a conta for
paga até o 5º dia haverá um desconto de 5%. Se for paga entre o 6º e o 15º dia não haverá desconto. E
para contas pagas após o 15º será cobrada uma multa de 10%. Faça um programa que calcule o valor
pago pelo consumidor. Receba como dados de entrada o número de identificação do consumidor, o valor
da conta e o dia em que ela foi paga.
Pseudocódigo
Linguagem C
#include <stdio.h>
Início
Int numiden, datapag;
#include <stdlib.h>
Real valorcon; totalpag;
main()
Escreva (“Digite o número de identificação
{
do consumidor”);
Int numiden, datapag;
Leia (numiden);
Float valorcon; totalpag;
Escreva (“Digite o valor da conta:”);
printf (“Digite o número de identificação do
Leia (valorcon);
consumidor”);
Escreva (“Digite a data de pagamento”);
scanf (“%i”, &numiden);
Leia (datapag);
printf (“Digite o valor da conta:”);
scanf (“%f”, &valorcon);
SE datapag <= 5 então
printf (“Digite a data que pagou”);
Totalpag = valorcont – (valorcont* 0.05
scanf (“%i”, &datapag);
);
if (datapag <= 5)
SENÃO
Totalpag = valorcont – (valorcont* 0.05
SE datapag < = 15 então
);
Totalpag = valorcont;
else
SENÃO
Totalpag
=
valorcont
+
if (datapag < = 15)
(valorcont* 0.10 );
Totalpag = valorcont;
Escreva (“O total a pagar é “, totalpag);
else
Totalpag
=
valorcont
+
Fim
(valorcont* 0.10 );
printf (“O total a pagar é %.2f“, totalpag);}
03) Receba um número inteiro e classifique-o como negativo, positivo ou nulo. Essa classificação deverá
ser exibida por uma mensagem.
…
{
Início
Int numero;
Int numero;
Leia num;
scanf(“%i”, &numero);
SE numero = 0 então
if (numero = = 0)
Escreva (“Número Nulo”);
printf(“Número Nulo”);
SENÃO
else
SE numero > 0 então
if (numero > 0)
Escreva (“Número Positivo”);
printf (“Número Positivo”);
SENÃO
else
Escreva (“Número Negativo”);
printf(“Número Negativo”);
Fim
}
OU
Início
Int numero;
leia numero;
SE numero = 0 então
Escreva (“Número Nulo”);
SE numero > 0 então
Escreva (“Número Positivo”);
SE numero < 0 então
Escreva (“Número Negativo”);
Fim
{
Int numero;
scanf(“%i”, &numero);
if (numero = = 0)
printf(“Número Nulo”);
if (numero > 0)
printf (“Número Positivo”);
if (numero < 0)
printf(“Número Negativo”);
}
ESTRUTURA DE REPETIÇÃO
AULA 20
Laço (Loop)
Toda vez que você ler ou ouvir a palavra loop saiba que ela significa volta, igual o loop de uma
montanha russa, onde você gira, e gira e repete essa volta várias vezes. Então, loop na programação
significa repetição, iteração, volta a executar um procedimento já executado.
Pode ser feita a repetição de apenas uma instrução ou de um conjunto de instruções, podendo ser
ou não definida a quantidade de vezes que irá repetir.
Tome cuidado na hora da definição dos processos a serem repetidos. Se você quiser que a tela
seja limpa toda vez que for exibida uma mensagem; então a instrução para limpar a tela deve estar dentro
do corpo do loop, senão, a tela será limpa apenas uma vez.
A estrutura que aprenderemos a partir de agora é usada para tornar automática a repetição de um
programa inteiro ou apenas uma parte dele. Com a repetição automática os programas tornam-se mais
rápidos e ágeis, não existindo linhas de comandos idênticas repetidas.
A estrutura de repetição pode ser pré-definida com contador ou condicional.
Quando for repetido um trecho do programa e já se souber a quantidade de vezes que ele será
executado, então, você usará a estrutura de repetição pré-definida com contador. Um exemplo onde
podemos usar esta estrutura é num programa que faz o cadastramento dos trezentos funcionários de uma
empresa.
Mas, quando não é conhecido de antemão o número de vezes a ser repetido um conjunto de
instruções, então você usará a estrutura com condição. Essa estrutura consiste em executar as instruções
enquanto uma condição pré-definida for verdadeira.
Símbolo de repetição no fluxograma
Esse símbolo é usado para representar estruturas de repetição, sejam elas pré-definidas ou não.
Estrutura de Repetição Condicional
Estrutura de Repetição com Contador
Repita
C = de 1 a 300
Faça Enquanto
X > = 30
REPETIÇÃO PRÉ-DEFINIDA
(PARA..FAÇA)
AULA 21
Essa estrutura de repetição é usada quando é conhecida a quantidade de vezes em que um
determinado trecho (bloco) do programa será repetido. Um trecho pode ser formado por uma ou várias
instruções.
C
CONDIÇÂO
PARA <variável_controlevalor inicial> ATÉ <variável_controlevalor final> INC <incremento>
FAÇA
Instrução;
Variável de repetição ou Variável de controle ou Variável Contadora
É através dessa variável que se controla a repetição. Essa variável pode ser iniciada tanto com
valores negativos como positivos, dependendo da forma a ser feita a contagem, regressiva ou progressiva.
Na linguagem C podem existir diversas variáveis de controle e possui uma flexibilidade muito
grande para definir valores, condições e formas de incrementar essa estrutura de repetição.
Valor inicial: O valor inicial indica qual o primeiro valor a ser armazenado dentro da variável de
controle.
Valor final: É através desse valor que é determinado quando deve ser finalizada a repetição. Na
linguagem C o que existe no lugar do valor final é uma condição que é testada e quando se torna falsa
determina que o laço deva ser finalizado.
Incremento: O incremento define um valor que irá alterar o conteúdo da variável de controle
toda vez que for executado um laço.
Variável de repetição
Valor inicial
Valor final
Valor de Incremento
REPITA
N = 1, 20, 1
INSTRUÇÕES
PRÓXIMO N
INSTRUÇÕES
Exemplo:
Cadastre o número de identificação e salário dos dez novos funcionários contratados.
Início
Int numiden, cont;
Real valorsal;
PARA contl ATÉ cont=10 INC contcont +1 FAÇA
Início
Escreva (“Número de identificação do funcionário:”);
Leia (numiden);
Escreva (“Valor do salário:”);
Leia (valorsal);
Fim
Fim
Explicação:
•
No exemplo acima, é inicializada a variável de controle com o valor 1.
•
A seguir é executado o bloco de instruções, que contém a entrada do número de identificação
e valor do salário, pela primeira vez. No final da execução é automaticamente adicionado ao
conteúdo da variável de controle o valor 1 (anteriormente valia 1 mais 1 de agora, a variável
passa a ter o valor 2).
•
Depois é verificado o valor da variável com o valor final. Assim que o valor da variável de
controle atingir um valor fora do intervalo definido como valor final a repetição pára e será
iniciada uma nova seqüência de comandos definidos fora da repetição.
Obs.: Se forem definidos de início, o valor inicial e final iguais não haverá repetição.
O valor de incremento pode ser positivo ou negativo.
Linguagem C
#include <stdio.h>
#include <stdlib.h>
Condição de término da repetição:
main()
Repete até que o valor de cont fique maior que 10
{
int numiden, cont;
float valorsal;
for (cont=1;cont <=10;cont++)
{
printf (“Número de identificação do funcionário”);
scanf (“%i”, &numiden);
printf (“Valor do salário:”);
scanf (“%f”, &valorsal);
}
}
Estrutura em C
for (variável de controle = valor inicial; condição que define o fim do laço; valor do
incremento ou decremento)
instrução;
ou,
for (variável de controle = valor inicial; condição que define o fim do laço; valor do
incremento ou decremento)
{
instrução;
instrução;
}
Exemplos:
a) for (cont =1; cont <=10; cont ++)
printf(“Ordem crescente: %i”, cont);
b) for (cont =10; cont >=1; cont --)
{
printf(“Ordem decrescente: %i ”, cont);
system(“cls”);
}
Dicas:
•
O uso de mais de uma variável dentro do for deve ser feito com o uso da vírgula (,).
for (n1=1, n2=1; n1+n2 < 10; n1++, n2++)
•
Não é obrigatória a definição dos três parâmetros, podendo ser feito um laço infinito.
for ( ; ; ) printf(“Oi!”);
ESTRUTURA DE REPETIÇÃO CONDICIONAL
(ENQUANTO..FAÇA / FAÇA..ENQUANTO)
AULA 22
Essa estrutura de repetição é usada quando a quantidade de vezes um determinado trecho do
programa é desconhecida. Existe a repetição com pré-condição e pós-condição.
Repetição com Pré-condição
Neste tipo de estrutura de repetição, o bloco de instruções será repetido enquanto a condição
testada no laço for verdadeira. Quando ela se tornar falsa pára a repetição e o fluxo de execução passa
para a linha depois do laço.
Cuidado ao usar o Enquanto: Se na primeira vez a condição testada já for falsa, então, não
ocorrerá nenhuma vez a execução das instruções dentro do laço. Se faz necessária a validação da
condição, ou seja, torna-la verdadeira.
o da
daçã
Vali
ição
cond
Condição
N=3
ENQUANTO
N < =20
INSTRUÇÕES
Receber
N
INSTRUÇÕES
Enquanto .. Faça
Início
...
Instrução;
validação da condição;
ENQUANTO condição FAÇA
Instrução;
Fim
Obs:Estrutura que repete apenas uma
instrução
Estrutura em C
while (condição)
instrução;
Início
...
Instrução;
validação da condição;
ENQUANTO condição FAÇA
Início
Instrução;
Instrução;
Fim
Fim
Obs: Serão repetidas várias instruções, por isso
há a necessidade de haver um delimitador para o
início e fim do bloco de repetição.
Estrutura em C
while (condição)
{
Instrução1;
Instrução2;
...
Instrução n;
}
Repetição com Pós-condição
Na linguagem C existe o teste da condição no final da repetição:
Faça .. Enquanto
Nesta estrutura a repetição ocorrerá pelo menos uma vez e não é preciso validar a
condição.
Em algumas linguagens existe o teste da condição no final da repetição:
Repita..Até
Obs.: Essa estrutura é diferente da Faça..Enquanto, pois, a repetição será feita até que
seja satisfeita a condição. Não existe a validação da condição.
Exemplos de Pseudocódigo
a)
num  1;
enquanto (num >0) faça
início
...
fim
b)
c)
faça
início
....
fim
enquanto (num >0);
d) repita
início
....
até (num <0);
a)
num = 1;
while (num >0)
{
....
resp  ‘s’;
enquanto (resp = ‘s’) faça
Exemplos em C
b)
resp = ‘s’;
while (resp = ‘s’)
{
...
c)
do
{ ….
....
}while(num
>0);
}
}
Comandos Break e Continue
Esses comandos são usados para se fazer um desvio na execução. O break e o continue são
usados dentro de laços.
Break: pode ser usado para terminar um case(switch) ou para forçar o término de um laço.
Depois de encerrado o laço ele retorna para o comando seguinte fora do laço. No pseudocódigo é
ABANDONE
Continue: ele encerra apenas a iteração atual do laço, voltando ao início da repetição.
Faça um programa que receba as notas e faltas de 2 alunos. Faça a consistência da nota, alertando
quando for digitada uma nota inválida (menor que 0 ou maior que 10).
#include <stdio.h>
#include <stdlib.h>
main()
{
float cont=1, nota=0, falta;
while (cont <= 2)
{
printf("\nDigite a nota do aluno:");
scanf("%f", &nota);
if ((nota < 0) || (nota > 10))
{
printf("\nA nota digitada deve estar entre 0 e 10");
continue;
}
printf("\nDigite a frequencia do aluno:");
scanf("%f", &falta);
cont++;
}
system("pause");
}
VARIÁVEIS CONTADORAS E ACUMULADORAS
AULA 23
Variáveis Contadoras:
Variáveis Acumuladoras:
É o nome dado a uma variável numérica
que tem a função de "contar" valores,
ocorrências, ou mesmo, um determinado
fenômeno. Esse recurso de programação é usado
em programas de cadastro e pesquisa. Através
dessas variáveis é possível contar: o número de
pessoas cadastradas, o número de pessoas
obesas, o número de pessoas com Aids, o
número de mortes, o número de pessoas
alfabetizadas, o número de votos dos candidatos.
Para cada situação deve-se usar uma
regra, um procedimento. Quando se faz a
contagem de algum dado usa-se a variável
contadora, incrementando o seu conteúdo com o
valor 1. Mas, se houver a necessidade de
acumular o valor de uma variável, então, usa-se
a variável acumuladora, onde elas são
incrementadas não pelo valor 1 e sim pelo valor
de outra variável.
Cuidados:
Cuidados:
•
•
•
todas as variáveis contadoras
devem ser zeradas no início;
o
conteúdo
da
variável
contadora
deve
ser
incrementado com o valor 1;
para a variável contadora ser
incrementada várias vezes ela
deve ser colocada dentro do
laço.
Exemplos:
ContPessoas  ContPessoas + 1;
ContDoentes  ContDoentes + 1;
TotalMulheres  TotalMulheres + 1;
Variável Contadora = Variável contadora +
•
•
•
todas as variáveis acumuladoras
devem ser zeradas no início do
processo;
o conteúdo de uma variável
acumuladora
deve
ser
incrementado com o valor de
outra variável;
para a variável acumuladora ser
incrementada várias vezes ela
deve ser colocada dentro do
laço.
Exemplos:
TotalPeso  TotalPeso + Peso;
TotalAltura  TotalAltura + Altura;
Somanota  Somanota + Nota;
1
Variável Acumuladora = Variável acumuladora + valor de outra variável
FUNÇÕES
AULA 24
Sub-Rotinas (Módulos)
As sub-rotinas, também chamadas de módulos ou subprogramas, são trechos de instruções que
realizam tarefas específicas e que podem ser realizadas diversas vezes.
Ao ser decomposto um programa em subprogramas ou sub-rotinas este tem sua complexidade
também dividida. Desta forma é possível focalizar a atenção em um problema de cada vez, fazer os
programas ficarem mais organizados e menores.
As linguagens sem uso de sub-rotinas executam uma linha de código, ou uma instrução por vez,
até o final do programa. Dessa forma não é possível fazer desvios de execução.
Na linguagem C possibilita o uso de sub-rotinas por meio das funções. Na linguagem C existe a
função principal main(), que é sempre a primeira rotina executada, executando a partir desta as outras
rotinas. A linguagem C é formada por funções, como printf(), scanf(), system(), que são incluídas através
da diretiva #include (já explicada anteriormente).
Declaração da Função
tipo_de_retorno nome_da_função (tipo_de_parâmetro nome_do_parâmetro, ....)
{
declaração das variáveis locais;
corpo da função;
retorno;
}
O tipo_retorno especifica o tipo de valor (int, float) que a função retornará através do return. Os
tipos podem ser inteiros (int), reais (float), char (caracter) ou mesmo void (não retorna nada). Se não
especificado o tipo o compilador assume um retorno inteiro.
O nome_da_função é o identificador da função. Através dele é possível saber o que a função
executará, por exemplo, se a função for criada para fazer uma adição ela pode ser chamada de soma(). O
compilador procura pelo nome da função para fazer o desvio de execução.
A lista de parâmetros é separada por vírgula. O tipo_de_parâmetro e o seu nome são
respectivamente o tipo e o nome da variável que serão passados para a função. Uma função pode não
ter parâmetros.
O corpo da função contém todas as instruções que deverão ser executadas pela função. Ele deve
estar entre chaves { }. A chaves de abertura { marca o início da função e a chaves fechada } marca o
final da função.
As variáveis locais são variáveis declaradas dentro (internamente) da função onde serão usadas e
somente são conhecidas (visíveis) pela função que as criou. Uma variável local vem a existir quando
ocorre a entrada na função e ela é destruída ao sair da função.
Exemplo:
float media_notas (float nota1, float nota2)
{
float media;
media = (nota1+nota2)/2;
return media;
}
Protótipos de Funções
O protótipo da função foi acrescido com o padrão C ANSI. O protótipo da função deve ser usado
quando a função for definida após a função principal main(). Ele é um cabeçalho que indica ao
compilador a existência de uma função dentro do programa, podendo estar no meio ou no final.
Definição do Protótipo
tipo_de_retorno nome_da_função (tipo_de_parâmetro nome_do_parâmetro, ....)
Exemplo:
float media_notas (float nota1, float nota2);
main()
{
}
** Se a função for descrita no início do programa, antes da função principal main(), não precisa
ser feito o seu protótipo.
Chamada (ativação) da Função
A chamada de função existe quando há uma referência de uma função dentro do programa.
Durante o acionamento da função, o fluxo de execução é desviado para ele, e logo após sua conclusão, o
fluxo de execução retorna a linha de origem (a que o desviou).
Na linha de chamada da função pode haver o envio ou não de argumentos para outra função.
Esses argumentos são valores de variáveis, que podem ser usadas na outra função.
Não são definidos os tipos de dados dos argumentos, pois os mesmos são definidos no início da
função.
Exemplo:
float media_notas (float nota1, float nota2);
main()
{
float n1,n2,media;
media= media_notas (n1, n2);
…
}
n1 e n2
nota1 e nota2
são argumentos (enviam)
são parâmetros (recebem)
float media_notas (float nota1, float nota2)
{
....
}
Os argumentos enviados para a função devem ser compatíveis com os parâmetros, ou seja, se
foram enviadas duas variáveis (argumentos) – exemplo nota1 e nota2 – devem ser definidos na função a
ser executada duas variáveis (parâmetros) para estar recebendo os conteúdos das variáveis. Os tipos de
variáveis devem ser iguais, ou seja, se os dados enviados são inteiros, então a variáveis definidas para
recebê-los também devem ser inteiros.
Exemplo Completo de Função
#include <stdio.h>
#include <stdlib.h>
float media_notas (float nota1, float nota2);
//protótipo da função
main( )
{
float n1, n2, media;
printf("\n Este programa calcula a média de duas notas");
printf("\n\n Primeiro nota");
scanf("%f", &n1);
printf("\n\n Segunda nota");
scanf("%f", &n2);
media= media_notas (n1, n2);
printf("\n\n A média das notas é %.2f \n", media);
system("pause");
}
// início da função principal
float media_notas (float nota1, float nota2)
{
float media;
media = (nota1+nota2)/2;
return media;
}
// definição das variáveis locais
// chamada da função media_notas()
// fim da função principal
// declaração da função media_notas
// definição das variáveis locais
//retorna o resultado da média para a
função principal
// fim da função media_notas()
** A função media_notas() é do tipo float porque o retorno dela será uma variável do tipo float
(media).
** Os parâmetros (nota1 e nota2) são do tipo float porque seus respectivos argumentos (n1,n2) são
do tipo float.
Tipos de Variáveis
•
•
•
Variáveis Globais: São variáveis definidas fora de qualquer função específica, no início do
programa. Elas poderão ser manipuladas por qualquer função do programa.
Variáveis Locais: São variáveis declaradas dentro de uma função específica e são visíveis
apenas na função em que foram criadas. Funções distintas podem ter variáveis locais com o
mesmo nome.
Então, a variável local será visível apenas na função que a cria e a variável global será visível por
todas as funções existentes no programa.
Comando Return
Tem duas formas de uso:
•
ele provoca uma saída imediata das função que o contém, retornando ao código chamador.
•
devolve um valor
Tipo Void
•
•
•
Todas as funções que não devolvem valores devem ser declaradas como tipo void.
Quando uma função não tem parâmetros, deve ser colocado o void entre parênteses.
Quando não existe um retorno o tipo de função é void.
As funções podem ser usadas como rotinas de entrada, rotinas de criação de ela ou rotinas de
exibição de dados. Muitas rotinas são específicas e independem dos valores de variáveis de outras
rotinas, por isso o uso do tipo void na especificação das funções.
Exemplo:
void entrada(void);
main()
{
entrada();
....
system(“pause);
}
void entrada(void)
{
system(“cls”);
printf(“\n\n\n”);
printf(“<1> - Adição \n”);
printf(“<2> - Subtração \n”);
printf(“<3> - Multiplicação \n”);
printf(“<4> - Divisão \n”);
printf(“<5> - Sair \n”);
return;
}
O void no parâmetro é opcional.
O void na definição do tipo de função é obrigatório
Função com Passagem de Parâmetro por Valor
Quando uma função é chamada, os parâmetros dessa função copiam os valores dos argumentos
que são passados pela função que a chama.
Essa passagem de parâmetro é denominada Passagem de Parâmetros por Valor. Isto ocorre
porque são passados para a função apenas os valores dos parâmetros e não os próprios parâmetros.
Os valores dos argumentos não são alterados fora da função que os criou.
No exemplo abaixo vemos que o valor mostrado da variável num a primeira vez (na função
main()) é diferente do valor mostrado na função quadrado(), pois, são duas variáveis diferentes. O valor
da variável num é alterado na função quadrado(), mas permanece inalterada na função main().
Exemplo: Programa que calcula o quadrado de um número qualquer, usando função.
#include <stdio.h>
#include <stdlib.h>
float quadrado (float num);
//protótipo da função quadrado()
main()
{
float num, qd;
//declaração das variáveis locais
printf ("Entre com um numero: ");
scanf ("%f",&num);
printf ("Na função MAIN a variável num vale %.2f \n", num);
qd= quadrado(num);
//chama a função quadrado() e envia o
argumento num
printf ("O quadrado do %.2f é = %.2f\n",num, qd);
system(“pause”);
}
float quadrado(float num)
//declaração da função quadrado() e
do
{
parâmetro num
num = num*num;
printf ("Na função QUADRADO a variável num vale %.2f \n", num);
return num;
//retorna a função que a chamou
retornando um valor (num) que será
}
atribuído a variável qd.
** A função quadrado() é do tipo float porque o retorno dela será uma variável do tipo float (num).
** O parâmetro (num) é do tipo float porque o argumento (num) é do tipo float.
Exercícios Resolvidos
1) Faça uma função que calcule a soma de dois números recebidos na função principal.
#include <stdio.h>
#include <stdlib.h>
float soma (float a, float b);
// protótipo da função soma
main( )
// início da função principal
{
float n1, n2, total;
// definição das variáveis locais
printf("\n Este programa calcula a soma de dois números");
printf("\n\n Digite o valor do primeiro número");
scanf("%f", &n1);
printf("\n\n Digite o valor do segundo número");
scanf("%f", &n2);
total=soma(n1, n2);
// chamada da função soma()
printf("\n\n A soma de %.2f com %.2f é %.2f \n", n1, n2,total);
system("pause");
}
// fim da função principal
float soma (float a, float b)
{
float res;
res= a+b;
return(res);
}
// definição da função soma
// definição das variáveis locais
// retorna o resultado da soma dos
números enviados
// fim da função soma()
2) Elabore um programa que tenha as seguintes funções:
_ na função principal deve ser recebidas pedidas duas notas e feitas às chamadas de
funções.
_ uma função que receba a nota do aluno e faça a consistência;
_ uma função que calcule a média;
_ uma função que exiba o resultado, se o aluno está aprovado, reprovado ou em exame.
#include <stdio.h>
#include <stdlib.h>
float ler_nota(void);
/* protótipos das funções*/
float calcula_media(float p1, float p2);
void exibe_resultado(float med);
void pausa(void);
main()
{
float n1, n2, med;
printf("Primeira prova: ");
n1=ler_nota();
printf("Segunda prova : ");
n2=ler_nota();
med=calcula_media(n1, n2);
exibe_resultado(med);
pausa();
}
float ler_nota(void)
{
float n;
do
{
scanf("%f", &n);
if (n<0.0 || n>10.0)
printf("Número Inválido! Redigite..:");
}while (n<0.0 || n>10.0);
return(n);
}
float calcula_media(float p1, float p2)
{
float res;
res = (p1 + p2) / 2;
/* Calcula a média*/
return(res);
}
void exibe_resultado(float med)
{
printf("Media %.1f: ", med);
if (med < 3.0)
printf("Aluno reprovado\n");
else if (med >= 3.0 && med < 7.0)
printf("Aluno em exame\n");
else if(med >= 7.0)
printf("Aluno aprovado\n");
}
void pausa(void)
{
system(“pause”);
system(“cls”);
}
VETORES
Conceito
• Os vetores são matrizes unidirecionais homogêneas e podem ser chamadas de: arranjos
unidimensionais, variáveis indexadas, variáveis compostas homogêneas unidimensionais ou
arrays.
• O vetor é um mecanismo de estruturação de dados usado para representar variáveis do
mesmo tipo de dado, que são referenciados pelo mesmo nome.
• Um elemento específico é acessado por meio de um índice.
• O índice 0 contém o primeiro elemento armazenado.
• Consiste em locações contíguas de memória. O endereço mais baixo corresponde ao primeiro
elemento e o mais alto ao último.
• O vetor mais utilizado é o de caracteres (string).
• Os vetores são variáveis indexadas por apenas um índice (uma dimensão, unidimensional).
Exemplos:
float media[10];
2.5 4.5
6.5
3.5
char nome[4];
A
N
A
\0
int notas[4];
6
3
10
5
// vetor com 10 elementos do tipo real
10
8 7 5.5
6 8.5
// vetor com 4 elementos do tipo caracter (string)
//vetor com 4 elementos do tipo inteiro
Declaração:
A declaração de um vetor pode ser feita da seguinte maneira:
tipo_da_variável
nome_da_variável [tamanho];
Onde:
• tipo_da_variável é o tipo base do vetor (int, float, char, etc), ou seja, qual tipo de
conteúdo será armazenado na variável;
• tamanho_da_variável é a quantidade de elementos que o vetor armazenará.
Exemplo:
float medias[45];
- A linguagem C reservará 180 bytes (45 x 4), ou seja, são 45 variáveis do tipo
float, onde cada float ocupa 4 bytes. Estes bytes são reservados de maneira contígua.
Acessando os elementos
Cada elemento do vetor é um elemento individual, ou seja, seu conteúdo não está
vinculado com os outros. Para acessá-lo eu preciso de uma referência a mais do que somente seu
nome, é preciso saber onde se localiza o elemento dentro do vetor. Para isso acessamos os
elementos do vetor, individualmente, através de um índice.
Na linguagem C os índices iniciam no 0 e finalizam valendo o tamanho do vetor -1,
devendo ser colocados entre colchetes.
Exemplo: float media[10];
A primeira média será armazenada na posição 0 do vetor e a última será na posição 9;
0
2.5
1
4.5
2
6.5
3
3.5
4
10
5
8
6
7
7
5.5
8
6
9
8.5
media[0] acessa o primeiro elemento do vetor;
media[9] acessa o último elemento do vetor;
media[2] acessa o terceiro elemento do vetor;
Armazenando os elementos
Para ser feito o armazenamento no vetor é necessário de definir seu nome e em qual
posição deverá ser armazenada (qual índice). O armazenamento pode ser feito separadamente ou
em conjunto, de uma vez só. Veja os exemplos abaixo:
a)
b)
media[0] = 2.5;
ou
media[10]= {2.5,4.5,6.5,3.5,10,8,7,5.5,6,8.5}
media[1] = 4.5;
** Cuidado: Não se esqueça que o índice sempre inicia no 0.
Ao declarar um vetor você coloca o tamanho total.
Exemplos de Código de Programação
a) Recebendo elementos de um vetor do tipo inteiro digitados via teclado
for ( i=0; i<100; i++ )
{
printf(“Digite %i elemento do vetor”, i++);
scanf( “%i”, &vet[i] );
}
b) Mostrando os elementos de um vetor na tela:
for ( i=0; i<100; i++ )
printf( “%i”, vet[i] );
c) Inicializando um vetor com zeros
for ( i=0; i<100; i++ )
valores[i] = 0;
Exercícios Resolvidos:
1) Crie um vetor com 10 elementos do tipo inteiro e depois armazene automaticamente os
valores de 0 a 9.
# include <stdio.h>
#include <stdlib.h>
main()
{
int x[10];
int i;
for (i = 0; i < 10; i ++)
x [i] = i;
system(“pause”); }
//definição do vetor
//definição da variável para controlar o índice
//definição do laço para gerar o vetor
//atribuição do valor da variável i ao vetor x
2) Crie um vetor com 10 elementos do tipo inteiro e depois armazene automaticamente os
resultados da tabuada do número 2.
#include <stdio.h>
#include <stdlib.h>
main()
{
int r[10];
int t;
for(t=0;t<10;t++)
{
r[t]=t*2;
printf("%i\n",r[t]);
}
system("pause");
}
3) O professor de Programação de Computadores precisa de um programa que calcule a média
geral da sala, verificando dessa forma o desempenho dos alunos. O programa deve receber e
armazenar as notas dos 35 alunos e calcular a média geral da sala.
#include <stdio.h>
#include <stdlib.h>
main()
{
int notas[35],i,soma =0;
for(i=0;i<5;i++)
{
printf("Digite a nota do aluno %d: ",i);
scanf("%i",&notas[i]);
soma=soma+notas[i];
}
printf("Media das notas: %i.",soma/5);
system("pause");
}
VETOR STRING (CADEIAS DE CARACTERES)
AULA 22
Na linguagem C não existe o tipo de dado string, dessa forma é necessário criar um vetor
de caracteres para armazenar uma cadeia de caracteres (string).
Ao usar esse tipo de vetor deve-se tomar cuidado para o fato de que as strings têm o seu
último elemento como caracter null (\0). Para declarar a string, devemos declarar sempre um
elemento a mais para o terminador. Cada caracter é um elemento independente e pode ser
acessado de um índice.
Existem bibliotecas e funções especiais para o tratamento e manipulação de strings. O
cabeçalho padrão é string.h.
Exemplos de declaração e atribuição:
a) char nome[7];
b) nome = {‘b’,’i’,’a’,’n’,’c’,’a’};
d) char mensagem[10] = “Exemplo”;
Exemplo de Função de String
Função strlen() Retorna o tamanho da string
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
main()
{
char nome[40];
printf(“Digite seu nome: ”);
gets(nome);
printf(“O tamanho do nome é: %i\n”, strlen(str));
}
Função strcat() União de variáveis string
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
main()
{
char c, nome[40], sobrenome[15];
int i;
printf ("\nEntre com um nome: ");
scanf ("%s", nome);
printf ("\nEntre com um sobrenome: ");
scanf ("%s", sobrenome);
strcat(nome, " ");
strcat(nome, sobrenome);
printf ("\nO seu nome é %s \n", nome);
system ("pause");
}
Exemplos de Programas usando String:
1) Faça um programa que receba um texto e depois mostre quantas vogais foram digitadas.
#include <stdio.h>
#include <stdlib.h>
main()
{
char texto[10];
int vogais=0,t;
printf ("Digite um texto\n");
scanf("%s", texto);
for (t=0;t<10;t++)
{
if (texto[t] == 'a' || texto[t] == 'e' || texto[t] == 'i' || texto[t] == 'o' || texto[t] == 'u')
vogais++;
}
printf ("Total de vogais: %i\n", vogais);
system ("pause");
}
MATRIZ
AULA 23
Matriz Bidimensional
A linguagem C permite que seja declarada uma matriz bidimensional (variável composta
homogênea bidirecional) ou mesmo multidimensional.
Na matriz bidimensional o primeiro índice indica a linha e o segundo a coluna. Os índices
iniciam no zero(0). Para calcular o espaço de memória necessário para armazenar a matriz é
necessário fazer o seguinte calculo:
int pontos_jogos [2] [4];
qtd de linhas * qtd de colunas * qtd do tipo (inteiro)
tamanho = 2 * 4 * 2
tamanho = 16
Declaração:
A declaração de uma matriz bidimensional pode ser feita da seguinte maneira:
tipo nome [dimensão1] [dimensão2];
ou
tipo nome [linha] [coluna];
Exemplos:
1) char tabela[5][5];
2) int pontos_jogos [2] [4];
0
1
2
3
0
1
pontos_jogos [0,1]
pontos_jogos [1,3]
Armazenando os elementos
A inicialização e armazenamento de uma matriz pode ser individual ou coletivo. Como
nos exemplos abaixo:
•
•
•
•
•
pontos_jogos [0] [1] = 5;
pontos_jogos [1] [3] = 60
int i[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int quadrados[5][2] = {1, 1, 2, 4, 3, 9, 4, 16, 5, 25};
float nota[2][3] = {{9, 8, 7} , {6.5, 4, 2}};
Armazenamento feito via teclado
A leitura e armazenamento dos elementos de uma matriz via teclado deve ser usando uma
estrutura de repetição (laço). O for é o mais usado.
Supondo que a matriz foi declarada como: int mat [2] [3];
O laço da linha (1ª dimensão) inicia no 0 e finaliza no 1 e o laço da coluna (2ª
dimensão) inicia no 0 e finaliza no 2.
for (l=0; l<2; l++)
{
for (c=0; c<3; c++)
scanf (“%i”, &mat[ l ] [c ]);
}
Mostrando os elementos
for.
Para mostrar os valores armazenados dentro de uma matriz também é usada a estrutura do
Para exibir a matriz mat declarada acima.
for (l=0; l<2; l++)
{
for (c=0; c<3; c++)
printf (“%i”, mat [ l ] [c ] );
}
BIBLIOGRAFIA CONSULTADA
ASCENCIO, Ana F. G. e CAMPOS, Edilene A. V. Fundamentos da Programação de
Computadores. Ed. Pearson, 2002
CELES, Waldemar; CERQUEIRA, Renato e RANGEL, José L. Introdução a Estrutura
de Dados. Ed. Campus, 2004
FORBELLONE, A. L. V.; et.al. Lógica de Programação - A Construção de Algoritmos
e Estruturas de Dados. 2ª ed. Makron Books. 2000.
SCHILDT, Herbert. C Completo e Total. 3ª ed. Ed. Makron Books. 1996.
SENAI-SP. MDI. Tecnologia de Elaboração de Material Didático Impresso. São
Paulo, 1996
VILLAS, Marcos Vianna e VILLASBOAS, Luiz Felipe P. Programação: conceitos,
técnicas e linguagens. Rio de Janeiro, Ed. Campus, 1988