Diferença entre passagem de parametro por valor e por referencia

Passagem de par�metros por valor e passagem por refer�ncia

J� vimos que, na linguagem C, quando chamamos uma fun��o os par�metros formais da fun��o copiam os valores dos par�metros que s�o passados para a fun��o. Isto quer dizer que n�o s�o alterados os valores que os par�metros t�m fora da fun��o. Este tipo de chamada de fun��o � denominado chamada por valor. Isto ocorre porque s�o passados para a fun��o apenas os valores dos par�metros e n�o os pr�prios par�metros. Veja o exemplo abaixo:

#include <stdio.h>
float sqr (float num);
void main ()
{
	float num,sq;
	printf ("Entre com um numero: ");
	scanf ("%f",&num);
	sq=sqr(num);
	printf ("\n\nO numero original e: %f\n",num);
	printf ("O seu quadrado vale: %f\n",sq);
}

float sqr (float num)
{
	num=num*num;
	return num;
}

No exemplo acima o par�metro formal num da fun��o sqr() sofre altera��es dentro da fun��o, mas a vari�vel num da fun��o main() permanece inalterada: � uma chamada por valor.

 Outro tipo de passagem de par�metros para uma  fun��o ocorre quando altera��es nos par�metros formais, dentro da fun��o, alteram os valores dos par�metros que foram passados para a fun��o. Este tipo de chamada de fun��o tem o nome de "chamada por refer�ncia". Este nome vem do fato de que, neste tipo de chamada, n�o se passa para a fun��o os valores das vari�veis, mas sim suas refer�ncias (a fun��o usa as refer�ncias para alterar os valores das vari�veis fora da fun��o).

 O C s� faz chamadas por valor. Isto � bom quando queremos usar os par�metros formais � vontade dentro da fun��o, sem termos que nos preocupar em estar alterando os valores dos par�metros que foram passados para a fun��o. Mas isto tamb�m pode ser ruim �s vezes, porque podemos querer mudar os valores dos par�metros fora da fun��o tamb�m. O C++ tem um recurso que permite ao programador fazer chamadas por refer�ncia. H� entretanto, no C, um recurso de programa��o que podemos usar para simular uma chamada por refer�ncia.

 Quando queremos alterar as vari�veis que s�o passadas para uma fun��o, n�s podemos declarar seus par�metros formais como sendo ponteiros. Os ponteiros s�o a "refer�ncia" que precisamos para poder alterar a vari�vel fora da fun��o. O �nico inconveniente � que, quando usarmos a fun��o, teremos de lembrar de colocar um & na frente das vari�veis que estivermos passando para a fun��o. Veja um exemplo:

#include <stdio.h>
void Swap (int *a,int *b);
void main (void)
{
	int num1,num2;
	num1=100;
	num2=200;
	Swap (&num1,&num2);
	printf ("\n\nEles agora valem %d  %d\n",num1,num2);
}
void Swap (int *a,int *b)
{
	int temp;
	temp=*a;
	*a=*b;
	*b=temp;
}

N�o � muito dif�cil. O que est� acontecendo � que passamos para a fun��o Swap o endere�o das vari�veis num1 e num2. Estes endere�os s�o copiados nos ponteiros a e b. Atrav�s do operador * estamos acessando o conte�do apontado pelos ponteiros e modificando-o. Mas, quem � este conte�do? Nada mais que os valores armazenados em num1 e num2, que, portanto, est�o sendo modificados!

Espere um momento... ser� que n�s j� n�o vimos esta est�ria de chamar uma fun��o com as vari�veis precedidas de &? J�! � assim que n�s chamamos a fun��o scanf(). Mas porqu�? Vamos pensar um pouco. A fun��o scanf() usa chamada por refer�ncia porque ela precisa alterar as vari�veis que passamos para ela! N�o � para isto mesmo que ela � feita? Ela l� vari�veis para n�s e portanto precisa alterar seus valores. Por isto passamos para a fun��o o endere�o da vari�vel a ser modificada!

