Apostila de Funções em C

FUNÇÕES

DISCIPLINA DE TÉCNICAS DE

PROGRAMAÇÃO

Prof.ª M.ª Eng.ª Elaine Cecília Gatto

Cornélio Procópio-PR

2017

Ministério da Educação

UNIVERSIDADE TECNOLÓGICA FEDERAL DO PARANÁ

Campus Cornélio Procópio

2

LISTA DE CÓDIGOS FONTE

Listagem 1: Código Fonte do arquivo C. ................................................................................................... 10

Listagem 2: Exemplo de programa usando funções sem parâmetros e sem retornos. ........................ 17

Listagem 3: Exemplo de programa usando funções sem parâmetros com retorno. ............................ 23

Listagem 4: Exemplo de programa usando funções com parâmetros sem retorno. ............................ 28

Listagem 5: Código Fonte .......................................................................................................................... 32




3

LISTA DE TABELAS

Tabela 1: Funções sem e com Parâmetro, mas Sem Retorno ............................................................................ 12

Tabela 2: Funções com e sem parâmetros, mas com retorno. .......................................................................... 12

Tabela 3: Teste de mesa para leitura e subtração .................................................................................................. 24

Tabela 4: Teste de Mesa ................................................................................................................................................... 28

Tabela 5: Teste de Mesa ................................................................................................................................................... 32




4

LISTA DE FIGURAS

Figura 1: Divisão do Escopo de Programa ................................................................................................................... 7

Figura 2: Código Fonte da Biblioteca ............................................................................................................................. 8

Figura 3: Estrutura de Pastas no Codeblocks .......................................................................................................... 10

Figura 4: Chamadas e Retornos das Funções entre os arquivos SOURCE e HEADER. ............................. 11

Figura 5: Sequência de Chamadas e Retornos das Funções ............................................................................... 17

Figura 6: Pilha de Execução ............................................................................................................................................ 18

Figura 7: Fluxograma de Chamadas e Retornos de Funções ............................................................................. 24

https://d.docs.live.net/66cd8efac71992ae/UTFPR/Disciplinas/ADS/Ténicas%20de%20Programação/2017-01/Apostila%20de%20Funções%20UTFPR.docx#_Toc479186291

https://d.docs.live.net/66cd8efac71992ae/UTFPR/Disciplinas/ADS/Ténicas%20de%20Programação/2017-01/Apostila%20de%20Funções%20UTFPR.docx#_Toc479186292




5

SUMÁRIO

A. INTRODUÇÃO ..................................................................................................................................................................... 6

1. Objetivo ............................................................................................................................................................................ 6

2. Escopo ............................................................................................................................................................................... 6

2. Bibliotecas ....................................................................................................................................................................... 6

3. Variáveis ....................................................................................................................................................................... 10

4. Protótipos de Funções ............................................................................................................................................. 11

5. Programa Principal ................................................................................................................................................... 13

B. FUNÇÃO SEM PARAMETRO E SEM RETORNO ................................................................................................... 14

C. FUNÇÃO SEM PARAMETRO E COM RETORNO ................................................................................................... 19

1. Visualizando a passagem de parâmetro ........................................................................................................... 23

D. FUNÇÃO COM PARAMETRO E SEM RETORNO .................................................................................................. 25

E. FUNÇÃO COM PARAMETRO E COM RETORNO .................................................................................................. 29

F. Funções e Ponteiros ...................................................................................................................................................... 33

G. Funções e Arrays ............................................................................................................................................................ 34

H. Funções e Strutus .......................................................................................................................................................... 35

I. Tipos de Funções ............................................................................................................................................................. 36

1. Funções do Tipo INT ................................................................................................................................................ 36

2. Funções do Tipo FLOAT .......................................................................................................................................... 36

3. Funções do Tipo Char .............................................................................................................................................. 36

3. Funções do Tipo Booleano ..................................................................................................................................... 36




6

A. INTRODUÇÃO

1. Objetivo

Uma Função tem como objetivo realizar uma tarefa específica, realmente muito específica.

Por exemplo, somar dois números, solicitar dados para um usuário, etc. Neste Tutorial, uma

calculadora será desenvolvida em C, usando a IDE CODEBLOCKS, que demonstrará a construção de

um programa completo usando FUNÇÕES e, mostrando os diferentes tipos de FUNÇÕES que podem

ser implementadas.

2. Escopo

