Qual é a diferença entre c ++ e java com variáveis?

Não há diferença se você os estiver usando em / de um Método de classe. Por quê? Como no C ++ e no Java, o valor e as chaves dos ponteiros são todos armazenados em matrizes associativas até que sejam obrigados a serem apontados para a memória e acessados ​​e / ou removidos ou descartados. A classe armazena um ponteiro, mas não o designa até que self.key [value] da matriz seja solicitada, em seguida, ela define e usa esse par de key.value atribuído à matriz. Maior trapaça na programação e a mais útil.

Em Java, há uma grande diferença entre como tipos primitivos (por exemplo, int, double) e tipos definidos pelo usuário (por exemplo, tipos definidos como classes) funcionam. Variáveis ​​de tipo primitivo em Java contêm diretamente o valor que representam. Variáveis ​​de tipo de classe contêm diretamente um ponteiro (chamado de "referência" em Java, mas mais análogo a um ponteiro C ++ do que uma referência C ++) ao valor que eles representam, não ao valor em si. Exemplo:

  1. int x = 5; // x contém diretamente o valor 5Dog fido = new Dog ("Fido", 5); // fido não contém um Dog, mas uma referência a um objeto Dog no heap gerenciado

C ++ é diferente. A principal diferença entre tipos fundamentais em C ++ (por exemplo, int, double, char, ponteiros brutos) é que os tipos fundamentais não têm nenhum destruidor que é executado quando a vida útil termina. Tipos definidos por estruturas e classes sim.

Em C ++, uma variável de

qualquer tipo

contém diretamente o valor que representa ou possui semântica equivalente a conter diretamente esse valor.

Considerar:

  1. int x = 5; // x contém diretamente o valor 5Dog fido = Dog {"Fido", 5}: // fido contém diretamente um valor de cachorro ou possui a mesma semânticastd :: unique_ptr rexPtr = std :: make_unique ("Rex", 5); // contém diretamente um ponteiro exclusivo para um objeto Dog.int * iPtr = new int {9}; // O iPtr contém diretamente um ponteiro bruto para um intDog * muffyPtr = new Dog {"Muffy", 4}; // muffyPtr contém diretamente um ponteiro bruto para um objeto Dog

Portanto, como você vê, variáveis ​​de tipos definidos pelo usuário não possuem semântica de ponteiro / referência incorporada a elas por padrão. Se você deseja uma variável que contenha diretamente um Dog, declare-a como uma variável Dog. Se, em vez disso, você desejar uma variável que contenha um ponteiro (em termos de Java, uma referência a um Dog), você declarará uma variável de ponteiro para Dog.

Isso nos leva à diferença em C ++ entre tipos fundamentais e tipos de classe / estrutura. Os tipos de classe / estrutura chamam automaticamente um destruidor que libera todos os seus recursos quando sua vida útil termina (se variáveis ​​locais, isso significa que eles ficam fora do escopo; se membros de outra classe quando essa vida útil de classes termina), mas os tipos Thifundamental não. Para tipos fundamentais como int, char, double isso não tem conseqüências importantes. Para

cru

ponteiros

, isso tem uma consequência importante. Se você não excluí-los antes que sua vida útil termine, você "vaza" o valor para o qual eles apontam: você não pode mais acessá-lo, mas ele permanece na memória irrecuperável até o término do programa. Assim, em C ++, você evita usar o heap quando pode e usa “ponteiros inteligentes” (basicamente um tipo de classe que possui um ponteiro com um destruidor que sabe como e quando liberar a memória) quando o heap é necessário.