Passando por referência em C

Se C não suporta a passagem de uma variável por referência, por que isso funciona?

#include <stdio.h>

void f(int *j) {
  (*j)++;
}

int main() {
  int i = 20;
  int *p = &i;
  f(p);
  printf("i = %d\n", i);

  return 0;
}

Resultado:

$ gcc -std=c99 test.c
$ a.exe
i = 21 

Como você está passando o valor do ponteiro para o método e desreferenciando-o para obter o número inteiro apontado.

Isso não é passar por referência, é passar por valor, como outros declararam.

A linguagem C é transmitida por valor, sem exceção. Passar um ponteiro como parâmetro não significa passagem por referência.

A regra é a seguinte:

Uma função não pode alterar o valor real dos parâmetros.

Vamos tentar ver as diferenças entre os parâmetros escalar e ponteiro de uma função.

Variáveis ​​escalares

Este pequeno programa mostra a passagem por valor usando uma variável escalar. paramé chamado de parâmetro formal e, variablena chamada de função, é chamado de parâmetro real. A nota incrementada paramna função não muda variable.

#include <stdio.h>

void function(int param) {
    printf("I've received value %d\n", param);
    param++;
}

int main(void) {
    int variable = 111;

    function(variable);
    printf("variable %d\m", variable);
    return 0;
}

O resultado é

I've received value 111
variable=111

Ilusão de passagem por referência

Mudamos um pouco o código. paramé um ponteiro agora.

#include <stdio.h>

void function2(int *param) {
    printf("I've received value %d\n", *param);
    (*param)++;
}

int main(void) {
    int variable = 111;

    function2(&variable);
    printf("variable %d\n", variable);
    return 0;
}

O resultado é

I've received value 111
variable=112

Isso faz você acreditar que o parâmetro foi passado por referência. Não era. Foi passado por valor, o valor do parâmetro sendo um endereço. O valor do tipo int foi incrementado, e esse é o efeito colateral que nos faz pensar que era uma chamada de função de passagem por referência.

Ponteiros - passados ​​por valor

Como podemos mostrar / provar esse fato? Bem, talvez possamos tentar o primeiro exemplo de variáveis ​​escalares, mas, em vez de escalares, usamos endereços (ponteiros). Vamos ver se isso pode ajudar.

#include <stdio.h>

void function2(int *param) {
    printf("param's address %d\n", param);
    param = NULL;
}

int main(void) {
    int variable = 111;
    int *ptr = &variable;

    function2(ptr);
    printf("ptr's address %d\n", ptr);
    return 0;
}

O resultado será que os dois endereços são iguais (não se preocupe com o valor exato).

Resultado de exemplo:

param's address -1846583468
ptr's address -1846583468

Na minha opinião, isso prova claramente que os ponteiros são passados ​​por valor. Caso contrário, ptrseria NULLapós a chamada da função.

Em C, passagem por referência é simulada passando o endereço de uma variável (um ponteiro) e desreferenciando esse endereço na função para ler ou gravar a variável real. Isso será chamado de "passagem C por referência ao estilo C."

Fonte: www-cs-students.stanford.edu

Porque não há passagem por referência no código acima. O uso de ponteiros (como void func(int* p)) é passado por endereço. Isso é passado por referência em C ++ (não funcionará em C):

void func(int& ref) {ref = 4;}

...
int a;
func(a);
// a is 4 now

Seu exemplo funciona porque você está passando o endereço da sua variável para uma função que manipula seu valor com o operador de desreferência .

Embora C não suporte tipos de dados de referência , você ainda pode simular a passagem por referência passando explicitamente os valores do ponteiro, como no seu exemplo.

O tipo de dados de referência C ++ é menos poderoso, mas considerado mais seguro que o tipo de ponteiro herdado de C. Este seria o seu exemplo, adaptado para usar referências C ++ :

void f(int &j) {
  j++;
}

int main() {
  int i = 20;
  f(i);
  printf("i = %d\n", i);

  return 0;
}

Você está passando um ponteiro (local do endereço) por valor .

É como dizer "aqui é o lugar com os dados que eu quero que você atualize".

p é uma variável de ponteiro. Seu valor é o endereço de i. Quando você chama f, passa o valor de p, que é o endereço de i.

Nenhuma passagem por referência em C, mas p "refere-se" a i e você passa p por valor.

Em C, tudo passa por valor. O uso de ponteiros nos dá a ilusão de que estamos passando por referência porque o valor da variável muda. No entanto, se você imprimir o endereço da variável ponteiro, verá que ela não é afetada. Uma cópia do valor do endereço é passada para a função. Abaixo está um trecho que ilustra isso.

void add_number(int *a) {
    *a = *a + 2;
}

int main(int argc, char *argv[]) {
   int a = 2;

   printf("before pass by reference, a == %i\n", a);
   add_number(&a);
   printf("after  pass by reference, a == %i\n", a);

   printf("before pass by reference, a == %p\n", &a);
   add_number(&a);
   printf("after  pass by reference, a == %p\n", &a);

}

before pass by reference, a == 2
after  pass by reference, a == 4
before pass by reference, a == 0x7fff5cf417ec
after  pass by reference, a == 0x7fff5cf417ec

Porque você está passando um ponteiro (endereço de memória) para a variável p na função f. Em outras palavras, você está passando um ponteiro, não uma referência.

Resposta curta: Sim, C implementa passagem de parâmetro por referência usando ponteiros.