Os arquivos de programas são divididos em várias partes, o que é chamado de ESCOPO, isto

é, o contexto de execução de cada parte do programa e a comunicação de cada um deles com outras

partes do programa, conforme ilustra a Figura 1. Antes de mais nada, é preciso entender o que

significa Escopo Global e Escopo Local. Os recursos que podem ser usados em TODO o arquivo de

código fonte fazem parte do Escopo Global. Eles são utilizados conforme a necessidade e existem

durante todo o tempo de execução do programa. Os recursos que só podem ser usados em uma

parte ESPECÍFICA do arquivo de código fonte fazem parte do Escopo Local. São utilizados apenas no

bloco em que foram declarados e existem apenas durante o tempo de execução daquele bloco em

particular. Definidos estes termos, serão definidos agora as partes que compõem o arquivo de

código fonte em linguagem C.

2. Bibliotecas

Essa área está identificada na Figura 1 com a cor amarela e seu Escopo é Global. As

bibliotecas que são declaradas aqui são aquelas definidas pelo compilador C, ou por algum

programador, para serem utilizadas nos programas, como um todo, portanto elas são de uso




7

GLOBAL. Bibliotecas são arquivos que normalmente contêm constantes e funções, e podem ser

usadas nos arquivos que pertencem ao seu projeto. Exemplo: println(); é uma função de saída, e

scanf(); é uma função de entrada. Essas funções estão sendo chamadas em alguma parte do código e

estão codificadas na biblioteca stdio.

Assim, o arquivo de programa CHAMA uma Função que está em outro arquivo, um arquivo

de biblioteca, e a utiliza quantas vezes forem necessárias. Entretanto, se esquecer de declarar a

biblioteca na área de declaração de bibliotecas, usando a palavra-chave #include, então não será

possível usar os recursos que foram codificados na biblioteca. É pela declaração da biblioteca que o

arquivo de programa e o arquivo de biblioteca podem “conversar”.

Para ilustrar, observe a Figura 2 ao lado esquerdo desta página. Ela apresenta um arquivo .h

com duas funções, uma para verificar se X É MAIOR QUE Y, e outra para verificar se X É MENOR

QUE Y. Ambas as funções são usadas projeto, especificamente no arquivo MAIN.C. A biblioteca é

declarada como #include <minmax.h>, na região especificada para declaração de bibliotecas.

Depois as funções desta biblioteca são chamadas dentro do CASE. A Figura 3 apresenta a estrutura

Figura 1: Divisão do Escopo de Programa




8

de arquivos do CODEBLOCKS para um projeto que utiliza essa biblioteca. Observe que existe uma

PASTA chamada SOURCES que contém o arquivo .C, que também é chamado de SOURCE, e outra

PASTA chamada HEARDS que contém todos os arquivos de cabeçalhos, isto é, todas as bibliotecas

que você precisar criar. A Figura 4 ilustra o relacionamento entre esses dois arquivos, a forma como

eles conversam nas chamadas e retornos das funções e Listagem 1 apresenta o código fonte do

programa que utiliza o arquivo de cabeçalho MIXMAX.

#include <stdio.h>

#include <stdlib.h>

#include <locale.h>

#include "minmax.h"

//DECLARAÇÃO DE VARIÁVEIS

float n1, n2;

int opcao;

void menu();

Figura 2: Código Fonte da Biblioteca




9

void leitura();

int main()

{

setlocale(LC_ALL, "Portuguese");

menu();

return 0;

}

void menu()

{

do

{

printf(" \n | ========================== | ");

printf(" \n | MENU | ");

printf(" \n | 1. Obter os Operandos |");

printf(" \n | 2. Maior Número |");

printf(" \n | 3. Menor Número |");

printf(" \n | 0. Sair |");

printf(" \n | ========================== | ");

printf(" \n \n Digite a opção desejada: ");

scanf("%d%*c", &opcao);

printf(" \n ");

switch(opcao)

{

case 1:

leitura();

break;

case 2:

printf(" \n O maior número é: %.2f ", max(n1, n2));

printf("\n");

break;

case 3:

printf(" \n O menor número é: %.2f", min(n1, n2));

printf("\n");

break;

default:

printf(" \n \n Digite uma opção válida! \n \n ");

break;

}

}




10

while(opcao!=0);

}

//FUNÇÃO PARA LEITURA DOS DADOS DO TECLADO

void leitura()

