Embed Size (px)
Citation preview
Introdução à Programação IPRJ/UERJ
Professora: Sílvia Campos
Sumário 1- Conceitos básicos de programação .......................................................................................................................... 2
1- Etapas para o desenvolvimento de um programa ................................................................................................ 5
2- Tipos de algoritmos (os mais usados) ................................................................................................................... 6
3- Uma visão geral de C ............................................................................................................................................. 9
4- Identificadores .................................................................................................................................................... 12
5- Variável ............................................................................................................................................................... 12
6- Funções matemáticas ......................................................................................................................................... 17
7- Operadores ......................................................................................................................................................... 19
8- Lista de Exercícios 1 ............................................................................................................................................ 22
2- Comandos de Controle do Programa ......................................................................................................................... 24
1- Comandos de Seleção ............................................................................................................................................. 24
1.1- Comando if .................................................................................................................................................. 24
1.2- Estrutura switch/case ................................................................................................................................. 26
1.3- Lista de Exercícios 2 .................................................................................................................................... 28
2- Comandos de Iteração ............................................................................................................................................ 30
2.1- O laço for .......................................................................................................................................................... 30
2.2- O laço while ...................................................................................................................................................... 31
2.3- O laço do-while ................................................................................................................................................ 32
3- Comandos de desvio ............................................................................................................................................... 34
3.1 - O comando return ........................................................................................................................................... 34
3.2 - O comando break ............................................................................................................................................ 34
3.3 - O comando continue....................................................................................................................................... 35
4- Lista de Exercícios 3 ............................................................................................................................................ 36
3- Vetor ....................................................................................................................................................................... 37
3.1- Atribuição de valores ao vetor ............................................................................................................................. 38
3.2- Preenchimento de um vetor ................................................................................................................................ 38
3.3- Exibição dos elementos do vetor ......................................................................................................................... 39
3.4- Lista de Exercícios 4 ............................................................................................................................................. 40
4- Funções ....................................................................................................................................................................... 41
4.1- Tipos de funções .................................................................................................................................................. 42
4.2- Protótipo de função ............................................................................................................................................. 46
1
4.3- Passagem de parâmetros por valor ..................................................................................................................... 46
4.4 - Passagem de parâmetros por referência ............................................................................................................ 47
4.5 - Lista de Exercícios 5 ............................................................................................................................................ 51
2
1- 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.) O tamanho da memória de um computador é normalmente expresso como algum
múltiplo de 210 = 1.024 bytes. Esse número (1.024) é chamado de 1k (1 Kylobyte). Computadores pequenos mais antigos tinham memória cujo tamanho típico varia de 64k até
vários megabytes, onde um megabyte (1 MB) equivale a 210 x 210= 1.024 kbytes. Atualmente as memórias são expressas em Gigabytes (GB), onde 1 GB = 1.024 Mbytes. Existem vários tipos de memória. A memória de acesso aleatório (RAM) é um tipo de
memória que permite a leitura e a escrita e é onde basicamente ficam armazenados os programas básicos operacionais.
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...
3
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ções sã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 b representam 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 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. 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.
4
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-6 segundos) 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.
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.
5
Exemplo: Um computador foi programado para calcular a área de um círculo utilizando a
fórmula . 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. 2. Calcular o valor da área, 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 e a área correspondente.
Cada um desses passos exigirá uma ou mais instruções de um programa.
1- 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:
Procedimento para contar:
Passo 1: Faça igual a zero
Passo 2: Some 1 a .
Passo 3: Volte ao passo 2
Não satisfaz a condição 3 de um algoritmo correto!!! Exemplos de algoritmos corretos:
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.
Satisfaz as três condições!!!
2) Somar três números
6
Passo 1 - Receber os três números. Passo 2 - Somar os três números.
Passo 3 - Mostrar o resultado obtido.
3) 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!!
2- 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:
3- Pseudocódigo (pseudolinguagem): utiliza regras pré-definidas que facilitam a passagem do algoritmo para qualquer linguagem de programação.
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:
7
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.
1- Algoritmo em descrição narrativa: PASSO 1- Receber os dois números que serão divididos.
PASSO 2- Se o segundo número for zero, não poderá ser feita a divisão, pois não existe divisão por zero; caso contrário, dividir os números.
PASSO 3 - Mostrar o resultado da divisão. 2- Algoritmo em fluxograma
8
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. 1- Algoritmo em descrição narrativa:
PASSO 1 - Receber as duas notas.
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; caso contrário, 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
9
ESCREVA "Média = ", Media SE M >=7
ENTÃO ESCREVA "Aprovado" SENÃO ESCREVA "Reprovado"
FIM_ALGORITMO.
3- 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. 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:
if (x<10) { printf("Número muito pequeno\n"); printf(“Digite novamente\n"); scanf("%d", &x); }
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. Função main(): precisa estar presente em todos os programas - primeira função a ser
chamada quando a execução do programa começa.
10
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.
Forma geral de uma programa em C (onde f1() a fn() são funções definidas pelo usuário):
#include <nome_da_biblioteca> declarações globais tipo_devolvido main (lista de parâmetros) { Sequência de comandos }
tipo_devolvido f1 (lista de parâmetros) { Sequência de comandos } tipo devolvido f2 (lista de parâmetros) { Sequência de comandos } ... tipo devolvido fn (lista de parâmetros) { Sequência de comandos } Obs: um bloco de código inicia-se em abre-chaves ( { ) e termina em fecha-chaves ( } ).
Exemplo de um programa em C: #include <stdio.h> //Biblioteca padrão de entrada e saída. main() { printf ("Hello IPRJ\n"); //Exibe a sequência de caracteres; \n representa o caractere de nova linha. }
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 (;)
Comandos de entrada
- São usados para receber dados digitados pelo usuário. - 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. (Apenas para C++).
gets(nome); Um ou mais caracteres digitados pelo usuário serão armazenados
11
na variável nome.
scanf("%d",&x); Um valor digitado pelo usuário será armazenado na variável x.
- O comando gets deve ser usado quando se deseja digitar uma cadeia contendo espaços em branco. Ex: Maria Jose. - O comando cin consegue armazenar os caracteres até que seja encontrado o
primeiro espaço em branco (os caracteres posteriores são descartados). Ex: Maria. - Os comandos gets e scanf: armazenam toda a cadeia até que seja pressionada a
tecla ENTER. (Necessário incluir a biblioteca stdio.h, ou seja, #include <stdio.h>) Comandos de Saída
- São usados para mostrar dados na tela ou na impressora. Exemplos:
Comando Definição
cout << x; Mostra o valor armazenado na variável x. Apenas para C++
cout << "Conteudo de x = ", << x; Mostra a mensagem "Conteúdo de x= " e em seguida o valor armazenado na variável x.
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 utilizando cinco
casas para a parte inteira e duas casas decimais.
No comando printf é necessário indicar o tipo de variável que será mostrada. Tipos mais comuns:
%f: para variáveis que armazenam números reais; %d: para variáveis que armazenam números inteiros:
%c: para variáveis que armazenam um único caractere; %s: para variáveis que armazenam um conjunto de caracteres.
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:
12
4- 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.
Não podem ser usadas palavras reservadas, ou seja, palavras que pertençam a uma 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
5- 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.
13
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.
Forma geral de declaração de variável:
tipo lista_de_variáveis;
onde tipo deve ser um tipo de dado válido em C e 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. float X;
Declara uma variável chamada X em que pode ser armazenado um número real.
unsigned int x; Declara uma variável em que podem ser armazenados 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.
Comando de atribuição:
- Utilizado para conceder valores ou operações a variáveis. Representado por = (sinal
de igualdade). Exemplos: x = 4;
14
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;
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.
15
- 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:
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 ser declaradas 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; ... }
Variáveis globais:
- 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, independente 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 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.
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
17
double 123.33 -0.9856432 long double 2000.2L
Constantes caractere de barra invertida. Ex:
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.
6- 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 maior que x. Ex: ceil (3.2) é 4.
Retorna o menor inteiro maior que . Embora inteiro, o valor é retornado como double.
Calcula o maior valor inteiro menor que x. Ex: floor (3.2) é 3.
Retorna o maior inteiro menor que . Embora inteiro, o valor é retornado como double.
Calcula o cosseno de ( em radianos).
O cosseno do arco , um valor no intervalo [-1,+1].
Calcula o seno de ( em radianos).
O seno do arco , um valor no intervalo [-1,+1].
Calcula a tangente de ( em radianos).
O valor da tangente do arco x como um número de dupla precisão (double).
Calcula o valor absoluto do argumento , onde é um inteiro.
O inteiro que representa o valor absoluto do argumento .
Calcula o valor absoluto do O double que representa o valor
18
argumento , onde é um double.
absoluto do argumento .
Obtém o logaritmo natural elevado à potência .
O valor de em precisão dupla.
Obtém o logaritmo natural de (logaritmo neperiano).
O valor de em precisão dupla.
Obtém o logaritmo de base 10 de (logaritmo decimal). o valor de deve ser positivo. Se , então
O valor de em precisão dupla.
Calcula a parte fracionária de e coloca a parte inteira em .
Retorna o valor da parte fracionária de x em dupla precisão.
Calcula a potência . Se ou for 0, o resultado é 0. Se qualquer um dos dois for negativo, pode ocorrer um erro.
O valor de em dupla precisão.
Calcula a raiz quadrada de , isto
é
.
O valor da raiz quadrada de em dupla precisão (double).
Constante que define o valor de
O valor de .
19
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.415; 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);
7- 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.
20
Equivale a x = x + 1 e depois y=x.
++ y= x++ Usado como sufixo. 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: + -
21
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. 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
Ambos os operadores são menores em precedência do que os 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
22
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
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); Conversão de tipo:
A conversão de tipo é automática na avaliação de uma expressão e pode ser requisitada explicitamente. Exemplo:
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 “%” */
8- Lista de Exercícios 1
1) Suponha que:
a = 3 b = a / 2
c = b + 3.1 Qual é o valor de c? Defina as variáveis a, b e c para obter as possíveis respostas:
c=4.6 c=4.1
c=4 Faça um programa que...
2)
23
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.
Exibir o resultado conforme abaixo (exemplo 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. que receba o raio, calcule e mostre:
a) o comprimento de uma esfera; sabe-se que ;
b) a área de uma esfera; sabe-se que ;
c) o volume de uma esfera; sabe-se que
.
11. receba uma temperatura em Celsius, calcule e mostre essa temperatura em
Fahrenheit. Sabe-se que . 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. recebe quatro nomes e quatro notas e produza a seguinte saída na tela:
ALUNO(A) NOTA
======= =====
MARIA 9.0
JOÃO 7.5
ANTÔNIO 5.6
SILVANA 8.5
24
2- Comandos de Controle do Programa
1- Comandos de Seleção
C suporta dois tipos de comandos de seleção: if e switch.
1.1- Comando if
Estrutura condicional simples: 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.
if (condição) {
comando1; comando2; comando3;
}
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 composta:
if (condição)
comando1; else comando2;
Se a condição for verdadeira, será executado o comando1; caso contrário, será
executado o comando2. 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.
25
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) */
A construção if-else-if:
if (expressão1)
comando_1; else if (expressão2) comando_2;
else if (expressão3) comando_3;
... else comando;
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.
26
1.2- 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. 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>
27
void 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(); }
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.
28
1.3- Lista de Exercícios 2
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 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:
29
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:
9) resolva equações do 2o. 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.
30
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 pre-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
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:
31
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.
/* Calcular a media de n numeros */ #include <stdio.h> void main() { int n, cont; //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 */ for (cont=1 ; cont <= n ; ++cont) { printf("x = "); scanf("%f", &x); soma += x; //soma: variável usada como um acumulador } /*Calcular a media e imprimir a resposta */ media = soma/n; printf("\nA media = %f\n", media); }
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.
Exercício: reescrever os códigos acima escritos com o laço for usando o laço while.
O exemplo seguinte mostra uma rotina de entrada pelo teclado que se repete até que o usuário digite A.
32
Primeiro, ch é inicializado com nulo. Como uma variável local, seu valor não é conhecido quando wait_for_char() é executado. 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 */ #include <stdio.h> void main() { int digito=0; while (digito <= 9) printf("%d\n", digito++); } /* Calcular a media de n numeros */ #include <stdio.h> void 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 */ while (cont <= n) { printf("x = "); scanf("%f", &x); soma += x; ++ cont; } /*Calcular a media e imprimir a resposta */ media = soma/n; printf("\nA media = %f\n", media); }
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.
Forma geral:
do { comando;
33
}while (condição);
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> void main() { int digito=0; do { printf("%d\n", digito++); } while (digito <= 9); } 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:
34
Aqui, o laço do-while foi uma boa escolha, porque você sempre deseja que uma função do menu execute 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 media de n numeros */ #include <stdio.h> void 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("\nA media = %f\n", media); }
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. 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:
35
Escreve os números de 1 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 numeros nao-negativos de uma lista de numeros */ #include <stdio.h> void 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 */
36
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; printf("\nA media = %f\n", media); }
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.
4- Lista de Exercícios 3
Faça um programa que... 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:
- 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.
37
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) calcule a área de um triângulo, e que não permita a entrada de dados inválidos, ou seja, medidas menores ou iguais a 0.
5) receba um número, calcule e mostre a tabuada desse número.
6) mostre as tabuadas dos números de 1 a 10.
7) Uma loja utiliza o código V para transação à vista e P para transação à 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, 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 metro; - 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) 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 ... ...
3- Vetor
Definição: variável composta homogênea unidimensional – conjunto de variáveis de mesmo tipo, 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.
38
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.
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).
3.1- 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.
3.2- 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.
39
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.
3.3- Exibição dos elementos do vetor
Também exige a utilização do índice.
Exemplo:
for (i=0; i<10; i++) { 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 int main () { int vet[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:
for (i=0; i<TAMANHO; i++) { cont=0; //Verificação dos números primos: for (var=1; var<=vet[i]; var++)
{ if (vet[i]%var==0) cont ++;
} if (cont==2)
{
40
printf(“\n O número %d é primo e encontra-se na posicao %d do vetor”, vet[i], i); }
} return 0;
}
3.4- Lista de Exercícios 4
Faça um programa que:
1- Preencha um vetor com 70 números inteiros, calcule e mostre os números primos e suas
respectivas posições.
2- Preencha um vetor com 8 números inteiros, calcule e mostre dois vetores resultantes. O primeiro
vetor resultante deve conter os números positivos; o segundo vetor deve conter os números
negativos. Cada vetor resultante vai ter, no máximo, 8 posições, que poderão não ser
completamente utilizadas.
3- Preencha dois vetores, X e Y, com dez números inteiros cada. Calcule e mostre os seguintes vetores
resultantes:
- A soma entre X e Y (soma de cada elemento de X com o elemento de mesma posição em Y).
- O produto entre X e Y (multiplicação de cada elemento de X com o elemento de mesma posição
em Y).
4- 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
nessa condição.
5- 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.
6- Leia um vetor com 80 posições para números reais e, depois, um código inteiro. Se o código for 0,
finalize o programa com uma mensagem; se for 1, mostre o vetor na ordem direta; se for 2, mostre
o vetor na ordem inversa.
7- Gere os dez primeiros números primos acima de 100 e armazene-os em um vetor. Escreva no final
o vetor resultante.
41
8- 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.
9- 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.
10- 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.
11- Leia um vetor com quinze números inteiros. Depois da leitura, divida todos os seus elementos pelo
maior valor do vetor. Mostre o vetor após os cálculos.
12- Preencha dois vetores de 4 elementos numéricos cada um e mostre o vetor resultante da
intercalação deles.
Vetor 1
1 4 8 9
0 1 2 3
Vetor 2
10 14 6 7
0 1 2 3
Vetor resultante da intercalação
1 10 4 14 8 6 9 7
0 1 2 3 4 5 6 7
4- 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.
42
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.
4.1- 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 void soma() 4 { 5 int num1, num2, soma; 6 printf(“\n Digite o primeiro numero:”); 7 scanf(“%d”, &num1); 8 printf(“\n Digite o segundo numero:”); 9 scanf(“%d”, &num2); 10 soma = num1 + num2; 11 printf(“\n Soma=%d”, soma); 12 getch();
13 } 14 void main() 15 { 16 soma(); 17 }
43
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 () { int vet[TAMANHO], maior, menor, i; //Entrar com os valores do vetor:
for (i=0; i<TAMANHO; i++) { printf(“\nEntre com o valor da posicao %d: ”, i); scanf(“%d”, &vet[i]);
} maior = vet[0]; menor= vet[0]; for (i=0; i<TAMANHO; i++) {
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);
} int main() { verifica(); return 0; }
2) Funções com passagem de parâmetro e sem retorno
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.
1 #include <stdio.h> 2 #include <conio.h>
44
3 void calcula_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 void main() 11 { 12 int num1, num2; 13 printf(“\n Digite o primeiro numero:”); 14 scanf(“%d”, &num1); 15 printf(“\n Digite o segundo numero:”); 16 scanf(“%d”, &num2); 17 calcula_media(num1, num2); 18 }
Explicação do programa:
- 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.
1 #include <stdio.h> 2 #include <conio.h> 3 float multiplicacao () 4 { 5 float multiplicando, multiplicador, produto; 6 printf(“\n Digite o valor do multiplicando:”); 7 scanf(“%f”, &multiplicando); 8 printf(“\n Digite o valor do multiplicador:”); 9 scanf(“%f”, &multiplicador); 10 produto = multiplicando * multiplicador;
45
11 return produto; 12 }
13 void main 14 { 15 float resposta; 16 resposta = multiplicacao (); 17 printf(“\n O produto = %f”, resposta); 18 getch() 19 }
Explicação do programa: - 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.
1 #include <stdio.h> 2 #include <conio.h> 3 float divisao (float dividendo, float divisor) 4 { 5 float q; 6 q = dividendo / divisor; 7 return q; 8 }
9 void main () 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); 18 resposta = divisao(n1, n2);
46
19 printf(“\n O resultado da divisao = %f”, resposta); 20 getch(); 21 }
Explicação do programa:
- 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.
4.2- 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.
float divisao (float dividendo, float divisor); //Esta linha descreve o protótipo da função.
4.3- Passagem de parâmetros por valor Significa que a função trabalhará com cópia dos valores passados no momento de sua
chamada.
Exemplo:
1 #include <stdio.h> 2 #include<conio.h> 3 int soma_dobro (int a, int b); 4 void main() 5 {
47
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 int soma_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:
Explicação do programa:
- 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.
4.4 - 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:
1 #include <stdio.h>
48
2 #include<conio.h> 3 int soma_dobro (int *a, int *b); 4 void main() 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 int soma_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:
Explicação do programa:
- 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 ponteiro 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).
49
- 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_dobro chega 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.
Resultado da execução:
50
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> void fatVet (int vet1[], int vet2[]); int main() { int vetA[10], vetB[10], i; //Entrar com os valores do vetor
for (i = 0 ; i < 10 ; i++) {
do { printf(“\nEntre com o valor da posicao %d: ”, i); scanf(“%d”, &vetA[i]); } while (vetA[i]<0);
} fatVet(vetA, vetB); //Mostra o vetor B resultante
for (i=0; i<10; i++) { printf (“\n O fatorial de %d = %d”, vetA[i], vetB[i]);
} return 0; } void fatVet (int vet1[], int vet2[]) { int fat, 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: void fatVet (int vet1[]);
51
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> void ordenaVet (float vet[]); int main() { float vetA[10]; int i; //Entrar com os valores do vetor:
for (i = 0 ; i < 10 ; i++) {
printf(“\nEntre com o valor da posicao %d: ”, 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]); }
}
void ordenaVet(float vet[]) { int i, j; float temp; 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; }
} } }
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 (int vetX[], int vetA[], int vetB[]);
4.5 - Lista de Exercícios 5
1) Faça um programa contento uma sub-rotina que retorne 1 se o número digitado for
positivo ou 0 se for negativo.
52
2) Faça um programa que receba dois números positivos por parâmetro e retorne a soma dos N números existentes entre eles.
3) 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.
4) 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).
5) 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.
6) Faça uma sub-rotina que leia cinco valores inteiros, determine e mostre o maior e o menor deles.
7) Crie uma sub-rotina que receba como parâmetro um valor inteiro e positivo N e retorne o valor de S, obtido pelo seguinte cálculo:
8) 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.
9) Faça uma sub-rotina que receba como parâmetro o raio de uma esfera, calcule e
mostre no programa principal o seu volume:
.
10) Faça uma sub-rotina que receba um valor inteiro e positivo, calcule e mostre o seu
fatorial.
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 o fatorial de cada elemento 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 crescente. 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 deve conter os elementos de X que sejam maiores que zero e o vetor B, os elementos menores ou iguais a zero.
53
14) Elabore uma sub-rotina que receba um vetor X de 15 números inteiros como
parâmetro e retorne a quantidade de valores pares em X.
15) Faça uma sub-rotina que receba um vetor X de 20 números reais e retorne a multiplicação dos elementos de X maiores que 100.
Referência:
Livros:
1- C completo e total. Herbert Schildt. Makrom Books.
2- The C programming Language
Brian W. Kernighan, Dennis M. Ritchie Prentice Hall.
3- Fundamentos da Programação.
Ascencio, Ana/Campos, Edilene. http://wps.prenhall.com/br_ascencio_2/77/19865/5085520.cw/index.html
