Aula 07: Funções e Passagem de Parâmetros

Como vimos na aula anterior, as funções recebem argumentos através de seus parâmetros formais e retornam valores.

Se a função for do tipo void (não-valor), ela simplesmente não retornará valor. Mas, se a função for do tipo inteira (int), caracter (char), real (float ou double), apenas para citar alguns tipos de dados, ela retornará algum valor para a função que a invocou (chamou).

Da forma que vimos, as funções podem receber diversos argumentos, mas retornam apenas UM valor. Essa forma de passagem de parâmetros é chamada de Passagem de Parâmentros por Valor. Ou seja, no momento em que o argumento é passado para a função, seja ele uma expressão ou variável, é o seu VALOR quem é copiado para o parâmetro formal. Desse jeito, ao alterar o conteúdo (valor) do parâmetro formal NÃO modificamos o argumento de entrada.

Vejamos um exemplo para trocar dois valores:

#include "stdio.h"

void swap(int x, int y);

int main(){
  int a = 2, b = 3;
  
  printf("Valores originais:\n");
  printf("a = %d\nb = %d\n\n", a, b);
  
  swap(a, b);
  
  printf("Valores foram modificados?:\n");
  printf("a = %d\nb = %d\n\n", a, b);

  getchar(); 
  return 0;
}

void swap(int x, int y) {
   int aux;
   
   aux = x;
   x = y;
   y = aux;
   
   return;
}

Após compilar e executar, você percebeu que não ocorreu troca alguma. Então esse tipo de passagem de parâmetros não nos serve para este exemplo.

Precisamos ter mais valores de retorno. Então, vem a pergunta: e quando precisamos ter N valores de retorno, o que fazemos?

Precisamos de usar a Passagem de Parâmetro por Referência.

Assim, ao enviar os argumentos (variáveis de entrada) à função, é seu ENDEREÇO DE MEMÓRIA (REFERÊNCIA) quem é copiado para o parâmetro formal. Isso significa que, ao alterar o valor do parâmetro formal, estaremos alterando o argumento de entrada.

Portanto, poderemos enviar diversos argumentos utilizando da passagem de parâmetros por referência para alterar os argumentos de entrada. Simples não? NÃO.

Para isso, precisamos de alguns conhecimentos sobre ponteiros.

Ponteiros são variáveis especiais que armazemam endereços de memória.

Vejamos um exemplo:

#include 
int main(){
   int num = 5;
   int *p; //isso é um ponteiro

   printf("O valor armazenado em num vale = %d\n", num);
   printf("O endereco de memoria de num = %d\n", &num);

   p = #  //um ponteiro só pode receber um endereço 
              //de memória de mesmo tipo de dado 
              //do ponteiro

//O endereco da var. num, visto atraves do ponteiro p
   printf("Endereco de num = %d\n", p);

//O valor da variavel num, visto atraves do ponteiro p
   printf("Valor de num = %d\n", *p);

//O endereco de memoria do ponteiro p
   printf("O endereco de p = %d\n", &p); 
  
   getchar();
   return 0;
}

Agora que você teve uma introdução aos ponteiros, vamos refazer o exemplo da troca de dois números, usando uma função com passagem de parâmetros por referência.

#include "stdio.h"

void swap(int *x, int *y); //perceba os ponteiros aí

int main(){
  int a = 2, b = 3;
  
  printf("Valores originais:\n");
  printf("a = %d\nb = %d\n\n", a, b);
  
  swap(&a, &b); 
//estamos passando os endereços das 
//variáveis para os ponteiros
  
  printf("Valores foram modificados?:\n");
  printf("a = %d\nb = %d\n\n", a, b);

  system("PAUSE"); 
  return 0;
}

void swap(int *x, int *y) {
   int aux;
   
   aux = *x;
   *x = *y;
   *y = aux;
}

É isso aí! Mesmo a função sendo void (sem retorno) conseguimos trocar os valores das variáveis originais (ter dois retornos). Isso, graças aos ponteiros!

Benditos ponteiros!!! :)

Agora é só fazer os exercícios da aula 07.

Retornar ao índice do curso.
Avançar à próxima aula.