{

printf(" \n Digite o valor do primeiro numero: ");

scanf("%f%*c", &n1);

printf(" \n Digite o valor do segundo numero: ");


}

Listagem 1: Código Fonte do arquivo C.

Figura 3: Estrutura de Pastas no Codeblocks

3. Variáveis

Essa área está identificada na Figura 1 com a cor verde e é definida como Escopo Global.

Aqui as variáveis são declaradas como GLOBAIS, isto é, as variáveis declaradas nesse ESCOPO são

usadas em TODO o programa e, por isso, deve-se tomar cuidado ao utilizá-las nas

funções/procedimentos, pois pode receber ou passar valores que não se deseja para outras partes

do programa, trabalhando assim com valores errados. Portanto, é sempre bom passar parâmetros

para as funções/procedimentos, garantindo o uso dos valores corretos entre as partes diferentes do

programa.




11

4. Protótipos de Funções

Essa área está identificada na Figura 1 com a cor azul e é de ESCOPO GLOBAL. Protótipos de

funções podem ter, ou não ter, parâmetros em seu protótipo, assim como declaração de novas

variáveis dentro do protótipo e também dentro do corpo da função.

Figura 4: Chamadas e Retornos das Funções entre os arquivos SOURCE e HEADER.

As variáveis declaradas dentro das funções, ou no protótipo, são variáveis LOCAIS, portanto

têm ESCOPO LOCAL. Elas receberão os valores que forem passados para elas na chamada,

garantindo assim a integridade dos valores e, após o término da execução da função, elas são

destruídas. Quem pode chamar uma Função? Outra Função ou qualquer outra parte do programa.




12

As Funções podem ou não retornar algum valor para quem chamou, dessa forma, pode-se

classificar Funções da seguinte maneira: Funções sem parâmetros e sem retorno; funções sem

parâmetros e com retorno; funções com parâmetros e sem retorno; e funções com parâmetros e

com retorno. A Tabela 1 apresenta exemplos para duas das quatro formas de funções: Funções sem

e com Parâmetro, mas sem Retorno. Já a Tabela 2 apresenta exemplos para Funções sem e com

Parâmetro, mas com Retorno. Considere que “so” é uma variável que foi declarada anteriormente

para poder ser utilizada.

Tabela 1: Funções sem e com Parâmetro, mas Sem Retorno

Sem Retorno

Protótipo da Função

Chamada da Função

Função Prototipada Retorno da

Função

Sem Parâmetro

void soma(); soma();

void soma() {

s = n1 + n2;

printf(" \n A soma é: %2.f", s);

}

Não retorna nenhum valor. Retorna apenas o que está dentro do corpo da função. Com

Parâmetro void soma ( float x,

float y ); soma ( x, y);

void soma (float x, float y) {

s = x + y;

printf(" \n A soma é: %2.f", s);

}

Tabela 2: Funções com e sem parâmetros, mas com retorno.

Com Retorno

Protótipo da Função Chamada da

Função Função Prototipada

Retorno da Função

Sem Parâmetro

float soma(); soma();

float soma() {

s = n1 + n2;

return s;

}

so = soma();

Com Parâmetro

float soma(float x, float y);

soma(x, y);

float soma(float x, float y) {

s = x + y;

return s;

}

so = soma(x,y);




13

5. Programa Principal

O programa principal basicamente só servirá para chamar as partes do programa que serão

necessárias, pois todo o resto pode ser implementado como bibliotecas e funções. O programa

principal tem acesso às variáveis globais, funções e bibliotecas, então, tudo o que for global, está

disponível para o programa principal. O que é LOCAL, não tem acesso permitido pelo programa

principal.




14

B. FUNÇÃO SEM PARAMETRO E SEM RETORNO

Funções sem parâmetros e sem retorno podem ser implementadas para resolver problemas,

isso significa que elas não receberão parâmetros de quem a está chamando, assim como não

retornarão um valor de um tipo especifico para quem está chamando. Esse tipo de função sempre

começa com a palavra-chave VOID antes do nome da função. VOID significa que não tem tipo, a

função não tem um tipo específico, como int ou float, por exemplo. A partir do momento que um

tipo é definido para uma Função, ela passa a ser uma Função com Retorno. A Listagem 2 apresenta

um exemplo de programa usando esta forma de função.

Nesse programa de exemplo, o programa principal chama a função MENU() e é só isso que o

programa principal faz, todo o restante está nas funções. Existe uma função para fazer a leitura do

