|
En programmation orientée objet, « passer par copie » et « passer par référence » font référence à différentes manières de transmettre des arguments à des fonctions ou des méthodes. Cependant, la terminologie varie selon la langue et le contexte.
Passer par copie :
- Arguments passés en copies : En mode passage par copie, une copie de l'argument réel est créée et transmise à la fonction. Toute modification apportée à cette copie au sein de la fonction n'affecte pas la variable d'origine en dehors de la fonction.
- Types de valeurs : La copie transmise est couramment utilisée avec les types valeur, qui sont des types de données qui contiennent directement leur valeur. Par exemple, en C++ ou Java, int, double, boolean, etc. sont des types valeur.
Passer par référence :
- Arguments comme références : Lors du passage par référence, une référence à l'argument réel est transmise à la fonction. Toute modification apportée à l'argument à l'intérieur de la fonction est directement reflétée dans la variable d'origine en dehors de la fonction.
- Types de référence : Le passage par référence est souvent utilisé avec les types référence, qui sont des types de données contenant une référence à un emplacement mémoire où les données réelles sont stockées. Par exemple, en C++ et Java, les objets (instances de classes) sont des types référence.
Dans certains langages, le comportement peut être contrôlé explicitement à l'aide de mots-clés tels que « passer par référence » ou « &» (pour les paramètres de référence) et « passer par valeur » ou « * » (pour les paramètres de valeur).
Par exemple, en C++ :
```cpp
void incrément (valeur int) { // passer par valeur
valeur++ ; // modifie la copie
}
void incrémentRef(int &value) { // passer par référence
valeur++ ; // modifie la variable d'origine
}
int main() {
entier x =5 ; // type de valeur
incrément(x); // x reste 5
incrémentRef(x); // x devient 6
}
```
En Java :
```Java
public void incrément (int value) { // passer par valeur
valeur++ ; // modifie la copie
}
public void incrémentRef(int &value) { // passer par référence
valeur++ ; // modifie la variable d'origine
}
public static void main (String[] arguments) {
entier x =5 ; // type de valeur primitive
incrément(x); // x reste 5
incrémentRef(x); // x devient 6
}
```
En Python, les arguments sont toujours passés par référence. Cependant, Python utilise un mécanisme de comptage de références pour gérer la durée de vie de l'objet et vous pouvez créer des copies indépendantes du nombre de références de l'objet d'origine.
Comprendre le passage par copie et le passage par référence aide à gérer efficacement la mémoire, à éviter les modifications indésirables et à garantir le bon comportement des fonctions/méthodes qui fonctionnent sur les arguments.
|
