Quelle est la différence entre C ++ et Java avec des variables?


Réponse 1:

Aucune différence si vous les utilisez dans / à partir d'une méthode de classe. Pourquoi? Parce que dans C ++ et Java, la valeur des pointeurs et les clés sont tous stockés dans des tableaux associatifs jusqu'à ce qu'ils doivent être pointés vers la mémoire et accessibles et / ou sautés ou supprimés. La classe stocke un pointeur mais ne lui attribue rien tant que self.key [valeur] du tableau n'est pas demandé, puis il définit et utilise cette paire de clés.value affectée au tableau. La plus grosse triche en programmation, et la plus utile.


Réponse 2:

En Java, il existe une grande différence entre le fonctionnement des types primitifs (par exemple int, double) et les types définis par l'utilisateur (par exemple, les types définis comme classes). Les variables de type primitif en Java contiennent directement la valeur qu'elles représentent. Les variables de type classe contiennent directement un pointeur (appelé «référence» en Java mais plus analogue à un pointeur C ++ qu'à une référence C ++) à la valeur qu'ils représentent, pas à la valeur elle-même. Exemple:

int x = 5; // x contient directement la valeur 5
Dog fido = nouveau chien ("Fido", 5); // fido ne contient pas de Dog mais une référence à un objet Dog sur le tas managé

C ++ est différent. La principale différence entre les types fondamentaux en C ++ (par exemple, int, double, char, pointeurs bruts) est que les types fondamentaux n'ont pas de destructeur qui s'exécute à la fin de leur vie. Les types définis par les structures et les classes le font.

En C ++, une variable de n'importe quel type contient directement la valeur qu'elle représente ou a une sémantique équivalente à contenir directement cette valeur. Considérer:

int x = 5; // x contient directement la valeur 5
Dog fido = Dog {"Fido", 5}: // fido contient directement une valeur de chien ou a la même sémantique
std :: unique_ptr  rexPtr = std :: make_unique  ("Rex", 5); // contient directement un pointeur unique vers un objet Dog.
int * iPtr = new int {9}; // iPtr contient directement un pointeur brut vers un int
Dog * muffyPtr = new Dog {"Muffy", 4}; // muffyPtr contient directement un pointeur brut vers un objet Dog

Ainsi, comme vous le voyez, les variables de types définis par l'utilisateur n'ont pas de sémantique pointeur / référence intégrée par défaut. Si vous voulez une variable qui contient directement un chien, vous la déclarez comme variable chien. Si, à la place, vous voulez une variable qui contient un pointeur (en termes Java une référence à un chien), vous déclarez une variable pointeur vers chien.

Cela nous amène à la différence en C ++ entre les types fondamentaux et les types classe / struct. Les types classe / struct appellent automatiquement un destructeur qui libère toutes leurs ressources à la fin de leur durée de vie (si les variables locales, cela signifie quand elles sortent du domaine; si les membres d'une autre classe quand la durée de vie de cette classe se termine) mais pas les types fondamentaux. Pour les types fondamentaux comme int, char, double, cela n'a aucune conséquence importante. Pour les pointeurs bruts, cela a une conséquence importante. Si vous n'appelez pas delete sur eux avant la fin de leur durée de vie, vous «perdez» la valeur vers laquelle ils pointent: vous ne pouvez plus y accéder mais il reste en mémoire non récupérable jusqu'à la fin du programme. Ainsi, en C ++, vous évitez d'utiliser le tas lorsque vous le pouvez et utilisez des «pointeurs intelligents» (essentiellement un type de classe qui possède un pointeur avec un destructeur qui sait comment et quand libérer la mémoire) lorsque le tas est nécessaire.