teclado (solicita dados ao usuário) e outras funções para cada um dos cálculos matemáticos e outra

função para chamar o MENU() e mostrar as opções para o usuário selecionar a que ele deseja. Dessa

forma o programa fica bem organizado e estruturado.

#include <stdio.h>

#include <stdlib.h>

#include <locale.h>

//DECLARAÇÃO DE VARIÁVEIS

float n1, n2, so, su, mu, di;

int opcao;

void menu();

void leitura();

void soma();

void subtracao();

void divisao();

void multiplicacao();

int main()

{


menu();

return 0;

}




15

void menu()

{

do

{

printf(" \n | ========================= |");

printf(" \n | MENU |");


printf(" \n | 2. Soma |");

printf(" \n | 3. Subtração |");

printf(" \n | 4. Multiplicação |");

printf(" \n | 5. Divisão |");


printf(" \n | ========================= |");

printf("\n");

printf(" \n Digite a opção desejada: ");


printf("\n");

switch(opcao)

{

case 1:

leitura();

break;

case 2:

soma();

break;

case 3:

subtracao();

break;

case 4:

multiplicacao();

break;

case 5:

divisao();

break;

default:

printf(" \n Digite uma opção válida!");

break;

}

}

while(opcao!=0);

}




16

//FUNÇÃO PARA LEITURA DOS DADOS DO TECLADO

void leitura()

{





printf(" \n Os números são %.2f e %.2f: ", n1, n2);

printf("\n");

}

//cálculo da soma

void soma()

{

so = n1 + n2;

printf(" \n A soma é: %2.f", so);

printf("\n");

}

//CÁLCULO DA SUBTRAÇÃO

void subtracao()

{

su = n1 - n2;

printf(" \n A subtração é: %2.f", su);

printf("\n");

}

//CÁLCULO DA MULTIPLICAÇÃO

void multiplicacao()

{

mu = n1 * n2;

printf(" \n A multiplicação é: %2.f", mu);

printf("\n");

}

//CÁLCULO DA DIVISÃO

void divisao()

{

if(n2 != 0)

{

di = n1 / n2;

}




17

else

{

printf(" \n Não existe divisão por zero!");

}

printf(" \n A divisão é: %2.f", di);

printf("\n");

}

Listagem 2: Exemplo de programa usando funções sem parâmetros e sem retornos.

Figura 5: Sequência de Chamadas e Retornos das Funções

Como são funções sem parâmetros e sem retornos (funções tipo VOID), as chamadas nas

opções dentro do switch/case também são simples. Não há passagem de parâmetros, nem

tratamento de variáveis ou retornos das chamadas, todo o trabalho é distribuído nas funções. A

verificação de n2=0, para evitar o erro de divisão de por zero, também pode ser transformado em

uma função, diminuindo assim a quantidade de código REPETIDO no arquivo de programa.

Pensar uma função é uma tarefa importante. É preciso identificar o que se repete com

frequência no código, perceber que aquilo ali pode se transformar numa função e, assim, ao invés

de ficar codificando a mesma coisa sempre, isso deve ser abstraído, otimizando o código. Melhor

ainda se transformar isso em uma UNIT, permitindo que as rotinas possam ser usadas em vários

arquivos de programas diferentes. Isso é reutilização de código, uma postura muito bem-vinda, e




18

aceita, por desenvolvedores e projetistas de software. É o tipo de prática de desenvolvimento que

deve ser treinada sempre. A Figura 5 ilustra uma sequência de chamadas (setas azuis) e de retornos

(setas marrons) das funções envolvidas, de uma para outra até chegar a última necessária,

formando uma espécie de cascata.

A Figuras 6 apresenta a Pilha de Execução, que é uma forma de representar a sequência de

chamadas das funções e seus retornos. A verdade é que os sistemas computacionais utilizam uma

estrutura de PILHA DINÂMICA para controlar as chamadas e retornos de funções, armazenando

seus valores atuais em memória e desalocando esses espaços quando não são mais necessários.

Cada chamada é empilhada com seus valores atuais, e cada retorno é desempilhado, retornando os

valores resultantes para quem chamou, conforme mostram as setas na Figura.

Figura 6: Pilha de Execução




19

C. FUNÇÃO SEM PARAMETRO E COM RETORNO

Funções sem parâmetros e sem retorno podem ser implementadas para resolver problemas,

isso significa que elas não receberão parâmetros de quem a está chamando, assim como não

