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

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

Funções em C

Recomendados

Recomendados

Mais conteúdo relacionado

Semelhante a Funções em C

Semelhante a Funções em C (20)

Mais de Elaine Cecília Gatto

Mais de Elaine Cecília Gatto (20)

Último

Último (20)

Funções em C