Qual a diferença entre uma referência Java e um ponteiro C?

C tem ponteiros e Java tem o que é chamado de referências. Eles têm algumas coisas em comum no sentido de que todos apontam para alguma coisa. Eu sei que os ponteiros em C armazenam os endereços para os quais eles apontam. A referência também armazena o endereço? Como eles são diferentes, exceto que o ponteiro é mais flexível e propenso a erros?

As referências podem ser implementadas armazenando o endereço. Geralmente, as referências Java serão implementadas como ponteiros, mas isso não é exigido pela especificação. Eles podem estar usando uma camada adicional de indireção para facilitar a coleta de lixo. Mas no final (quase sempre) se resume a ponteiros (no estilo C) envolvidos na implementação de referências (no estilo Java).

Você não pode fazer aritmética de ponteiro com referências. A diferença mais importante entre um ponteiro em C e uma referência em Java é que você não pode realmente obter (e manipular) o valor subjacente de uma referência em Java. Em outras palavras: você não pode fazer aritmética de ponteiro.

Em C, você pode adicionar algo a um ponteiro (ou seja, o endereço) ou subtrair algo para apontar para coisas que estão "próximas" ou para lugares que estão em qualquer lugar.

Em Java, uma referência aponta para uma coisa e apenas essa coisa. Você pode fazer uma variável manter uma referência diferente , mas não pode simplesmente pedir que aponte para "a coisa após a coisa original".

As referências são fortemente digitadas. Outra diferença é que o tipo de uma referência é muito mais rigorosamente controlado em Java do que o tipo de um ponteiro em C. Em C, você pode ter um int*e convertê-lo em um char*e apenas reinterpretar a memória nesse local. Essa reinterpretação não funciona em Java: você só pode interpretar o objeto na outra extremidade da referência como algo que já é (ou seja, você pode converter uma Objectreferência em Stringreferência apenas se o objeto apontado for realmente a String).

Essas diferenças tornam os ponteiros C mais poderosos, mas também mais perigosos. Essas duas possibilidades (aritmética do ponteiro e reinterpretação dos valores apontados) adicionam flexibilidade ao C e são a fonte de parte do poder da linguagem. Mas eles também são grandes fontes de problemas, porque, se usados ​​incorretamente, podem facilmente quebrar as suposições de que seu código foi criado. E é muito fácil usá-los incorretamente.

Referências C ++ são diferentes novamente.

Eles precisam ser inicializados e não podem ser nulos (pelo menos não em um programa bem formado) e não podem ser recolocados para se referir a outra coisa. uma referência C ++ é muito mais parecida com um alias para um objeto.

Outra diferença importante entre ponteiros e referências Java / C ++ é que você pode pegar o endereço de um ponteiro que não pode acessar o endereço de uma referência (na verdade, uma referência C ++ não precisa realmente existir como um objeto na memória); consequentemente, você pode ter um ponteiro para um ponteiro, mas não uma referência a uma referência

Referências Java e ponteiros C diferem exatamente em dois pontos:

1. Não há aritmética para o primeiro.
2. E você não pode criar uma referência Java para o que quiser, só pode copiar aqueles salvos em algum lugar acessível (campos estáticos, campos de objetos, variáveis ​​locais) ou retornados por invocações de funções (como chamadas de construtor), que, portanto, se referem a Java objetos (nunca tipos básicos como referências, char, inte assim por diante).

Alguém escreveu que as referências são fortemente tipadas, porque você não pode forçar o compilador a tratar um int*como a char*.
Completamente aparte do fato de que essa conversão específica é realmente segura , não há polimorfismo em C, de modo que a comparação não é iniciada.
Certamente, Java é mais fortemente tipado que C, não que esse seja um recurso de ponteiros C versus referências a Java; você precisa usar o JNI para quebrar a segurança de tipo (além de desconsiderar as restrições genéricas), mas mesmo em C você deve forçar o compilador.

Alguém escreveu que as referências Java pode ser implementado como ponteiros C, a que eu digo com certeza, como eles são estritamente menos poderosos, em máquinas 32Bit eles normalmente são, se o JVM é implementado em C . Embora em máquinas de 64 bits, eles normalmente são ponteiros de objetos comuns compactados ("OOPs compactados") para economizar espaço e largura de banda.
De qualquer forma, esses ponteiros C também não precisam ser equivalentes aos endereços de hardware, mesmo que normalmente (> 99% das implementações) sejam por motivos de desempenho.
Finalmente, esse é um detalhe de implementação que não é exposto ao programador.

Eles são um pouco diferentes. Em Java, uma cópia da referência é copiada para a pilha de uma função chamada, apontando para o mesmo objeto que a função de chamada e permitindo que você manipule esse objeto. No entanto, você não pode alterar o objeto ao qual a função de chamada se refere.

Considere o seguinte código java

public static void changeRValue(StringBuffer sb){
    sb = new StringBuffer("helllllo"); /*attempt to assign the reference
                                        to a new object*/
}
public static void main(String[] args) {
    StringBuffer sb = new StringBuffer("hi");     //Create a new string buffer
    changeRValue(sb);                             //Call changeRValue
    System.out.println(sb.toString());            //Prints "hi" not "hello"
}

Agora considere um ponteiro em c ++:

void func(Dog* dog){
    *dog = Dog("hello world"); //Change the value of dog to a new object
}

int main(int argc, const char * argv[]) {
    Dog dog1("hi");                            //Create a dog object
    func(&dog1);                               //pass the address of dog
    cout << dog1.name;                         //Prints "hello world" not hi.
    return 0;
}