Introdução à Programação

Capítulo 5

Funções

O BJETIVOS DO CAPÍTULO
Ao final deste capítulo você deverá ser capaz de:
• Criar e usar funções e procedimentos em C
• Identificar quando escrever uma função ou um procedimento
• Entender as regras de escopo para variáveis em C
• Entender os diferentes tipos de passagem de parâmetro e quando utilizá-los
• Trabalhar com funções recursivas

Quando elaboramos um algoritmo para resolver um problema, e quando escrevemos um programa

para implementar este algoritmo, muitas vezes identificamos uma parte do algoritmo que deve ser
realizada várias vezes para chegar ao resultado. Ou, ao trabalhar com vários algoritmos diferentes,
identificamos algumas partes em comum entre eles. Nestes casos, é uma boa ideia isolar essas partes
que se repetem, de maneira que elas possam ser realizadas sem repetir o mesmo código várias vezes.
Esse objetivo pode ser atingido com o uso de funções e procedimentos.
Neste capítulo, vamos estudar as funções e procedimentos como uma forma de reaproveitar o código
de tarefas que se repetem em um programa. Funções são importantes para a modularização de um
programa, ou seja, para dividir o programa em partes menores, cada parte com uma função específica;
sem funções ou procedimentos, um programa maior e mais complicado ficaria organizado em uma
única parte que faz tudo e é mais difícil de entender. Neste capítulo, vamos entender quando utilizar
as funções ou procedimentos para melhor dividir o código dos nossos programas.

Importante
Neste capítulo, vamos descartar a utilização de pseudocódigo. Agora que você já possui
um conhecimento básico sobre a linguagem C e, provavelmente, escreveu alguns programas
nela, consideramos que não haverá mais necessidade de apresentar sintaxes para pseudo-
códigos. Portanto, deste capítulo em diante, o conteúdo apresentadao utilizará somente a
sintaxe da linguagem C.

5.1 O que são funções?

Funções e procedimentos podem ser compreendidos como trechos reutilizáveis de código. Uma fun-
ção ou procedimento pode, então, ser utilizado várias vezes por um mesmo programa. Isso simplifica

63 / 92
 Introdução à Programação

a criação de programas maiores, dividindo-os em unidades menores que trabalham em conjunto. Fun-
ções e procedimentos são bastante semelhantes e, posteriormente, vamos entender as diferenças entre
eles.

Revisão
Lembre-se que durante o curso você já utilizou funções diversas vezes, o que nós sabemos
sobre funções até agora?

• Uma função implementa um comportamento que pode ser reutilizado;

• Para executar uma função, utilizamos o nome da função e passamos alguns parâmetros
entre parênteses e separados por vírgula. Exemplo: printf("R$ %1.2f", preco);

• A função printf é utilizada para imprimir texto na saída;

• As funções scanf e getchar para ler dados da entrada;

• As funções strlen, strcpy, strcat e strchr são utilizadas para manipular strings;

• As funções são agrupadas em módulos. Exemplo: stdio;

Quando realizamos um processo com um determinado objetivo, é comum identificarmos partes que se
repetem. Quando se trata de processos no mundo físico, muitas vezes criamos máquinas que ajudam
a realizar as partes que se repetem.
Por exemplo, pense no processo de limpar as roupas que usamos para podermos usá-las novamente.
Este processo envolve lavar as roupas com água e sabão, secar as roupas lavadas e, finalmente, passar
as roupas para evitar que fiquem amassadas. Para reduzir a quantidade de trabalho necessária para
realizar esse processo, foi inventada uma máquina de lavar, que realiza a lavagem das roupas. Uma
pessoa que tem uma máquina de lavar pode usá-la repetidamente e, sempre que precisa de roupas
limpas, precisa apenas se encarregar de enxugar e passar as roupas; a lavagem fica por conta da
máquina. Dizemos inclusive que a função da máquina é lavar as roupas.
As funções e os procedimentos funcionam desta forma, capturando partes menores de um algoritmo
que podem ser utilizadas por outros algoritmos, economizando o trabalho de sempre refazer uma
determinada tarefa.

5.1.1 Um exemplo

Vejamos um exemplo. Queremos criar um programa que calcule a média final de um aluno em uma
disciplina com três provas; o programa deve pedir ao usuário que entre com as notas das três provas,
calcular a média aritmética das três notas e apresentar o resultado. O programador que resolveu o
problema decidiu imprimir um separador na tela entre cada entrada de dados e o resultado final, desta
forma, produzindo o seguinte código:
Código fonte
Cálculo da média de um aluno em uma disciplina
1 #include <stdio.h>
2

3 int main () {
4 float nota1, nota2, nota3, media;

64 / 92
 Introdução à Programação

6 printf("Entre a nota da primeira prova: ");

7 scanf("%f", &nota1);
8

9 printf("\n"); // 1x
10 printf("=============================================\n"); // 2x
11 printf("\n"); // 3x
12

13 printf("Entre a nota da segunda prova: ");

14 scanf("%f", &nota2);
15

16 printf("\n");
17 printf("=============================================\n");
18 printf("\n");
19

20 printf("Entre a nota da terceira prova: ");

21 scanf("%f", &nota3);
22

23 printf("\n");
24 printf("=============================================\n");
25 printf("\n");
26

27 media = (nota1 + nota2 + nota3) / 3.0;

28 printf("Media: %f\n", media);
29

30 return 0;
31 }

x, 2x, 3x Código
1 que imprime um separador na tela.

Resultado da execução do programa

Entre a nota da primeira prova: 7.0

=============================================

Entre a nota da segunda prova: 8.0

=============================================

Entre a nota da terceira prova: 9.6

=============================================

Media: 8.200000

É fácil de notar que o código usado para imprimir um separador se repete três vezes no programa. Po-
demos melhorar esse programa utilizando um procedimento que terá a tarefa de imprimir o separador.
Isso teria o seguinte resultado:
Código fonte
Cálculo da média usando procedimento

65 / 92
 Introdução à Programação

1 #include <stdio.h>
2

3 void imprime_separador() { // 1x
4 printf("\n"); // 2x
5 printf("=============================================\n"); // 3x
6 printf("\n"); // 4x
7 }
8

9 int main () {
10 float nota1, nota2, nota3, media;
11

12 printf("Entre a nota da primeira prova: ");

13 scanf("%f", &nota1);
14

15 imprime_separador(); // 5x
16

17 printf("Entre a nota da segunda prova: ");

18 scanf("%f", &nota2);
19

20 imprime_separador();
21

22 printf("Entre a nota da terceira prova: ");

23 scanf("%f", &nota3);
24

25 imprime_separador();
26

27 media = (nota1 + nota2 + nota3) / 3.0;

28 printf("Media: %f\n", media);
29

30 return 0;
31 }

x
1 Definição do procedimento imprime_separador.
x, 3x, 4x Código
2 no corpo do procedimento.
x
5 Chamada do procedimento imprime_separador.

A linha void imprime_separador() inicia a definição do procedimento chamado

imprime_separador; o corpo do procedimento é o conjunto de comandos entre chaves que
vem logo após o nome do procedimento. Os parênteses e a palavra void no início serão explicados
depois. Dizemos que o uso de um procedimento é uma chamada ao mesmo. No exemplo anterior, o
código do programa chama imprime_separador três vezes.
É importante notar que além de economizar a repetição de linhas de código, o programa usando o
procedimento imprime_separador também é mais fácil de entender porque transmite melhor as
partes que compõem o programa. A melhor modularização do código do programa é um motivo extre-
mamente importante para usar funções e procedimentos, principalmente à medida que os programas
se tornam maiores e mais complexos.