retornarão um valor de um tipo especifico para quem está chamando. Esse tipo de função sempre

começa com a palavra-chave VOID antes do nome da função. VOID significa que não tem tipo, a

função não tem um tipo específico, como int ou float, por exemplo. A partir do momento que um

tipo é definido para uma Função, ela passa a ser uma Função com Retorno. A Listagem 2 apresenta

um exemplo de programa usando esta forma de função.

Funções sem parâmetros e com retorno também podem ser implementadas, isso significa

que elas não receberão parâmetros vindos de quem a chamou, mas retornarão um valor de um tipo

especifico para quem está chamando. Isso significa que a Função tem um TIPO: int, float, boolean,

char, etc., e é esse tipo que deve ser retornado. A Listagem 3 apresenta um exemplo que é muito

parecido com o exemplo da Listagem 2. Na verdade, ela faz exatamente a mesma coisa, só que de

forma diferente. Antes de continuar, alguns conceitos importantes envolvidos nos exemplos devem

ser definidos.

Parâmetros: são as variáveis situadas no protótipo de uma função. Um parâmetro é um

valor que vem de uma variável, ou de uma expressão, que é passado para uma função, a qual utiliza

esses valores atribuídos aos parâmetros para alterar o seu comportamento em tempo de execução.

Argumentos: são os valores atribuídos aos parâmetros.

Chamada de Função: é um mecanismo pelo qual uma parte do programa de computador

solicita que uma tarefa seja realizada por outra parte dele próprio, no caso, uma função. Uma

chamada de função ocasiona um desvio na execução do programa.

Passagem de Parâmetros: são os valores passados para as funções.

Passagem de Parâmetros por Valor: é a forma mais comum de passar valores a uma

função. Uma cópia da variável inteira é feita e esta pode ser usada e alterada dentro da função sem

afetar a variável da qual ela foi gerada. Isso significa que o valor dos parâmetros sendo alterados

durante a execução da função não acarretará em nenhuma modificação no valor dos parâmetros

reais (variáveis da função chamadora).

Passagem de Parâmetros por Referência: o endereço da variável é transferido, isto

significa que um ponteiro é manipulado na função. Esta forma deve ser usada quando uma rotina




20

precisa ser capaz de alterar os valores das variáveis usadas como argumentos, os parâmetros então

precisam ser explicitamente declarados como tipos ponteiros. Isso significa que qualquer alteração

no valor dos parâmetros durante a execução da função será refletida no valor de seus parâmetros

reais correspondentes.

#include <stdio.h>

#include <stdlib.h>

#include <locale.h>

//declaração das variáveis globais

float n1, n2, so, su, mu, divi;

int opcao;

//declaração dos protótipos de funções

void menu();

void leitura();

float soma();

float subtracao();

float divisao();

float multiplicacao();

//PROGRAMA PRINCIPAL

int main()

{


menu();

return 0;

}

//FUNÇÃO PARA ESCOLHA DA OPÇÃO

void menu()

{

do

{

printf(" \n | ========================= |");









21



printf(" \n | ========================= |");

printf("\n");



printf("\n");

switch(opcao)

{

case 1:

leitura();

printf("\n");

break;

case 2:

so = soma();

printf("\n A soma é: %.2f", so);

printf("\n");

break;

case 3:

su = subtracao();

printf("\n A subtração é: %.2f", su);

printf("\n");

break;

case 4:

mu = multiplicacao();

printf("\n A multiplicação é: %.2f", mu);

printf("\n");

break;

case 5:

if(n2 != 0)

{

divi = divisao();

printf("\n A divisão é: %.2f: ", divi);

printf("\n");

}

else

{

printf("\n Não existe divisão por zero.");

printf("\n");

}

break;




22

default:


break;

}

}

while(opcao!=0);

}

//FUNÇÃO PARA LEITURA DOS DADOS

void leitura()

{





printf(" \n Os números digitados são %2.f e %.2f: ", n1, n2);

}

//FUNÇÃO PARA SOMAR DOIS NUMEROS

float soma()

{

float s;

s = n1 + n2;

return s;

}

//FUNÇÃO PARA SUBTRAIR DOIS NUMEROS

float subtracao()

{

float s;

s = n1 - n2;

return s;

}

//FUNÇÃO PARA DIVIDIR DOIS NUMEROS

float divisao()

{

float d;

d = n1/n2;

return d;

}

