sumário · conceitos básicos de programação ... sacar dinheiro no banco 24 horas ... mensagem...
TRANSCRIPT
1
Introdução à Programação
IPRJ/UERJ Professora: Sílvia Mara
Sumário Conceitos básicos de programação .................................................................................................................................. 2
Etapas para o desenvolvimento de um programa: ....................................................................................................... 5
Uma visão geral de C ..................................................................................................................................................... 6
Identificadores: ............................................................................................................................................................. 9
Variável: ...................................................................................................................................................................... 10
Funções matemáticas ................................................................................................................................................. 14
Operadores ................................................................................................................................................................. 17
Comandos de Controle do Programa .............................................................................................................................. 19
1- Comandos de Seleção ............................................................................................................................................. 19
Comando if: ............................................................................................................................................................. 20
Estrutura switch/case: ............................................................................................................................................ 22
2- Comandos de Iteração ............................................................................................................................................ 23
2.1- O laço for .......................................................................................................................................................... 23
2.2- O laço while ...................................................................................................................................................... 25
2.3- O laço do-while ................................................................................................................................................ 26
3- Comandos de desvio ............................................................................................................................................... 28
Vetor ............................................................................................................................................................................... 30
Funções: .......................................................................................................................................................................... 32
Tipos de funções: ........................................................................................................................................................ 33
1- Funções sem passagem de parâmetro e sem retorno .................................................................................... 33
2- Funções com passagem de parâmetro e sem retorno ................................................................................... 34
3- Funções sem passagem de parâmetro e com retorno ................................................................................... 35
4- Funções com passagem de parâmetro e com retorno ................................................................................... 36
Protótipo de função: ................................................................................................................................................... 37
Passagem de parâmetros por valor: ........................................................................................................................... 37
Passagem de parâmetros por referência: ................................................................................................................... 39
2
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 antigo tinham memória cujo tamanho típico variam de 64k até
vários megabytes, onde 1 megabyte (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 descrevem uma tarefa a ser realizada por um
computador, escritas 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... Ex: de instrução de soma: ADD, M, N, P. Significa: adicione o número contido
3
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. Ex: suponha que desejamos adicionar dois números e depositar a soma em um terceiro número em linguagem C/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). 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.
Fases da compilação:
4
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 do 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.
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 – ferramenta do tipo descrição narrativa, fluxograma ou português estruturado
(pseudocódigo) são usados para descrever o problema com 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!!
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"); scanf("%d",&x); } Palavras-chave (ou palavras reservadas) da linguagem C:
7
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.
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 ( } ).
8
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 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 "Conteudo 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 "Conteudo 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:
%f: para variáveis que armazenam números reais; %d: para variáveis que armazenam números inteiros:
9
%c: para variáveis que armazenam um único caractere; %s: para variáveis que armazenam um conjunto de caracteres.
Expressões em C
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.
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.
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
10
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.
Forma geral de uma declaração:
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). - 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; 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");
11
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.
- 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:
12
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. O exemplo a seguir mostra uma função tecnicamente incorreta e que
pode não ser compilada em alguns compiladores:
Versões corretas:
/* Define j no início do bloco da função. */
void f(void) {
int i; int j; i=10;
j=10; }
Variáveis globais:
13
- 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:
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:
14
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: "Calculo de uma area". O C não possui formalmente um tipo de dado string.
E possível especificar precisamente o tipo da constante numérica por meio de um sufixo:
Tipo de dado Exemplos de constantes
int 1 223 25444 -34 long int 45333L -34L short int 10 -22 90
unsigned int 20000U 888U 4000 float 123.33F 4.34e-3F
double 123.33 -0.9856432 long double 2000.2L
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.
Funções matemáticas Exemplos de algumas funções matemáticas da biblioteca math.h:
15
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 argumento , onde é um double.
o double que representa o valor 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 .
16
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);
17
Operadores Classes de operadores definidas pelo C: aritméticos, relacionais, lógico e bit a bit.
Operadores aritméticos
Operador Exemplo Comentário
+ x + y Soma o conteúdo de x e de y.
- x - y Subtrai o conteúdo de x e de y.
* x * y Multiplica o conteúdo de x pelo conteúdo de y.
/ x/y Obtém o quociente de divisão de x por y. (y deve ser diferente de 0).
% x%y Obtém o módulo da divisão (resto) de x por y (obs: apenas para números inteiros)
+= x += y Equivale a x = x + y.
-= x -= y Equivale a x = x - y.
*= x *= y Equivale a x = x * y.
/= x /= y Equivale a x = x / y.
%= x %= y Equivale a x = x % y.
++ x++ Incremento. Soma 1 ao seu operando. Equivale a x = x + 1.
++ y= ++x Usado como prefixo. Equivale a x = x + 1 e depois y=x.
++ y= x++ Usado como sufixo. 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.
Observação: quando o operador / é aplicado a um inteiro, qualquer resto é truncado. Ex: 5/2
será igual a 2 em uma divisão inteira. Exemplo do operador / 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.*/
Exemplo dos operadores ++ e --:
x=10; y=++x; coloca 11 em y.
18
x=10; y=x++; coloca 10 em y. Nos dois casos, x recebe 11. A diferença está em quando isso acontece. A maioria dos compiladores C produz código-objeto para as operações de incremento e
decremento muito mais rápidas e eficientes comparado ao uso da sentença de atribuição equivalente.
Precedência dos operadores aritméticos:
Mais alta: ++ -- - (menos unário)
* / % Mais baixa: + -
Operadores do mesmo nível de precedência são avaliados pelo compilador da esquerda para a direita. Parênteses podem ser usados para alterar a ordem de avaliação, pois forçam
uma operação, ou um conjunto de operações, a ter um nível de precedência maior. 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.
19
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
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. Por exemplo:
!0 && 0 || 0 é falso
!(0 && 0) || 0 é verdadeiro LEMBRAR: TODA EXPRESSÃO RELACIONAL E LÓGICA PRODUZ COMO
RESULTADO 0 OU 1.
Exemplo de um fragmento de código:
int x; x=100; printf ("%d", x>10);
Imprimirá o número 1 na tela.
Comandos de Controle do Programa
1- Comandos de Seleção
C suporta dois tipos de comandos de seleção: if e switch.
20
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.
21
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.
22
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> void main()
{ int i;
23
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.
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
24
Forma geral: for (inicialização; condição; incremento) comando;
Permite muitas variações. A inicialização é, geralmente, um comando de atribuição que é usado para colocar um valor na variável de controle do laço.
A condição é uma expressão relacional que determina quando o laço acaba. O incremento define como a variável de controle do laço varia cada vez que o laço é
repetido. As três seções principais devem ser separadas por pontos-e-vírgulas (;). Uma vez que a condição se torne falsa, a execução do programa continua no comando
seguinte ao for.
Por exemplo: o programa a seguir imprime os números de 1 a 100 na tela:
Neste programa, x é inicialmente ajustado para 1. Como x é menor que 100, printf()
é executado e x é incrementado em 1 e testado para ver se ainda é menor ou igual a 100. Este processo se repete até que x fique maior que 100; nesse ponto, o laço termina. Neste
exemplo, x é a variável de controle do laço, que é alterada e testada toda vez que o laço se repete.
Exemplo de um laço for com múltiplos comandos:
Tanto a multiplicação de x por si mesmo como a função printf() são executadas até que x seja igual a 65. Neste caso o laço é executado de forma inversa: x é inicializado com
100 e será subtraído de 5 cada vez que o laço se repetir.
Nos laços for, o teste condicional sempre é executado no topo do laço, ou seja, o código dentro do laço pode não ser executado se todas as condições forem falsas logo no
início. Por exemplo, em:
o laço nunca executará, pois x e y já são iguais desde a sua entrada. Já que a expressão
condicional é avaliada como falsa, nem o corpo do laço nem a porção de incremento do laço são executados. Logo, y ainda tem o valor 10 e a saída é o número 10 escrito apenas uma
vez na tela.
25
/* 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.
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.
26
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 { commando;
}while (condição);
27
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:
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.
28
/* 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:
29
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 */
30
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.
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.
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)
31
O vetor chamado vet possui dez posições, começando pela posição 0 e indo até a
posição 9 (tamanho do vetor -1). Em cada posição poderão ser armazenados números
inteiros, conforme especificado pelo tipo int na declaração.
2)
O vetor chamado x possui cinco posições, começando pela posição 0 e indo até a
posição 4 (tamanho do vetor -1). Em cada posição poderão ser armazenados caracteres,
conforme especificado pelo tipo char na declaração.
OBS: em C/C++ não existe o tipo de dados string, como ocorre na linguagem Pascal.
Dessa forma, para poder armazenar em uma cadeia de caracteres, por exemplo, o nome
completo de uma pessoa, deve-se declarar um vetor de char, em que cada posição equivale
a um caractere ou a uma letra do nome. Toda vez que se faz uso de um vetor para
armazenar uma cadeia de caracteres, deve-se definir uma posição a mais que a
necessária para armazenar a marca de finalização de cadeia (\0).
Atribuição de valores ao vetor: É necessário informar em qual de suas posições o valor ficará armazenado.
Lembrando-se sempre que a primeira posição de um vetor em C/C++ tem índice 0.
vet[0]=1; atribui o valor 1 à primeira posição do vetor. x[3]='b'; atribui a letra b à quarta posição do vetor.
Preenchimento de um vetor:
Significa atribuir valores a todas as suas posições. Assim, deve-se implementar um
mecanismo que controle o valor do índice.
Exemplo:
for (i=0; i<10; i++) { printf(“\n Entre com o elemento %d do vetor:”, i); scanf(“%d”, &vetor[i]);
}
A estrutura de repetição for foi utilizada para garantir que a variável i assuma todos os valores possíveis para o índice do vetor (de 0 a 9). Assim, para cada execução da repetição,
será utilizada uma posição diferente do vetor.
Mostrar os elementos do vetor: Também exige a utilização do índice.
32
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)
{ printf(“\n O número %d é primo e encontra-se na posicao %d do vetor”, vet[i], i); }
} return 0;
}
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.
33
Os programas em geral são executados linearmente, uma linha após a outra, até o fim. Em geral, quando usamos sub-rotinas, é possível realizar desvios na execução dos
programas. Estes desvios são efetuados quando uma função e chamada pelo programa principal.
Modularização: recurso das linguagens de programação – particionar um programa em sub-rotinas bastante específicas.
Variáveis locais: variáveis declaradas dentro das sub-rotinas. Quando a execução desta
chega ao fim, essas variáveis são destruídas e seus conteúdos são perdidos. Variáveis globais: variáveis declaradas fora de qualquer sub-rotina. Qualquer ponto do
programa, incluindo as sub-rotinas, pode utilizá-las. Elas são destruídas quando a execução do programa chega ao fim.
Obs: não é aconselhável a utilização excessiva de variáveis globais, pois torna difícil a manutenção e a busca por erros nos programas.
Sub-rotinas em C (funções): Um programa escrito na linguagem C tem, no mínimo, uma função chamada main, que
indica o início da execução. Existe uma série de outras funções predefinidas, por exemplo: clrscr(), gets(), strcpy(), printf(), scanf(), pow(), etc. Estas funções são adicionadas aos
programas pela diretiva #include, no momento da “linkedição”. O usuário pode criar quantas funções quiser, dependendo do problema que estiver
sendo resolvido pelo programa.
As funções podem, quando houver necessidade, receber valores externos, chamados parâmetros, e também podem devolver algum valor produzido para o ambiente externo,
denominado retorno. Os parâmetros são representados por uma lista de variáveis colocadas dentro de parênteses, logo após o nome da função.
Caso haja retorno, a última linha da função deverá incluir o comando return, seguido do valor ou variável que será devolvido a quem chamou a função. O tipo do valor retornado
deverá ser exatamente igual ao tipo informado antes do nome da função. A palavra void deverá ser digitada caso a função não retorne valor.
Tipos de funções:
1- Funções sem passagem de parâmetro e sem retorno
Tipo mais simples de função, pois não recebe nenhuma informação no momento de sua chamada e também não repassa nenhum valor para quem a chamou.
Exemplo: Função que leia dois números e execute a soma entre eles.
1 #include <stdio.h> 2 #include <conio.h> 3 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;
34
11 printf(“\n Soma=%d”, soma); 12 getch();
13 } 14 void main() 15 { 16 soma(); 17 }
Explicação do programa:
- A execução sempre começa pela função main. A execução se inicia na linha 14. - Na linha 16, existe uma chamada à função soma, onde o fluxo da execução é
desviado para a linha 3. Depois são executadas as linhas 4 até a 12. Quando a execução atinge a linha 13, a marca de final da função é encontrada. Neste momento, o fluxo da
execução retorna para a linha 17, exatamente abaixo de onde ocorreu o desvio para a função soma.
- Na linha 17 está a marca de finalização da função main, e o programa é concluído.
Obs.1: no momento em que a função soma foi chamada, na linha 16, nenhum valor ou
variável foi colocado entre parênteses, indicando que não houve passagem de parâmetros. Obs.2: dentro da função soma não foi utilizado o comando return, indicando que ela
não retornou nenhum valor para quem a chamou, logo, o seu tipo é void.
Exemplo: Faça uma sub-rotina que leia cinco valores inteiros, determine e mostre o
maior e o menor deles. #include <stdio.h> #define TAMANHO 5 void verifica () { 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
35
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> 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>
36
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; 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 {
37
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); 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.
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.
Passagem de parâmetros por valor:
Significa que a função trabalhará com cópia dos valores passados no momento de sua chamada.
38
Exemplo:
1 #include <stdio.h> 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 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.
39
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> 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:
40
- 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).
- 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.
41
Resultado da execução:
Exemplos:
1) Faça uma sub-rotina que receba um vetor A de dez elementos inteiros como
parâmetro. Ao final dessa função, deverá ter sido gerado um vetor B contendo o fatorial de cada elemento de A. O vetor B deverá ser mostrado no programa principal.
#include <stdio.h> 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]);
42
} 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[]);
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++)
43
{ 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[]);
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