66 / 92
 Introdução à Programação

5.2 Parâmetros

O exemplo usando imprime_separador é o caso mais simples, mas menos interessante do uso
de procedimentos e funções, quando o código a ser reutilizado é sempre o mesmo. Na maioria das
situações de interesse, queremos utilizar uma função ou procedimento em situações com algumas
diferenças. Para tornar um procedimento (ou função) mais flexível, é preciso que informações sejam
passadas para o procedimento. Isso é feito com o uso de parâmetros.
Já vimos muitas vezes o uso de procedimentos com parâmetros. Por exemplo, printf é um proce-
dimento da biblioteca padrão da linguagem C que imprime a string passada como parâmetro. Assim,
printf("ola, mundo!");

é uma chamada ao procedimento printf com parâmetro "ola, mundo!".

Como exemplo do uso de parâmetros em um procedimento, voltemos ao exemplo do cálculo das
médias. Vamos utilizar o separador para fazer uma visualização simples das notas e da média, impri-
mindo uma barra de tamanho proporcional a cada valor.
Código fonte
Uso de um procedimento com parâmetro
1 #include <stdio.h>
2 #include <math.h>
3

4 void imprime_separador(float nota) { // 1x

5 int i;
6 printf("\n");
7 for (i = 0; i < (int) lround(nota * 5.0); i++) {
8 printf("=");
9 }
10 printf(" %3.2f / 10.0\n", nota);
11 printf("\n");
12 }
13

14 int main () {
15 float nota1, nota2, nota3, media;
16

17 printf("Entre a nota da primeira prova: ");

18 scanf("%f", &nota1);
19

20 imprime_separador(nota1); // 2x
21

22 printf("Entre a nota da segunda prova: ");

23 scanf("%f", &nota2);
24

25 imprime_separador(nota2);
26

27 printf("Entre a nota da terceira prova: ");

28 scanf("%f", &nota3);
29

30 imprime_separador(nota3);
31

32 media = (nota1 + nota2 + nota3) / 3.0;

67 / 92
 Introdução à Programação

33 printf("Media: %3.2f\n", media);

34

35 imprime_separador(media);
36

37 return 0;
38 }

x
1 Definição do procedimento imprime_separador, com o parâmetro nota, do tipo float.
x
2 Chamada do procedimento imprime_separador, passando o argumento nota1.

Resultado da execução do programa code/cap5/media_param.c

Entre a nota da primeira prova: 6.2

=============================== 6.20 / 10.0

Entre a nota da segunda prova: 7.8

======================================= 7.80 / 10.0

Entre a nota da terceira prova: 9.2

============================================== 9.20 / 10.0

Media: 7.73

======================================= 7.73 / 10.0

Como se pode ver no resultado da execução do programa, o novo procedimento

imprime_separador imprime uma barra de tamanho proporcional à nota passada como
argumento (são 5 caracteres = para cada ponto da nota). Note a diferença de nomenclatura: o
procedimento imprime_separador é definido com um parâmetro de nome nota, mas é
chamado com um argumento, o valor que é comunicado ao procedimento. No exemplo acima,
imprime_separador é chamado com os argumentos nota, nota2, nota3 e media. É
necessário especificar o tipo de cada parâmetro que deve ser passado para o procedimento; no caso,
o parâmetro nota do procedimento imprime_separador é do tipo float.
Na chamada de um procedimento com um parâmetro, o controle do programa executa o código do
procedimento, atribuindo o valor passado como argumento à variável nota dentro do procedimento
imprime_separador. Ou seja, o seguinte código
int main() {
float nota1;

printf("Entre a nota da primeira prova: ");

scanf("%f", &nota1);

imprime_separador(nota1);

// resto do programa ...

}

68 / 92
Introdução à Programação

funciona como se fosse o seguinte (utilizando o procedimento):

int main() {
float nota1;

printf("Entre a nota da primeira prova: ");

scanf("%f", &nota1);

float nota = nota1; // 1x

int i; // 2x
printf("\n");
for (i = 0; i < (int) lround(nota * 5.0); i++) {
printf("=");
}
printf(" %3.2f / 10.0\n", nota);
printf("\n");

// resto do programa ...

}

x
1 Atribuição do valor do argumento nota1 para o parâmetro nota.
x
2 Resto do corpo do procedimento imprime_separador.

Este exemplo é apenas uma ilustração; na prática, o chamado do procedimento não funciona exata-
mente desta forma. Em particular, a variável nota, que designa o parâmetro do procedimento, só
existe enquanto o procedimento executa. Isso será detalhado mais tarde.
O uso de parâmetros nos procedimentos os tornam muito mais flexíveis para uso em diferentes situ-
ações. Mas assim como é útil que o código que chama o procedimento comunique informações para
o procedimento chamado, muitas vezes também é útil que o procedimento comunique algo de volta
para o código que o chamou; neste caso, passamos dos procedimentos para as funções.

5.3 Retorno de Valores com Funções

Até agora só temos usado procedimentos como ferramenta de modularização do código, mas muitas
vezes é útil chamar um procedimento que retorna alguma informação de volta para o código que o
chamou. Esta é a diferença entre procedimentos e funções: as funções retornam algum valor. Desta
forma, as funções em linguagem C são similares às funções da matemática: uma função como

f : Z → Z, f (x) = x2 + 2

tem um parâmetro x (um inteiro), e retorna um determinado valor que depende do parâmetro passado;
por exemplo,
f (5) = 52 + 2 = 27
É fácil escrever a mesma função em linguagem C:
int f(int x) { // 1x
return x * x + 2; // 2x
}

69 / 92
 Introdução à Programação

x
1 Definição da função f. A definição começa com int f(...), significando que o tipo de
retorno da função é int.
x
2 A palavra-chave return determina o valor de retorno da função f, que será o resultado da
expressão x * x + 2.

A função f do exemplo faz o mesmo que a versão matemática: dado o valor do parâmetro x, retorna
um valor que é igual a x ao quadrado, somado a dois. Note que é preciso especificar o tipo do valor
que é retornado pela função e, por isso, toda função começa com o tipo de retorno antes do nome.
Especificar os tipos dos parâmetros e o tipo do valor de retorno também é similar às funções na
matemática, para as quais devemos especificar os conjuntos domínio e contra-domínio.

5.3.1 Funções, Procedimentos e o Tipo void

Neste ponto pode surgir uma pergunta: se é preciso especificar o tipo do valor retornado por uma
função antes do nome da função (por exemplo int f(...)), por que nos procedimentos usa-se a
palavra-chave void?
A verdade é que, embora algumas linguagens de programação façam uma distinção entre procedi-
mentos e funções, na linguagem C existem apenas funções. Como a diferença entre procedimentos e
funções é apenas o fato de retornar ou não um valor, os procedimentos em C são considerados funções
que retornam um valor vazio. É isso que significa o void no início da definição de um procedimento
como imprime_separador, que vimos anteriormente; a rigor, imprime_separador é uma
função, mas retorna um valor vazio, ou seja, nenhum valor. O tipo void na linguagem C é um tipo
especial que denota a ausência de valores.
Como procedimentos em C são funções, também é possível usar return em procedimentos, mas
apenas para terminar sua execução e retornar imediatamente. Isso às vezes é útil para terminar um
procedimento em pontos diferentes do seu final. Também pode-se utilizar return ao final do pro-
cedimento, mas este uso é supérfluo e não é recomendado.
O seguinte exemplo demonstra o uso do return em procedimentos. Continuando no tema relaci-
onado ao cálculo de médias, queremos detectar se uma das notas entradas pelo usuário é uma nota
inválida antes de fazer o cálculo da média. Neste caso, o programa deve apenas imprimir se algum
valor negativo foi entrado pelo usuário. O procedimento possui_negativo será responsável por
imprimir uma mensagem caso um dos valores seja negativo.
Código fonte
Uso de return em um procedimento
1 #include <stdio.h>
2

