Diferença entre Chamada por Valor e Chamada por Referência

Nas linguagens de programação, as funções podem ser invocadas de duas maneiras: conhecida como Chamada por Valor e Chamada por Referência.

O que é o método Chamada por Valor?

O método Call by Value copia o valor de um argumento no parâmetro formal dessa função. Portanto, as alterações feitas no parâmetro da função principal não afetam o argumento.

Neste método de passagem de parâmetros, os valores dos parâmetros reais são copiados para os parâmetros formais da função e os parâmetros são armazenados em diferentes locais de memória. Portanto, quaisquer alterações feitas dentro das funções não são refletidas nos parâmetros reais do chamador.

O que é o método Chamada por Referência?

O método de chamada por referência copia o endereço de um argumento no parâmetro formal. Neste método, o endereço é usado para acessar o argumento real usado na chamada da função. Isso significa que as alterações feitas no parâmetro alteram o argumento de passagem.

Neste método, a alocação de memória é igual aos parâmetros reais. Todas as operações na função são realizadas no valor armazenado no endereço do parâmetro real, e o valor modificado será armazenado no mesmo endereço.

Exemplo de código C de um método Call by Value

void main() {
        int a = 10,
        void increment(int);
        Cout << "before function calling" << a;
        increment(a);
        Cout << "after function calling" << a;
        getch();

        void increment(int x) {
            int x = x + 1;
            Cout << "value is" << x;
        }

Saída:

before function calling 10
value is 11
after function calling 1-0

Porque a variável declarada 'a' em main() é diferente da variável 'x' em increment(). Neste programa apenas os nomes das variáveis ​​são semelhantes, mas seus endereços de memória são diferentes e armazenados em locais de memória diferentes.

Java Exemplo de código de um método de chamada por referência

Public static void main(string args[]) {
    int a = 10;
    System.out.println("Before call Value of a = ", a);
    Void increment();
    System.out.println("After call Value of a = ", a);
}

Void increment(int x) {
    int x = x + 1;
}

Saída:

Before call Value of a =10
After call Value of a =11

Porque a variável declarada 'a' está referenciando/apontando para a variável 'a' em main(). Aqui o nome da variável é diferente, mas ambos apontam/referem-se aos mesmos locais de endereço de memória.

Chamada por valor vs. Chamada por referência

Vantagens de usar o método Call by value em C

Prós/benefícios de uma chamada por valor em C:

• O método não altera a variável original, portanto preserva os dados.
• Sempre que uma função é chamada, nunca afete o conteúdo real dos argumentos reais.
• Valor dos argumentos reais passados ​​para os argumentos formais, portanto, quaisquer alterações feitas no argumento formal não afetam os casos reais.

Vantagens de usar o método Chamada por referência

Prós de usar o método de chamada por referência:

• A função pode alterar o valor do argumento, o que é bastante útil.
• Ele não cria dados duplicados para armazenar apenas um valor, o que ajuda a economizar espaço de memória.
• Neste método, não há cópia do argumento feita. Portanto, é processado muito rapidamente.
• Ajuda você a evitar alterações feitas por engano
• Quem lê o código nunca sabe que o valor pode ser modificado na função.

Desvantagens de usar o método Call by value

Aqui estão os principais contras/desvantagens de um método de chamada por valor:

• Mudanças nos parâmetros reais também podem modificar variáveis ​​de argumento correspondentes
• Neste método, os argumentos devem ser variáveis.
• Você não pode alterar diretamente uma variável no corpo de uma função.
• Às vezes, o argumento pode ser expressões complexas
• Existem duas cópias criadas para a mesma variável que não consomem muita memória.

Desvantagens de usar o método Chamar por referência

Aqui estão os principais contras do uso do método de chamada por referência:

• Garantia forte não nula. Uma função que recebe uma referência precisa ter certeza de que a entrada não é nula. Portanto, a verificação de nulo não precisa ser feita.
• Passar por referência faz com que a função não seja pura teoricamente.
• Uma garantia vitalícia é um grande problema com referências. Isso é especificamente perigoso ao trabalhar com lambdas e programas multithread.