//FUNÇÃO PARA MULTIPLICAR DOIS NUMEROS




23

float multiplicacao()

{

float m;

m = n1 * n2;

return m;

}

Listagem 3: Exemplo de programa usando funções sem parâmetros com retorno.

1. Visualizando a passagem de parâmetro

Nesta seção será explicado o funcionamento da passagem de parâmetros entre as diferentes

partes do projeto em C. O programa principal chama a função MENU() e é assim que tudo começa.

Dentro do MENU() o switch/case permite ao usuário escolher uma opção.

Suponha que o usuário já digitou os valores para n1 e n2 e então escolheu a opção 3, que é a

subtração. Então, o usuário digitou no teclado o número 3, quando lhe foi solicitado escolher uma

opção, e foi esse valor que o scanf obteve e armazenou na variável do tipo inteiro OPCAO. Essa

variável OPCAO é passada como parâmetro no SWITCH/CASE. O Case analisa a variável OPCAO,

comparando o valor que está nela armazenado, com os valores de cada um dos CASES listados. Case

1 = 3? Não, vai para o próximo. Case 2 = 3? Não, vai para o próximo. Case 3 = 3? Sim, entra nesse

bloco de comando e o executa.

No corpo de Case 3 existe uma chamada para a função subtração. Como é uma função com

retorno, é necessário armazenar o retorno da função em uma variável do mesmo tipo, por isso é

feito su = subtracao(). A variável SU, do tipo float, armazena o valor que volta da função. Quando a

função a chamada, o programa pula para onde está a função, executa todos os comandos que estão

no corpo da função e retorna para quem chamou.

No corpo da função está a declaração de uma variável do tipo float chamada s, que

armazenará o resultado da subtração entre n1 e n2. Essa mesma variável é usada na linha return s.

Return é a palavra chave usada para RETORNAR um valor. A função de subtração é do tipo FLOAT,

por isso a variável local é float s, portanto, s é o valor que resulta da subtração e é retornado para

quem chamou a função. O Teste de Mesa para a sequência completa é apresentado na Tabela 4 e a

Figura ilustra as interações entre as partes.




24

Como exercício e treino sugere-se fazer o teste de mesa para todas as operações da Listagem

2 e da Listagem 3. Além disso, desenhar o fluxograma, ou a pilha de execuções, também ajudará a

entender o comportamento dos programas apresentados aqui.

Tabela 3: Teste de mesa para leitura e subtração

ITERAÇÃO opcao case

void leitura()

float subtração() case

n1 n2 s = n1 – n2 return s su =

subtração(); printf(“%.2f”,

su)

1 1 1 10,5 3,4

2 3 3 s = 10,5 – 3,4

s = 7,1

return 7,1

su = 7,1 7,10

3 1 1 54,7 8,5

4 3 3 s = 54,7 – 8,5

s = 46,2

return 46,2

su = 46,2 46,20

Figura 7: Fluxograma de Chamadas e Retornos de Funções




25

D. FUNÇÃO COM PARAMETRO E SEM RETORNO

Outro tipo de Função em C são as Funções com parâmetros e sem retorno, isso significa que

elas receberão parâmetros vindos de quem a chamou, mas não retornarão um valor de um tipo

especifico para quem está chamando. Novamente as funções serão do tipo VOID. A Listagem 4

apresenta um exemplo.

#include <stdio.h>

#include <stdlib.h>

#include <locale.h>


float n1, n2;

int opcao;


void menu();

void leitura();

void soma(float x, float y);

void subtracao(float x, float y);

void divisao(float x, float y);

void multiplicacao(float x, float y);


int main()

{


menu();

return 0;

}


void menu()

{

do

{

printf(" \n | ========================= |");






26






printf(" \n | ========================= |");

printf("\n");



printf("\n");

switch(opcao)

{

case 1:

leitura();

printf("\n");

break;

case 2:

soma(n1, n2);

break;

case 3:

subtracao(n1, n2);

break;

case 4:

multiplicacao(n1, n2);

break;

case 5:

divisao(n1, n2);

break;

default:


break;

}

}

while(opcao!=0);

}


void leitura()

{






27




}


void soma(float x, float y);

{

float s;

s = x + y;

printf("\n A soma é: %.2f", s);

printf("\n");

}


void subtracao(float x, float y)

{

float s;

s = x – y;

printf("\n A subtração é: %.2f", s);

printf("\n");

}


void divisao(float x, float y)