Veja como voc� est�:
  Escreva uma fun��o que receba duas vari�veis inteiras e "zere" o valor das vari�veis.  Use o que voc� aprendeu nesta p�gina para fazer a implementa��o

Curso de C do CPDEE/UFMG - 1996 - 1999

Por: Eduardo Casavella

Existem dois métodos de passagem de parâmetros para funções:

Passagem por valor – permite usar dentro de uma função uma cópia do valor de uma variável, porém não permite alterar o valor da variável original (somente a cópia pode ser alterada).

Passagem por referência – É passada para a função uma referência da variável, sendo possível alterar o conteúdo da variável original usando-se esta referência.

Na linguagem C a passagem por referência é implementada com o uso de ponteiros.

Usando ponteiros (também chamados de apontadores) é possível alterar os valores das variáveis passadas como argumentos para uma função.

A função utilizada dessa forma é denominada função com passagem por referência. Nesse tipo de função, os argumentos passam os endereços de memória para os parâmetros declarados na função. Sendo assim, os parâmetros que recebem os valores passados obrigatoriamente tem que ser ponteiros já que irão receber um endereço de memória.

A seguir temos o código fonte do exemplo mostrado no vídeo.

Exemplo 1 – Função com passagem por referência

#include <stdio.h>

//função que soma 10 ao valor recebido
void soma10(int x)
{
  x = x + 10;  
  printf("Valor de x apos a soma = %d \n",x);
  return;
}

void soma10p(int *x)
{
  *x = *x + 10;  
  printf("Valor de x apos a soma = %d \n",*x);
  return;
}

int main(void)
{
  int numero;
  printf("Digite um numero: ");
  scanf("%d", &numero);  
     
  printf("O numero digitado foi: %d \n",numero);  
  
  soma10(numero);  //chamada da função
  printf("Agora o numero vale: %d \n",numero);    
  
  soma10p(&numero);  //chamada da função com ponteiro como parâmetro
  printf("Agora o numero vale: %d \n",numero);  
  return 0;
}

As alterações feitas dentro da função tem efeito direto nas variáveis passadas como argumentos na chamada. Isto proporciona a oportunidade de retornar vários valores em uma única função já que as alterações ocorrem diretamente nas variáveis.

Veja outro exemplo a seguir onde usamos uma função com dois parâmetros por referência.

Exemplo 2 – função que troca de valores na main

O objetivo do programa abaixo é receber dois valores na main e depois, através de uma função fazer a troca dos valores recebidos nas variáveis sendo que estes valores já trocados devem ser mostrados dentro da main.

#include <stdio.h>
#include <conio.h>

//função com passagem por referência
//note que a função tem dois ponteiros como parâmetros
void troca_valores(int *ptrx, int *ptry);

int main(void)
{
	int a, b;
	printf("Digite o primeiro valor: ");
	scanf("%d", &a);
	
	printf("Digite o segundo valor: ");
	scanf("%d", &b);
	
	printf("Voce digitou os valores na seguinte ordem: %d e %d\n", a, b);
	
	/* Chamada da função que troca os valores das variáveis a e b.
	Observe como são passados os endereços nos argumentos.
	Esta é uma função chamada por referência */
	troca_valores(&a, &b);
	
	//Exibindo os valores já trocados após a chamada da função
	printf("Os valores trocados sao: %d e %d\n", a, b);
	
	getch();
	return 0;
}

//função que troca os valores inteiros apontados por ptrx e ptry
void troca_valores(int *ptrx, int *ptry)
{
	int auxiliar;
	
	//auxiliar recebe o conteúdo apontado por ptrx
	auxiliar = *ptrx;
	
	//coloca o valor que está no local apontado por ptry em ptrx
	*ptrx = *ptry;
	
	//finalmente, ptry recebe o valor armazenado em auxiliar
	*ptry = auxiliar;
	
	return;
}

Tela de Execução

Tela de execução com passagem de parâmetros por referência.

Até a próxima!

O que é passagem de parâmetros por referência?

O que é passagem por valor?

Quais são os tipos de passagem de parâmetros utilizados?

Quais são as duas maneiras de se fazer a passagem de parâmetros existentes?