3 void possui_negativo(float n1, float n2, float n3) {

4 if (n1 < 0.0) {
5 printf("Numero negativo encontrado!\n");
6 return; // 1x
7 }
8

9 if (n2 < 0.0) {

10 printf("Numero negativo encontrado!\n");
11 return;
12 }

70 / 92
 Introdução à Programação

13

14 if (n3 < 0.0) {

15 printf("Numero negativo encontrado!\n");
16 return;
17 }
18

19 printf("Nenhum numero negativo encontrado\n"); // 2x

20 }
21

22 int main() {
23 float nota1, nota2, nota3;
24

25 printf("Entre as três notas, separadas por espacos: ");

26 scanf("%f %f %f", &nota1, &nota2, &nota3);
27

28 possui_negativo(nota1, nota2, nota3);

29

30 printf("Media: %f\n", (nota1 + nota2 + nota3) / 3.0);

31

32 return 0;
33 }

x
1 Uso do return para sair prematuramente do procedimento.
x
2 Este comando de impressão será executado se nenhuma das condições testadas em
possui_negativo for verdade, ou seja, se nenhum dos valores dos parâmetros for nega-
tivo.

Resultado de duas execuções do programa code/cap5/retorno_proc.c

Entre as três notas, separadas por espacos: 4.5 5.6 8.9
Nenhum numero negativo encontrado
Media: 6.333333

Entre as três notas, separadas por espacos: 4.5 -6.7 9.9

Numero negativo encontrado!
Media: 2.566667

O procedimento possui_negativo deve verificar se um dos três números passados como argu-
mentos, mas basta achar um número entre eles para que o resultado possa ser impresso imediatamente
e o procedimento pode retornar; por isso, usamos return assim que o primeiro valor negativo é en-
contrado.
Esse exemplo ainda tem um problema: como pode ser visto nos exemplos de execução, mesmo que
o usuário entre um valor negativo, a média aritmética das três notas ainda é impressa na tela (o
usuário apenas é avisado que um dos valores foi negativo). Isso é uma indicação que seria melhor que
possui_negativo fosse uma função, e que o programa principal verificasse o valor retornado e
tomasse uma decisão. Se fizermos essas alterações ficamos com o seguinte programa:
Código fonte
Reescrevendo o exemplo anterior para usar uma função

71 / 92
 Introdução à Programação

1 #include <stdio.h>
2

3 int possui_negativo(float n1, float n2, float n3) { // 1x

4 if (n1 < 0.0 || n2 < 0.0 || n3 < 0.0) // 2x
5 return 1; // 3x
6

7 return 0; // 4x
8 }
9