{

float d;

if(y != 0)

{

d = x / y;

printf("\n A divisão é: %.2f: ", d);

printf("\n");

}

else

{


printf("\n");

}

}





28

void multiplicacao(float x, float y)

{

float m;

m = x * y;

printf("\n A multiplicação é: %.2f", m);

printf("\n");

}

Listagem 4: Exemplo de programa usando funções com parâmetros sem retorno.

Observe os protótipos de funções, são todos do tipo void e todas as funções tem parâmetros: void

multiplicacao(float x, float y);. Depois, a função é chamada nos cases, passando para elas as variáveis

globais multiplicacao(n1, n2);. Por fim, as funções são prototipadas. A Tabela 4 apresenta o teste de mesa

para iterações com a multiplicação.

Tabela 4: Teste de Mesa


void leitura()

case void multiplicação(float x, float y)

n1 n2 nultiplicação(n1,n2); float

m; m = x * y;

printf(“”, m);

1 1 1 5 2

2 4 4 multiplicação(5,2); m = 5 * 2 = 10 10

3 1 1 4 10

4 4 4 multiplicação(4,10);

m = 4 * 10 =

40 40




29

E. FUNÇÃO COM PARAMETRO E COM RETORNO

Outro tipo de Função em C são as Funções com parâmetros e com retorno, isso significa que

elas receberão parâmetros vindos de quem a chamou, e retornarão um valor de um tipo especifico

para quem está chamando. Neste exemplo as funções têm tipos (não são void). A Listagem 5

apresenta um exemplo

#include <stdio.h>

#include <stdlib.h>

#include <locale.h>


float n1, n2, so, su, mu, divi;

int opcao;


void menu();

void leitura();

float soma(float x, float y);

float subtracao(float x, float y);

float divisao(float x, float y);

float multiplicacao(float x, float y);


int main()

{


menu();

return 0;

}


void menu()

{

do

{

printf(" \n | ========================= |");








30




printf(" \n | ========================= |");

printf("\n");



printf("\n");

switch(opcao)

{

case 1:

leitura();

printf("\n");

break;

case 2:

so = soma(n1, n2);

printf("\n A soma é: %.2f", so);

printf("\n");

break;

case 3:

su = subtracao(n1, n2);

printf("\n A subtração é: %.2f", su);

printf("\n");

break;

case 4:

mu = multiplicacao(n1, n2);

printf("\n A multiplicação é: %.2f", mu);

printf("\n");

break;

case 5:

if(n2 != 0)

{

divi = divisao(n1, n2);

printf("\n A divisão é: %.2f: ", divi);

printf("\n");

}

else

{


printf("\n");

}




31

break;

default:


break;

}

}

while(opcao!=0);

}


void leitura()

{






}


float soma(float x, float y)

{

float s;

s = n1 + n2;

return s;

}


float subtracao(float x, float y)

{

float s;

s = n1 - n2;

return s;

}


float divisao(float x, float y)

{

float d;

d = n1/n2;

return d;

}




32


float multiplicacao(float x, float y)

{

float m;

m = n1 * n2;

return m;

}

Listagem 5: Código Fonte

Observe os protótipos de funções, são todo tem um tipo e todas as funções tem parâmetros:

float multiplicacao(float x, float y);. Depois, a função é chamada nos cases, passando para elas as

variáveis globais multiplicacao(n1, n2); e além disso, o retorno da função deve ser trabalhado,

salvando o retorno em outra variável, mul = multiplicação(n1,n2);. Por fim, as funções são

prototipadas. A Tabela 5 apresenta o teste de mesa para iterações com a multiplicação.

Tabela 5: Teste de Mesa


void leitura()

case float multiplicação(float x, float y)

n1 n2 mul =

nultiplicação(n1,n2);

printf(“”, mul); float m;

m = x * y;

return m;

1 1 1 5 2

2 4 4 mul =

multiplicação(5,2) = 10

10

m = 5 * 2 = 10

10

3 1 1 4 10

4 4 4 mul =

multiplicação(4,10) = 40

40

m = 4 * 10 =

40 40




33

F. Funções e Ponteiros




34

G. Funções e Arrays




35

H. Funções e Structs




36

I. Tipos de Funções

1. Funções do Tipo INT

2. Funções do Tipo FLOAT

3. Funções do Tipo Char

3. Funções do Tipo Booleano

Apostila de Funções em C

Education

Transcript of Apostila de Funções em C