Ao implementar a passagem de parâmetros, os designers de linguagens de programação usam três estratégias diferentes (ou modelos semânticos): transferir dados para o subprograma, receber dados do subprograma ou fazer as duas coisas. Esses modelos são comumente conhecidos como modo in, out e inout, respectivamente.

Vários designers foram criados por designers de linguagem para implementar essas três estratégias de passagem de parâmetros elementares:

Passagem por valor (semântica no modo) Passagem por resultado (semântica no modo de saída) Passagem por valor (semântica no modo de entrada) Passagem por referência (semântica no modo de entrada) Passagem por nome (modo de entrada semântica)

Passagem por referência é a segunda técnica para a passagem de parâmetros no modo de entrada. Em vez de copiar dados entre a rotina principal e o subprograma, o sistema de tempo de execução envia um caminho de acesso direto aos dados para o subprograma. Nesta estratégia, o subprograma tem acesso direto aos dados, compartilhando efetivamente os dados com a rotina principal. A principal vantagem dessa técnica é que ela é absolutamente eficiente no tempo e no espaço, porque não há necessidade de duplicar o espaço e não há operações de cópia de dados.

A implementação de passagem de parâmetro em C: C implementa a semântica de passagem por valor e também de passagem por referência (modo inout) usando ponteiros como parâmetros. O ponteiro é enviado para o subprograma e nenhum dado real é copiado. No entanto, como um ponteiro é um caminho de acesso aos dados da rotina principal, o subprograma pode alterar os dados na rotina principal. C adotou esse método da ALGOL68.

Implementação de passagem de parâmetro no C ++: O C ++ também implementa a semântica de passagem por referência (modo inout) usando ponteiros e também usando um tipo especial de ponteiro, chamado tipo de referência. Os ponteiros do tipo de referência são desreferenciados implicitamente dentro do subprograma, mas sua semântica também é passada por referência.

Portanto, o principal conceito aqui é que a passagem por referência implementa um caminho de acesso aos dados em vez de copiá-los no subprograma. Os caminhos de acesso a dados podem ser ponteiros desreferenciados explicitamente ou ponteiros desreferenciados automaticamente (tipo de referência).

Para mais informações, consulte o livro Concepts of Programming Languages, de Robert Sebesta, 10a Ed., Capítulo 9.

Você não está passando um int por referência, está passando um ponteiro para um int por valor. Sintaxe diferente, mesmo significado.

Em C, para passar por referência, você usa o endereço do operador &que deve ser usado em uma variável, mas no seu caso, desde que você usou a variável ponteiro p, não é necessário prefixá-la com o operador do endereço do endereço. Teria sido verdade se você utilizado &icomo parâmetro: f(&i).

Você também pode adicionar isso à desreferencia pe ver como esse valor corresponde i:

printf("p=%d \n",*p);

ponteiros e referências são dois thigngs diferentes.

Algumas coisas que eu não vi mencionadas.

Um ponteiro é o endereço de alguma coisa. Um ponteiro pode ser armazenado e copiado como qualquer outra variável. Assim, tem um tamanho.

Uma referência deve ser vista como um ALIAS de alguma coisa. Ele não tem tamanho e não pode ser armazenado. DEVE referenciar algo, ie. não pode ser nulo ou alterado. Bem, às vezes o compilador precisa armazenar a referência como um ponteiro, mas isso é um detalhe de implementação.

Com referências, você não tem problemas com ponteiros, como manipulação de propriedade, verificação nula, cancelamento de referência no uso.

'Passar por referência' (usando ponteiros) está em C desde o início. Por que você acha que não é?

Eu acho que C de fato suporta passagem por referência.

A maioria das línguas exige que o açúcar sintático passe por referência em vez de valor. (C ++, por exemplo, requer & na declaração de parâmetro).

C também requer açúcar sintático para isso. É * na declaração do tipo de parâmetro e & no argumento. Então * e & é a sintaxe C para passar por referência.

Agora, pode-se argumentar que a passagem real por referência deve exigir apenas sintaxe na declaração do parâmetro, não no lado do argumento.

Mas agora vem C #, que faz apoio pela passagem de referência e requer açúcar sintático em ambos os parâmetros e argumentos lados.

O argumento de que C não tem passagem por referência faz com que os elementos sintáticos para expressá-lo exibam a implementação técnica subjacente não é um argumento, pois isso se aplica mais ou menos a todas as implementações.

O único argumento restante é que passar por ref em C não é um recurso monolítico, mas combina dois recursos existentes. (Pegue ref do argumento por &, espere ref digitar por *.) C #, por exemplo, requer dois elementos sintáticos, mas eles não podem ser usados ​​um sem o outro.

Este é obviamente um argumento perigoso, porque muitos outros recursos em idiomas são compostos por outros recursos. (como suporte a cadeias de caracteres em C ++)

O que você está fazendo é passar por valor, não por referência. Como você está enviando o valor de uma variável 'p' para a função 'f' (em principal como f (p);)

O mesmo programa em C com passagem por referência será semelhante a (!!! este programa apresenta 2 erros, pois a passagem por referência não é suportada em C)

#include <stdio.h>

void f(int &j) {    //j is reference variable to i same as int &j = i
  j++;
}

int main() {
  int i = 20;
  f(i);
  printf("i = %d\n", i);

  return 0;
}

Resultado:-

3:12: erro: esperado ';', ',' ou ')' antes do token '&'
             n vazio f (int & j);
                        ^
9: 3: aviso: declaração implícita da função 'f'
               f (a);
               ^