10 int main() {
11 float nota1, nota2, nota3;
12

13 printf("Entre as três notas, separadas por espacos: ");

14 scanf("%f %f %f", &nota1, &nota2, &nota3);
15

16 if (possui_negativo(nota1, nota2, nota3) == 1) // 5x

17 printf("Nao e’ possivel calcular a media, uma ou mais notas ←-
sao negativas\n");
18 else
19 printf("Media: %f\n", (nota1 + nota2 + nota3) / 3.0);
20

21 return 0;
22 }

x
1 A função possui_negativo agora retorna um inteiro de valor 1 caso um dos valores dos
parâmetros seja negativo, e 0 caso contrário (todos são positivos).
x
2 Teste para identificar se um ou mais dos parâmetros informados são negativos.
x
3 A função retorna 1 se um dos números passados para a função for negativo.
x
4 Caso nenhum dos números seja negativo, o controle passa para o comando return ao final da
função e o valor 0 é retornado para indicar que nenhum número negativo foi encontrado.
x
5 O programa principal verifica o valor de retorno da função possui_negativo e imprime
informações adequadas na tela para cada caso.

Resultado de duas execuções do programa code/cap5/retorno_func.c

Entre as três notas, separadas por espacos: 6.8 9.7 -2.3
Nao e’ possivel calcular a media, uma ou mais notas sao ←-
negativas

Entre as três notas, separadas por espacos: 6.8 9.7 7.2

Media: 7.900000

Como pode-se ver nos dois exemplos de execução do programa, a saída agora é mais adequada.
Caso uma das notas informadas seja negativa, o programa não imprime um valor de média, apenas
avisando o usuário do erro na entrada de dados. O código da função possui_negativo também
foi simplificado pelo uso do operador lógico OU.

72 / 92
Introdução à Programação

Como funções e procedimentos são tratados de maneira uniforme na linguagem C (e em muitas

outras linguagens atuais), a partir de agora vamos usar o termo função tanto para funções como
para procedimentos. Isso não deve gerar nenhuma confusão. Em caso de dúvida, basta olhar para a
definição da função no código-fonte do programa; se a função for declarada com o tipo de retorno
void, então é um procedimento.

5.4 Um Exemplo Matemático: Equação de Segundo Grau

Nesta seção, veremos mais um exemplo do uso de funções em um programa para calcular as raízes
de uma equação de segundo grau. Neste exemplo, as funções não serão utilizadas várias vezes, mas o
programa principal será mais claro e mais fácil de entender graças à melhor modularização conseguida
com o uso das funções.
Lembremos que um polinômio de segundo grau é uma soma de três termos em potências de uma
variável, por exemplo
P(x) = ax2 + bx + c
onde a, b e c são coeficientes constantes. Uma equação de segundo grau é formada ao igualar um
polinômio de segundo grau a zero, ou seja

ax2 + bx + c = 0

Sabemos que uma equação de segundo grau pode ter até duas raízes reais; cada raiz é um valor
da variável x que satisfaz a equação. Essas raízes podem ser encontradas pela chamada fórmula de
Bhaskara. A fórmula consiste em calcular um valor auxiliar chamado de ∆ (delta), e usar o valor
calculado para identificar quantas raízes reais distintas podem ser encontradas para a equação:

• se ∆ < 0, a equação não tem raízes reais;

• se ∆ = 0, a equação possui uma raiz real;

• se ∆ > 0, a equação possui duas raízes reais distintas.

A fórmula para calcular ∆ é

∆ = b2 − 4ac
No caso ∆ >= 0, as raízes da equação são dadas por
√
−b ± ∆
x=
2a
√
uma das raízes sendo obtida pelo uso do sinal positivo em −b ± ∆, enquanto que a outra raiz é
calculada pelo uso do sinal negativo. Se ∆ = 0, ambos os valores serão iguais.
Como exemplo do uso da fórmula de Bhaskara, considere a equação:

x2 − 5x + 6 = 0

Nesta equação os coeficientes são a = 1, b = −5 e c = 6. Calculamos o ∆ usando os valores dos

coeficientes:
∆ = b2 − 4ac = (−5)2 − 4 × 1 × 6 = 25 − 24 = 1

73 / 92
 Introdução à Programação

E assim, podemos calcular as raízes:

√ √
−b ± ∆ 5 ± 1 5 ± 1
x= = =
2a 2 2
Ou seja, as raízes são 6/2 = 3 e 4/2 = 2.
Agora vamos escrever um programa que resolve equações do segundo grau, usando o processo mos-
trado acima.
Código fonte
Cálculo de raízes de uma equação de segundo grau
1 #include <stdio.h>
2 #include <math.h>
3

4 float calculo_delta(float a, float b, float c) { // 1x

5 return (b * b) - (4 * a * c);
6 }
7

8 float raiz_positiva(float a, float b, float delta) { // 2x

9 return (-b + sqrt(delta)) / 2 * a;
10 }
11

12 float raiz_negativa(float a, float b, float delta) { // 3x

13 return (-b - sqrt(delta)) / 2 * a;
14 }
15

16 int main() {
17 float a, b, c;
18 float delta;
19

20 printf("Entre os coeficientes A, B e C, nesta ordem: ");

21 scanf("%f %f %f", &a, &b, &c);
22

23 delta = calculo_delta(a, b, c);

24

25 if (delta < 0.0)

26 printf("Delta negativo, nao existem raizes\n");
27 else if (delta == 0)
28 printf("Delta = 0, uma raiz: %f\n", raiz_positiva(a, b, delta) ←-
);
29 else
30 printf("Raizes: %f e %f\n", raiz_positiva(a, b, delta), ←-
raiz_negativa(a, b, delta));
31

32 return 0;
33 }

x
1 Função que calcula o valor do ∆.
x
2 Função que calcula a raiz positiva da equação.
x
3 Função que calcula a raiz negativa da equação.

74 / 92
 Introdução à Programação

Resultado de três execuções do programa code/cap5/equacao.c

Entre os coeficientes A, B e C, nesta ordem: 1.0 -5.0 6.0
Raizes: 3.000000 e 2.000000

Entre os coeficientes A, B e C, nesta ordem: 1.0 -6.0 9.0

Delta = 0, uma raiz: 3.000000

Entre os coeficientes A, B e C, nesta ordem: 4.0 -3.0 7.0

Delta negativo, nao existem raizes

Podemos ver neste exemplo funções para calcular o valor do ∆ e das duas raízes da equação. O
programa obtém o valor do ∆ e verifica se a equação tem nenhuma, uma ou duas raízes, e imprime o
resultado de acordo com isso. Embora cada função seja usada apenas uma vez, o programa principal
é mais claro e mais fácil de entender porque cada função faz uma parte do processo necessário, ao
invés de ter todo o código junto na função main. Funções são importantes não só para reutilizar
código e diminuir esforço de programação, mas também para melhorar a modularização do programa
e torná-lo mais fácil de ser lido. Em situações práticas, muitas vezes é necessário ler um código que
já foi produzido antes e entendê-lo, seja para consertar defeitos encontrados ou para extender suas
funcionalidades. Tornar um programa mais legível auxilia e reduz o custo relacionado à manutenção
do mesmo.
Entretanto, este último exemplo pode parecer estranho do ponto de vista da modularização, já
que duas de suas funções são quase idênticas. As funções que calculam o valor das raízes,
raiz_positiva e raiz_negativa, mudam apenas em uma operação. Podemos pensar em
como reescrever o programa para usar apenas uma função ao invés de duas funções quase idênticas.
A repetição desnecessária de código pode ser um problema para a manutenção de um programa.
A chave para criar uma só função que calcula os dois valores é criar um novo parâmetro que indica
qual das duas raízes deve ser calculada. Vamos usar um parâmetro chamado sinal que indica, pelo
seu valor, se será usada uma soma ou subtração no cálculo da raiz. Se sinal for 1, será usada uma
soma, e se for -1 será usada uma subtração. O código resultante é mais compacto e evita repetições:
Código fonte
Cálculo de raízes de uma equação de segundo grau
1 #include <stdio.h>
2 #include <math.h>
3

4 float calculo_delta(float a, float b, float c) {

5 return (b * b) - (4 * a * c);
6 }
7

8 float raiz(float a, float b, float delta, int sinal) {

9 if (sinal == 1)
10 return (-b + sqrt(delta)) / 2 * a;
11 else
12 return (-b - sqrt(delta)) / 2 * a;
13 }
14

15 int main() {
16 float a, b, c;
17 float delta;

75 / 92
 Introdução à Programação

18

19 printf("Entre os coeficientes A, B e C, nesta ordem: ");

20 scanf("%f %f %f", &a, &b, &c);
21

22 delta = calculo_delta(a, b, c);

23

24 if (delta < 0.0)

25 printf("Delta negativo, nao existem raizes\n");
26 else if (delta == 0)
27 printf("Delta = 0, uma raiz: %f\n", raiz(a, b, delta, 1));
28 else
29 printf("Raizes: %f e %f\n", raiz(a, b, delta, 1), raiz(a, b, ←-
delta, -1));
30

31 return 0;
32 }

É comum quando escrevemos programas nos concentrarmos, inicialmente, em fazê-lo funcionar, ou

seja, resolver o problema desejado. Entretanto, é importante depois reler o código escrito e revisá-lo
para torná-lo mais claro, mais legível e mais fácil de manter. Esse processo de revisar o código de
um programa sem mudar sua funcionalidade é muito importante na programação de computadores, e
normalmente recebe o nome de refatoração.

5.5 Escopo de Variáveis

Quando trabalhamos com programas compostos por várias funções, nos deparamos com questões
relativas à visibilidade das variáveis em diferentes partes do programa. Ou seja, se uma variável é
visível ou acessível em certas partes de um programa.
Um programador iniciante poderia escrever o seguinte programa para calcular a média aritmética de
três notas:
Código fonte
Cálculo da média usando código incorreto
1 #include <stdio.h>
2

3 float calc_media() {
4 return (nota1 + nota2 + nota3) / 3.0; // 1x
5 }
6

7 int main() {
8 float nota1, nota2, nota3;
9

10 printf("Entre as três notas: ");

11 scanf("%f %f %f", &nota1, &nota2, &nota3);
12

13 printf("Media: %f\n", calc_media());

14

15 return 0;
16 }

76 / 92
 Introdução à Programação

x
1 Esta linha contém erros e o programa não será compilado.

O raciocínio do programador é "se as variáveis nota1, nota2 e nota3 existem na função main
e a função calc_media é chamada dentro de main, as variáveis nota1, nota2 e nota3 não
deveriam ser visíveis dentro de calc_media ?"
Acontece que isso não é válido na linguagem C, e qualquer compilador da linguagem vai acusar
erros de compilação neste programa, avisando que as variáveis nota1, nota2 e nota3 não foram
declaradas.
Para entender como funciona a visibilidade das variáveis em um programa na linguagem C, precisa-
mos falar sobre as regras de escopo desta linguagem. O escopo de uma variável é a parte do programa
na qual ela é visível e pode ser acessada.
A linguagem C usa um conjunto de regras de escopo que recebe o nome de escopo estático ou escopo
léxico. Essas regras são bastante simples de entender e aplicar, como veremos a seguir.
Em programas na linguagem C existem dois tipos de escopo (regiões de visibilidade):

• escopo global;

• escopos locais.

Existe apenas um escopo global e, como indicado pelo seu nome, ele contém elementos que são
visíveis em todo o programa. Já os escopos locais são vários e particulares: basicamente, cada função
define um escopo local que corresponde com o corpo da função.
Desta forma, variáveis declaradas no escopo global (ou seja, "fora"de qualquer função) são visíveis
em todo programa, enquanto variáveis declaradas dentro de uma função são visíveis apenas dentro
da mesma função. No exemplo anterior, as variáveis nota1, nota2 e nota3 são visíveis apenas
dentro da função main, e por isso não podem ser acessadas dentro da função calc_media.
Isso pode ser resolvido mudando as variáveis nota1, nota2 e nota3 para o escopo global, ou seja,
tornando-as variáveis globais, como no seguinte programa:
Código fonte
Cálculo de raízes de uma equação de segundo grau
1 #include <stdio.h>
2

3 float nota1, nota2, nota3; // 1x

4

5 float calc_media() {
6 return (nota1 + nota2 + nota3) / 3.0; // 2x
7 }
8

9 int main() {
10 printf("Entre as três notas: ");
11 scanf("%f %f %f", &nota1, &nota2, &nota3); // 3x
12

13 printf("Media: %f\n", calc_media());

14

15 return 0;
16 }

77 / 92
 Introdução à Programação

x
1 Declaração das variáveis nota1, nota2 e nota3 como variáveis globais. Note que elas estão
declaradas "fora"de qualquer função.
x
2 Código dentro de calc_media que usa as variáveis globais. Neste programa, as variáveis
estão visíveis e não ocorrerá um erro durante a compilação.
x
3 Código dentro de main que usa as variáveis globais. Variáveis globais são visíveis em todo o
programa, incluindo na função principal.

Este programa agora compila corretamente e funciona para o cálculo da média. Mas é importante
observar que esse tipo de prática não é recomendada. Entre as boas práticas da programação está a
sugestão de usar variáveis globais apenas quando absolutamente necessário. Como variáveis globais
podem ser acessadas e ter seu valor alterado por qualquer parte do programa, fica difícil saber que
partes podem influenciar ou serem influenciadas pelas variáveis globais, o que torna todo o programa
mais difícil de entender. Para o exemplo das notas, é melhor e mais de acordo com boas práticas de
programação comunicar as notas para a função calc_media usando parâmtros, como segue:
Código fonte
Cálculo de raízes de uma equação de segundo grau
1 #include <stdio.h>
2

3 float calc_media(float n1, float n2, float n3) {

4 return (n1 + n2 + n3) / 3.0;
5 }
6

7 int main() {
8 float nota1, nota2, nota3;
9

10 printf("Entre as três notas: ");

11 scanf("%f %f %f", &nota1, &nota2, &nota3);
12

13 printf("Media: %f\n", calc_media(nota1, nota2, nota3));

14

15 return 0;
16 }

Este código funciona corretamente e evita o uso desnecessário de variáveis globais.

5.5.1 Escopo dos Parâmetros

Uma pergunta que pode surgir (especialmente após o exemplo anterior) é “qual o escopo dos parâme-
tros das funções?” A resposta é simples: para questões de visibilidade, o escopo dos parâmetros das
funções é o escopo local da função da qual eles pertencem. Ou seja, os parâmetros de uma função
funcionam exatamente como variáveis locais declaradas dentro da função.

5.5.2 Sombreamento e Sobreposição de Escopos

O que acontece se duas variáveis tiverem o mesmo nome em um só programa? A resposta depende
de onde as variáveis em questão são declaradas.

78 / 92
 Introdução à Programação

Não podem existir duas variáveis de mesmo nome em um mesmo escopo; um programa que tente
declarar duas variáveis de mesmo nome no mesmo escopo ocasionará um erro quando for compilado.
Assim, não podem existir duas variáveis globais de nome x ou duas variáveis de nome y em uma
mesma função.
Em escopos diferentes a regra muda: variáveis de mesmo nome podem existir em um programa se
forem declarados em escopos distintos. Isso é bastante útil: imagine um programa com 20 ou 30
mil linhas de código (o que hoje em dia é considerado um programa de pequeno a médio porte); um
programa deste tamanho precisa usar um grande número de variáveis, se cada uma delas precisasse
ter um nome diferente de todas as outras, seria muito difícil dar nomes a vários milhares de variáveis.
Imagine que um programa deste tamanho pode ter mais de mil laços for, cada um com uma variável
de controle, e cada uma dessas variáveis teria que ter um nome diferente. Por isso, as regras de
escopo também são úteis para estabelecer espaços locais onde os nomes não entram em conflitos com
os nomes de outros escopos locais.
Quando temos duas variáveis de mesmo nome em diferentes escopos locais, ou seja, duas funções
diferentes, o resultado é simples, já que essas variáveis de mesmo nome nunca seriam visíveis no
mesmo local do programa. Mas e se tivermos duas variáveis de mesmo nome, sendo uma variável
local e uma global? Neste caso, dentro da função que declara a variável com mesmo nome da global,
existirão duas variáveis que poderiam ser visíveis com o mesmo nome. O que acontece nesses casos é
chamado de sombreamento: a variável do escopo local esconde a variável do escopo global. Vamos
ilustrar essa regra com um exemplo:
Código fonte
Exemplo de sombreamento de variáveis globais
1 #include <stdio.h>
2

3 int x = 5; // 1x
4

5 void f() {
6 int x = 60; // 2x
7 int y = x * x; // 3x
8

9 printf("x = %d, y = %d\n", x, y);

10 }
11

12 int g() {
13 int y = x * x; // 4x
14

15 return y;
16 }
17

18 int main() {
19 f();
20

21 printf("g = %d\n", g());

22

23 return 0;
24 }

x
1 Declaração da variável global x.

79 / 92
 Introdução à Programação

x
2 Declaração da variável local x na função f.
x
3 Declaração da variável local y na função f.
x
4 Declaração da variável local y na função g.

Vemos no exemplo que existe uma variável global chamada x e uma variável local x na função f.
A função f também tem uma variável local chamada y, e há uma variável local de mesmo nome na
função g. As variáveis chamadas y em f e g não interferem, pois são escopos totalmente diferentes.
Já as variáveis chamadas x interferem, já que uma está no escopo global e outra está no escopo local
da função f. A questão é: o que é impresso pelo programa? Isso depende dos valores de x dentro
da função f e na função g (que usa x para calcular o valor de y, que é retornado). A execução do
programa imprime o seguinte:
Resultado da execução do programa code/cap5/sombra.c
x = 60, y = 3600
g = 25

A primeira linha é o que é impresso na função f. Como existe uma variável local x declarada em f,
dentro da função f a variável x tem o valor 60, como declarado; o valor de y calculado em f é, então,
60 × 60 = 3600. Já na função g não existe uma variável x local, então o valor de x dentro de g é o
valor da variável global x, que é igual a 5; desta forma, y em g tem valor 5 × 5 = 25. Isso explica a
saída do programa como visto acima.

Nota
Uma consequência da regra de sombreamento é que dentro de funções que tenham variáveis
locais que escondem variáveis globais de mesmo nome, é impossível acessar ou utilizar
as variáveis globais escondidas. No exemplo anterior, dentro da função f é impossível ter
acesso à variável global x.

5.6 Passagem de Parâmetros

Com o que vimos até agora sobre parâmetros de funções, eles funcionam de maneira simples: o
código que chama uma função especifica expressões para cada um dos argumentos da função. Os
valores de cada expressão são calculados e transmitidos como o valor dos parâmetros declarados na
função.
Entretanto, isso não é suficiente para todos os casos em que podemos querer usar parâmetros. Por
exemplo, digamos que temos uma situação em que é necessário trocar o valor de duas variáveis, e
que isso é necessário várias vezes ao longo do programa. Para evitar repetição, a melhor solução é
escrever uma função que realiza a troca do valor de duas variáveis. O exemplo a seguir mostra o que
acontece quando tentamos fazer isso apenas com o que vimos até agora:
Código fonte
Tentativa de trocar o valor de duas variáveis usando uma função
1 #include <stdio.h>
2

3 void troca_variaveis(int a, int b) {

80 / 92
 Introdução à Programação

4 int temp = a;
5 a = b;
6 b = temp;
7

8 printf("Dentro de troca_variaveis: a = %d, b = %d\n", a, b);

9 }
10

11 int main() {
12 int x = 5;
13 int y = 7;
14

15 printf("Antes da troca: x = %d, y = %d\n", x, y);

16 troca_variaveis(x, y);
17 printf("Depois da troca: x = %d, y = %d\n", x, y);
18 }

Resultado da execução do programa

Antes da troca: x = 5, y = 7
Dentro de troca_variaveis: a = 7, b = 5
Depois da troca: x = 5, y = 7

Como se vê no resultado da execução do programa, embora as variáveis a e b realmente troquem de

valor dentro da função troca_variaveis, isso não afeta o valor das variáveis x e y em main.
Isso acontece porque, normalmente, os parâmetros em C são passados por valor, ou seja, apenas o
valor de x e y são copiados para a e b. Precisamos que as variáveis na função troca_variaveis,
de alguma maneira, afetem as variáveis que foram usadas como parâmetro, e para isso é necessário
usar o modo de passagem de parâmetros chamado de passagem por referência. A seguir, vamos ver
em maiores detalhes como funcionam esses dois modos de passagem de parâmetros.

5.6.1 Passagem por Valor

A passagem de parâmetros por valor é a situação padrão na linguagem C. Este modo de passagem de
parâmetros comunica apenas valores entre o código chamador e a função chamada.
A passagem por valor funciona da seguinte forma: para uma função f com N parâmetros, uma cha-
mada de f deve conter N expressões como argumentos (se o número de argumentos não corresponder
ao número de parâmetros declarados, o compilador acusará um erro no programa). Então o seguinte
processo de chamada de função acontece:

1. O valor de cada uma das N expressões usadas como argumento é calculado e guardado;

2. N variáveis locais são criadas para a função chamada, uma para cada parâmetro da função, e
usando o nome declarado na função;

3. Os valores calculados no passo 1 são atribuídos às variáveis criadas no passo 2.

4. O corpo da função f é executado.

Como as variáveis criadas para os parâmetros são locais, elas deixam de existir quando a função
chamada termina, e isso não tem nenhum efeito nas expressões que foram usadas para atribuir valor
aos parâmetros ao início da função. Isso significa que o programa para troca de valor de variáveis

81 / 92
Introdução à Programação

mostrado acima funciona de maneira similar ao seguinte programa (no qual colocamos o código da
função troca_variaveis diretamente na função main):
Código fonte
Troca do valor de duas variáveis usando outra variável temporária
#include <stdio.h>

int main() {
int x = 5;
int y = 7;

printf("Antes da troca: x = %d, y = %d\n", x, y);

// troca_variaveis
int a = x, b = y;
int temp = a;
a = b;
b = temp;
printf("Dentro de troca_variaveis: a = %d, b = %d\n", a, b);
// fim de troca_variaveis

printf("Depois da troca: x = %d, y = %d\n", x, y);

}

Neste caso, fica claro que as variáveis x e y são usadas apenas para obter o valor inicial das variáveis
a e b, e portanto a mudança de valor das duas últimas não deve afetar x e y.
A passagem de parâmetros por valor é simples e funciona bem na maioria dos casos. Mas em algumas
situações pode ser desejável ter uma forma de afetar variáveis externas à uma determinada função e,
para isso, usa-se a passagem de parâmetros por referência.

5.6.2 Passagem por Referência

A passagem de parâmetros por referência funciona passando para a função chamada referências para
variáveis ao invés de valores de expressões. Isso permite à função chamada afetar as variáveis usadas
como argumento para a função.
Vamos ilustrar como isso funciona demonstrando como criar uma função que troca o valor de duas
variáveis e realmente funciona:
Código fonte
Função para trocar o valor de duas variáveis usando passagem por referência
#include <stdio.h>

void troca_variaveis(int *a, int *b) { // 1x

int temp = *a;
*a = *b; // 2x
*b = temp;

printf("Dentro de troca_variaveis: a = %d, b = %d\n", *a, *b);

}

82 / 92
Introdução à Programação

int main() {
int x = 5;
int y = 7;

printf("Antes da troca: x = %d, y = %d\n", x, y);

troca_variaveis(&x, &y); // 3x

printf("Depois da troca: x = %d, y = %d\n", x, y);

}

x
1 Definição do procedimento. Os parâmetros a e b são declarados usando int * ao invés de
simplesmente int. Isso indica passagem por referência.
x
2 Ao usar as variáveis a e b que foram passadas por referência, é necessário usar *a e *b para
acessar ou modificar seu valor.
x
3 Na chamada da função troca_variaveis é preciso passar referências para as variáveis x e
y, isso é conseguido usando &x e &y.

Resultado da execução do programa code/cap5/troca_ref.c

Antes da troca: x = 5, y = 7
Dentro de troca_variaveis: a = 7, b = 5
Depois da troca: x = 7, y = 5

A primeira coisa a notar é que são necessárias algumas mudanças sintáticas para usar parâmetros
por referência. A declaração dos parâmetros no início da função agora define os parâmetros a e b
como tendo tipo int *. Quando esses parâmetros são usados na função troca_variaveis, eles
precisam ser precedidos de asterisco (*a ao invés de a). E para chamar a função, é preciso passar
referências para as variáveis x e y ao invés de passar seu valor, por isso usamos &x e &y na chamada.
De maneira simplificada, a passagem por referência funciona da seguinte forma: ao escrever um
argumento como &x para a função troca_variaveis, não estamos passando o valor de x
para a função, mas sim uma referência para a própria variável x. Isso significa que, dentro de
troca_variáveis, o parâmetro a se torna um nome diferente para a mesma variável x; desta
forma, alterações feitas em a (através da sintaxe *a) são alterações também no valor da variável ori-
ginal x. É por isso que o programa acima funciona, como pode ser visto no resultado da execução:
a função troca_variaveis recebe referências para as variáveis x e y, e por isso pode alterar o
valor destas variáveis diretamente, trocando o valor das duas.
A passagem de parâmetros por referência é usada quando uma função precisa alterar o valor de uma
variável que existe fora da própria função e que não necessariamente é uma variável global. O mesmo
efeito de ter uma função alterando uma variável externa poderia ser atingido usando variáveis globais
ao invés de passagem por referência, mas com grande perda de flexibilidade. Além disso, o uso
desnecessário de variáveis globais não é recomendado, como comentado antes.

[Link] Realizando troca de valores com variáveis globais

Uma outra forma de trocar os valores de duas variáveis, dentro de uma função, poderia ser elabo-
rada utilizando variáveis globais. Por exemplo, poderíamos trocar os valores das variáveis x e y no
exemplo anterior se ambas fossem alteradas para serem variáveis globais:

83 / 92
Introdução à Programação

Código fonte
Função para trocar o valor de duas variáveis globais
#include <stdio.h>

int x = 5; // 1x
int y = 7;

void troca_variaveis() { // 2x
int temp = x;
x = y;
y = temp;

printf("Dentro de troca_variaveis: x = %d, y = %d\n", x, y);

}

int main() {
printf("Antes da troca: x = %d, y = %d\n", x, y);
troca_variaveis();
printf("Depois da troca: x = %d, y = %d\n", x, y);
}

x
1 x e y agora são variáveis globais.
x
2 troca_variaveis não utiliza parâmetros, já que acessa diretamente as variáveis globais.

Resultado da execução do programa

Antes da troca: x = 5, y = 7
Dentro de troca_variaveis: x = 7, y = 5
Depois da troca: x = 7, y = 5

O programa funciona, mas note que agora troca_variaveis só altera o valor de duas variáveis
específicas, x e y, enquanto que a versão usando passagem por referência era geral e podia trocar o
valor de quaisquer duas variáveis inteiras. Se um programa precisa trocar os valores de vários pares
de variáveis, em vários locais diferentes, seria preciso criar uma função de troca para cada par, e
fazer todas as variáveis serem globais. Isso acarretaria em muita repetição, e muito uso desnecessário
de variáveis globais que tornariam a manutenção do código muito mais difícil. Neste caso, é muito
mais recomendado usar a passagem por referência para chegar a um código mais geral, mais fácil de
manter e com menos repetição.

Nota
A passagem por referência vem sido usada neste livro há vários capítulos, pois a função
scanf (Seção 2.10.2 [28]) usa esse modo de passagem de parâmetros. Em toda chamada
a scanf passamos referências para as variáveis que vão receber os valores, e não os
valores dessas variáveis. Isso faz sentido já que scanf precisa alterar o valor das variáveis
passadas como parâmetro, e ao mesmo tempo scanf não utiliza o valor original dessas
variáveis para nada.

84 / 92
Introdução à Programação

Nota
Com a passagem por referência e por valor na linguagem C acontece algo semelhante ao
que vimos com os conceitos de procedimento e função: a rigor na linguagem C só existe a
passagem por valor, mas a passagem por referência pode ser obtida pelo uso de ponteiros,
um conceito avançado da linguagem C. Como se trata de um conceito avançado, não vamos
detalhar mais sobre eles aqui neste livro.

5.7 Protótipos e Declaração de Funções

Em todos os exemplos que vimos neste capítulo até agora, nós sempre definimos uma função antes
de chamá-la em outra função. Nesses exemplos, a função main sempre aparece no final do arquivo,
já que as chamadas para as outras funções apareciam apenas em main.
Mas em muitos casos pode ser necessário chamar uma função que é definida posteriormente no ar-
quivo, sem precisar mudar as funções de lugar. O mesmo ocorre em programas maiores, quando
usamos vários arquivos de código-fonte para um programa (mas este caso não será detalhado aqui).
Se tentarmos usar uma função antes de sua definição vamos observar um erro de compilação. No
exemplo abaixo, a intenção é definir uma função que imprime a situação de um aluno em uma disci-
plina cuja média é 7.0. Para isso é necessário passar para a função as três notas do aluno na disciplina.
Mas se definirmos a função após main, como abaixo:
Código fonte
Chamando uma função antes de sua definição
#include <stdio.h>

int main() {
float nota1, nota2, nota3;

printf("Entre as três notas: ");

scanf("%f %f %f", &nota1, &nota2, &nota3);

situacao(nota1, nota2, nota3); // 1x

return 0;
}

void situacao(float n1, float n2, float n3) { // 2x

float media = (n1 + n2 + n3) / 3.0;

printf("Media %f, ", media);

if (media >= 7.0)
printf("Aluno aprovado\n");
else if (media < 4.0)
printf("Aluno reprovado por media\n");
else
printf("Aluno na prova final");
}

x
1 A função main chama situacao antes de sua definição.

85 / 92
Introdução à Programação

x
2 A definição de situacao começa após a função main.

Ao tentar compilar esse programa, um erro similar ao seguinte será acusado:

Resultado da execução do programa
situacao.[Link] error: conflicting types for ’situacao’
void situacao(float n1, float n2, float n3) { // 1x

Isso acontece porque o compilador não pode identificar se a função foi realmente definida em algum
lugar e, principalmente, se o tipo dos parâmetros e o tipo do retorno da função estão sendo usados
corretamente.
Esse problema pode ser resolvido através do uso de protótipos para declarar uma função antes que
seja definida. Um protótipo de função é uma declaração que especifica as seguintes informações:

1. O tipo de retorno da função;

2. O nome da função;
3. O número de parâmetros;
4. Os tipos de cada um dos parâmetros.

Com essas informações, o compilador pode identificar se a função está sendo usada de maneira correta
com relação aos tipos, e evita os erros anteriores.
Para consertar o erro no exemplo anterior basta adicionar uma linha com o protótipo da função:
Código fonte
Usando protótipos de funções
#include <stdio.h>

// Prototipo da funcao situacao

void situacao(float, float, float); // 1x

int main() {
float nota1, nota2, nota3;

printf("Entre as três notas: ");

scanf("%f %f %f", &nota1, &nota2, &nota3);

situacao(nota1, nota2, nota3); // 2x

}

void situacao(float n1, float n2, float n3) {

float media = (n1 + n2 + n3) / 3.0;

printf("Media %f, ", media);

if (media >= 7.0)
printf("Aluno aprovado\n");
else if (media < 4.0)
printf("Aluno reprovado por media\n");
else
printf("Aluno na prova final");
}

86 / 92
Introdução à Programação

x
1 Protótipo da função situacao. Note que o protótipo inclui o tipo de retorno (void), o nome
da função, que a função aceita três parâmetros, e que todos eles possuem tipo float. Não
é preciso especificar o nome dos parâmetros em um protótipo, mas é possível especificar os
nomes, se desejado; incluir os nomes dos parâmetros pode ser útil como uma forma simples de
documentação.
x, 2x A
1 chamada a situacao em main agora pode acontecer sem problema.

Resultado da execução do programa

Entre as três notas: 6.8 5.2 9.0
Media 7.000000, Aluno aprovado

Nesse exemplo, seria possível consertar o problema simplesmente movendo a função situacao
completa para antes da função main, mas em programas maiores o uso de protótipos toma grande
importância.

5.8 Funções Recursivas

Uma função pode ser chamada a partir de qualquer outra função no mesmo programa. Dessa forma,
podemos pensar em uma função chamando a si mesma. Isso é possível e útil em muitos casos.
Quando uma função f chama a si mesma em algum ponto, dizemos que f é uma função recursiva.
Recursividade se refere a um objeto auto-referente, ou seja, que referencia a si próprio; isso inclui as
funções recursivas mas também outros tipos de objetos.
Um exemplo é o cálculo do fatorial de um número. O fatorial de um número inteiro positivo N (cuja
notação é N!) é definido como o produto de todos os números de 1 até N:

N! = N × (N − 1) × · · · × 2 × 1

Por exemplo, o fatorial de 3 é 3! = 3 × 2 × 1 = 6, e o fatorial de 4 é 4! = 4 × 3 × 2 × 1 = 24, e assim

por diante. Para números N maiores que 1, sempre podemos fazer a seguinte relação:

N! = N × (N − 1)!

ou seja, 4! = 4 × 3! = 4 × 6 = 24. Isso indica a estrutura recursiva do cálculo do fatorial: o fatorial de

um número N é igual a N vezes o fatorial do número anterior a N, N-1.
Seguindo essa ideia, podemos escrever uma função recursiva que calcula o valor do fatorial de um
número. Como a função chama a si mesma, é muito importante saber quando a cadeia de chamadas
da função a ela mesma termina. No caso do fatorial, quando queremos calcular o fatorial do número
1 ou do número 0, podemos responder diretamente: 1! = 0! = 1, sem usar a recursividade. Esse
é o chamado caso-base da recursão. Sem isso, a função nunca pararia de chamar a si mesmo, e
o programa seria finalizado com algum erro dependente do sistema operacional e do compilador
utilizados.
O programa com a função que calcula o fatorial é o seguinte:
Código fonte
Cálculo do fatorial usando uma função recursiva

87 / 92
Introdução à Programação

#include <stdio.h>

// prototipo
int fatorial(int); // 1x

int main() {
int n;

printf("Entre o numero para calcular o fatorial: ");

scanf("%d", &n);

printf("%d! = %d\n", n, fatorial(n));

return 0;
}

int fatorial(int n) {
if (n == 0 || n == 1)
return 1; // 2x
else
return n * fatorial(n - 1); // 3x
}

x
1 Protótipo da função fatorial.
x
2 Caso-base na função fatorial: para n igual a 0 ou 1, retorna 1.
x
3 Caso recursivo na função fatorial: se n for maior que 1, retorne n multiplicado pelo fatorial
de n - 1.

Resultado de três execuções do programa code/cap5/fatorial.c

Entre o numero para calcular o fatorial: 4
4! = 24

Entre o numero para calcular o fatorial: 5

5! = 120

Entre o numero para calcular o fatorial: 6

6! = 720

O código calcula o fatorial de um número inteiro recursivamente. Se o número for 0 ou 1, a resposta é

direta: 1. Se o número for maior do que 0 ou 1, a resposta é obtida pela multiplicação do número pelo
fatorial do número anterior a ele. Note que esse processo sempre termina se o parâmetro n da função
fatorial for um inteiro positivo, pois em cada chamada recursiva o argumento da função fatorial será
um número menor que o anterior, até eventualmente chegar a 1, cuja resposta é direta. Como a função
tem um parâmetro declarado como inteiro, o compilador C não permitiria passar como parâmetro um
número não-inteiro, então, isso não pode criar problema para essa função recursiva. Entretanto, um
erro que pode acontecer neste caso é se o usuário especificar um número negativo:
Cálculo do fatorial usando número negativo, usando o programa code/cap5/fatorial.c

88 / 92
Introdução à Programação

Entre o numero para calcular o fatorial: -4

Segmentation fault: 11

A falha de segmentação (segmentation fault) mostrada quando se passa um argumento negativo para
a função fatorial é o resultado da recursão infinita que ocorre na função: como em cada etapa
o número é diminuído de um, um número negativo nunca vai chegar a 1 (ou 0) e portanto nunca vai
parar no caso-base. Mesmo a noção matemática do fatorial não está definida para números negativos.
Uma forma de consertar o programa acima seria imprimir um erro quando fatorial fosse chamado
com um argumento negativo, ou retornar um valor qualquer, sem chamar a função recursivamente.
Uma forma de fazer isso seria mudando o teste do caso base:
Código fonte
Cálculo do fatorial com alteração do teste do caso base
#include <stdio.h>

// prototipo
int fatorial(int);

int main() {
int n;

printf("Entre o numero para calcular o fatorial: ");

scanf("%d", &n);

printf("%d! = %d\n", n, fatorial(n));

return 0;
}

int fatorial(int n) {
if (n <= 1) // 1x
return 1;
else
return n * fatorial(n - 1);
}

x
1 Caso-base da função fatorial. O teste agora é se o parâmetro é menor ou igual a 1, o que
inclui os números negativos. Neste caso, a função retorna 1 sem fazer chamadas recursivas.

Resultado de duas execuções do programa code/cap5/fatorial2.c

Entre o numero para calcular o fatorial: 5
5! = 120
Sandman:funcoes andrei$ ./fat
Entre o numero para calcular o fatorial: -4
-4! = 1

Neste caso, a função sempre retorna 1 para números negativos, o que é um resultado estranho, mas
como o fatorial não está definido para números negativos, isso não chega a ser um grande problema.

89 / 92
Introdução à Programação

A recursividade é um conceito de programação considerado avançado, mas se torna bastante im-

portante em programas mais complexos. Alguns paradigmas de programação como a programação
funcional e a programação lógica são bastante baseadas no uso de funções recursivas, e muitos pro-
cessos se tornam muito mais fáceis de implementar usando funções recursivas. Por isso, apesar de
não entrarmos em mais detalhes sobre funções recursivas aqui, é importante ter em mente que esse é
um dos conceitos que se tornam importantes para a evolução de um programador.

5.9 Recapitulando

Neste capítulo, vimos uma importante ferramenta para a criação de programas na linguagem C: fun-
ções. As funções (e os procedimentos, que são tratados na linguagem C como funções) possibilitam
a reutilização de trechos de código em várias partes de um programa, e permitem isolar determi-
nadas componentes do programa em unidades mais autocontidas, melhorando a modularização do
programa. É raro que um programa não-trivial na linguagem C não faça uso de funções.
Vimos exemplos do uso de procedimentos (funções que não retornam valores) com e sem parâmetros.
Vimos também como usar parâmetros para funções e como retornar valores a partir de uma função.
As regras que regem a visibilidade de variáveis locais, globais e parâmetros de funções foram apre-
sentadas, assim como os diferentes modos de passagem de parâmetros e como utilizá-los: passagem
por valor e por referência.
Também vimos como declarar funções usando protótipos, para poder utilizar essas funções antes de
sua definição (ou em arquivos diferentes de onde elas estão definidas). Um exemplo simples de função
recursiva foi mostrado, como forma de introdução ao conceito.
Compreender o conteúdo deste capítulo é extremamente importante para aprender a programar bem
na linguagem C.

5.10 Exercícios Propostos

1. Escreva uma função que calcula a média final de um aluno que fez prova final em uma disci-
plina. A função deve receber a média parcial do aluno (média das notas nas provas regulares da
disciplina) e a nota obtida na prova final. O cálculo para a média final é
MF = 6×MP+4×PF
10 onde MF é a média final, MP é a média parcial e PF é a nota da prova
final. Escreva um programa que utiliza esta função, pedindo os dados necessários ao usuário e
imprimindo o valor da média final na tela.

2. Às vezes é útil limpar a "tela"antes de imprimir informações adicionais no console. Uma forma
de limpar a tela é imprimir mais de 24 linhas em branco (dependendo do tamanho do console).
Em geral, imprimir 30 linhas em branco deve ser suficiente. Escreva uma função (procedi-
mento) que limpe a tela imprimindo 30 linhas em branco.

3. Escreva uma função que recebe dois parâmetros a e b e troca o valor de a com o valor de b se
o valor de a for maior do que o de b; o objetivo é ter, ao final, o menor dos dois valores em a e
o maior em b. Por exemplo, se a = 5 e b = 3, então os valores das duas variáveis devem ser
trocados, mas se a = 2 e b = 7, então a ordem já está correta e não é necessário trocar os
valores. Utilize passagem de parâmetros por referência para poder afetar o valor das variáveis.
Escreva um programa para testar a função.

90 / 92
Introdução à Programação

4. O que é impresso pelo seguinte programa?

Código fonte
#include <stdio.h>

int x = 5;
int y = 9;

int f(int x) {
int z = x * x;
return z * y;
}

int main() {
int y = 3;

printf("%d \n", x);

printf("%d \n", f(y));

return 0;
}

Feedback sobre o capítulo

Você pode contribuir para melhoria dos nossos livros. Encontrou algum erro? Gostaria de
submeter uma sugestão ou crítica?
Para compreender melhor como feedbacks funcionam consulte o guia do curso.

91 / 92