Discussion :

[Deadpool]

Bon après quelque recherche sur développez à ce sujet, j'ai trouvé ceci

http://bruce-eckel.developpez.com/li...&page=0#00.005

Et finalement je suis d'accord avec ceci :

Ceci nous amène à discuter terminologie, ce qui est toujours bon dans un débat. Le sens de l'expression « passage par valeur » dépend de la perception qu'on a du fonctionnement du programme. Le sens général est qu'on récupère une copie locale de ce qu'on passe, mais cela est tempéré par notre façon de penser à propos de ce qu'on passe. Deux camps bien distincts s'affrontent quant au sens de « passage par valeur » :

Java passe tout par valeur. Quand on passe un scalaire à une méthode, on obtient une copie distincte de ce scalaire. Quand on passe une référence à une méthode, on obtient une copie de la référence. Ainsi, tous les passages d'arguments se font par valeur. Bien sûr, cela suppose qu'on raisonne en terme de références, mais Java a justement été conçu afin de vous permettre d'ignorer (la plupart du temps) que vous travaillez avec une référence. C'est à dire qu'il permet d'assimiler la référence à « l'objet », car il la déréférence automatiquement lorsqu'on fait un appel à une méthode.
Java passe les scalaires par valeur (pas de contestations sur ce point), mais les objets sont passés par référence. La référence est considérée comme un alias sur l'objet ; on ne pense donc pas passer une référence, mais on se dit plutôt « je passe l'objet ». Comme on n'obtient pas une copie locale de l'objet quand il est passé à une méthode, il est clair que les objets ne sont pas passés par valeur. Sun semble plutôt soutenir ce point de vue, puisque l'un des mot-clefs « réservés mais non implémentés » est byvalue (bien que rien ne précise si ce mot-clef verra le jour).

Donc en gros tout dépend de la perception qu'on en a.

Désolé de vous avoir pris la tête.

[adiGuba]

Désolé de vous avoir pris la tête.

Au contraire c'est bien de le préciser

En effet cela peut être trompeur pour ceux qui viennent du C++ où le passage par référence est différent et peut prendre une part importante de la conception d'une application (Cf la FAQ C++ sur les références).

a++

[Pill_S]

Hello,

selon moi, tout est passé par valeur en java...

quand on écrit:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
foo(5);

on passe la valeur "5" à la méthode... normal

et quand on écrit:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
Object o = new Object();
foo(o);

on passe aussi la valeur de "o" à la méthode "foo" ... mais comme "o" est une référence, sa valeur vaut en fait un emplacement mémoire genre "0x10b62c9", et c'est cela qu'on lui passe en paramètre.

logique non ?

c'est d'ailleurs la même chose avec le "==":

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
if(4 == 5) // compare les valeurs

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
if(o1 == o2) // compare les valeurs des références, renvoie true si et seulement si o1 et o2 référencent le même objet (même valeur = même adresse mémoire = même objet)

[viena]

Pill : ça se passe bien comme ça. et ça s'appele un passage par référence. La preuve en est :
pour des objets java non immuables (des classes que vous avez créé par exemple), si on passe un objet à une methode et qu'on travaille sur l'objet, en sortant de la méthode, les modifications sont concervées. Faites le test et vous verrez

[Pill_S]

oui, mais il ne s'agit que d'une conséquence du fait que les paramètres sont passés par valeur, et les objets gérés par référence

[xavlours]

Edit, tiens le message auquel j'ai répondu à disparu!

Oui, j'avoue, j'avais lu ton post en diagonale, et j'ai retiré le mien (qui n'apportait rien) le plus vite possible, mais pas assez ...

[Deadpool]

oui, mais il ne s'agit que d'une conséquence du fait que les paramètres sont passés par valeur, et les objets gérés par référence

Exactement, dans la méthode on obtient une copie du contenu de la variable, qui est une référence, ce qui permet d'altérer l'objet (s'il est altérable).

Oui, j'avoue, j'avais lu ton post en diagonale, et j'ai retiré le mien (qui n'apportait rien) le plus vite possible, mais pas assez ...

Ca m'arrive souvent aussi!

[FreshVic]

oui, mais il ne s'agit que d'une conséquence du fait que les paramètres sont passés par valeur, et les objets gérés par référence

Moi perso je suis de l'avis de Viena , mais bon c'est juste une question de point , je crois que l'essentiel c'est qui'on sache a peu pres comment ca marche

Mais quand je vois :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
 
public void foo(Object o){
...
}

je vois une methode foo qui prend en parametre un Object et dans la mesure ou l'object passé en parametre n'est pas une copie de l'original il s'agit d'un passage par reference.
La meme syntaxe en C++ pour un objet créé statiquement provoque la copie de celui ci, et un passage par valeur , alors qu'en java on a le meme objet et non une copie (ou un clone).

[vbrabant]

Juste pour completer ce débat, je voudrais rajouter un exemple, montrant que tout est bien un passage par valeur et non par référence.

Essayez ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
class Test {
  private String display;
  public Test(String value) {
    this.display = value;
  }
  public String toString() {
    return display;
  }
}
public class Main {    
  public static void foo(Object obj){
    obj = new Test("objet2");
    System.out.println("foo "+obj);  
  } 
  public static void main(String[] args) {
    Object object1 = new Test("objet1");
    System.out.println(object1);
    foo(object1);
    System.out.println(object1);
  }
}

Si c'était vraiment un passage par référence, on aurait ceci:

objet1
foo objet2
objet2

Mais comme c'est un passage par valeur, on obtient

objet1
foo objet2
objet1

J'espère que jusqu'ici vous avez suivi.

Maintenant, pour compliquer un peu plus, il faut savoir que lorsqu'on ne manipule pas des primitives en Java, on ne manipule pas non plus des objets. Ni des références à des objets, comme pourrait le penser un programmeur C++). Mais on manipule des pointeurs à des objets. Et lorsqu'on "passe un objet" à une méthode, on ne passe pas l'objet ni sa référence, mais on passe la valeur du pointeur à l'objet. Grande nuance.

Je vais citer ci-dessous quelques extraits de l'excellent livre "Au coeur de Java 2" Notion fondamentales JDK 5 Volume 1.

Page 119

De nombreuses personne pensent à tort que les variables objets de Java se comportent comme les références en C++.
Mais en C++, il n'y a pas de référence nlles et les références ne peuvent être affectées. Il faut plutôt penser aux variables objet de Java comme aux pointeurs sur objets de C++. Par exemple,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Date birthday;// en Java

est en fait identique à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Date* birthday; //en C++

Lorsqu'on fait cette association, tout redevient clair. Bien entendu, un pointeur Date* n'est pas initialisé tant que l'on n'appelle pas new. La syntaxe est presque la même en C++ et en Java:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Date* birthday = new Date(); // C++

(C'est moi qui ai mis en gras à tort)


Et la méthode Java suivante:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void method(Date birthday); // en Java

serait en fait équivalente à ceci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void method(Date* birthday); // en pseudo C++

et non à ceci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void method(Date& birthday); // en C++

ni à ceci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void method(Date*& birthday); // en pseudo C++

-------------------------------

Page 64

Les programmeurs C++ sont souvent stupéfaits lorsqu'ils rencontrent des chaines Java pour la première fois, car ils considèrent les chaines comme des tableaux de caractères

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

char greeting[] = "Hello";

La comparaison n'est pas bonne; une chaine Java ressemble davantage à un pointeur char*;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

char* greeting = "Hello";

-------------------------------

Page 98

Un tableau Java est assez différent d'un tableau C/C++ dans la pile (stack). Il peut cependant être comparé à un pointeur sur un tableau alloué dans le tas (segment heap de la mémoire). C'est à dire que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int[] a =  new int[100]; //en Java

n'est pas la même chose que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int[] a =  new int[100]; //en C++

mais plutot à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int* a =  new int[100]; //en C++

[Deadpool]

Merci pour cette explication!

[r0d]

Mais alors concrètement, comment fait-on pour faire l'équivalent d'un passage de paramètre de fonction par référence en c++, sur un type primitif en java?

Exemple concret, comment faire en sorte que le code suivant affiche "a=10"?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
public class Test{
    public static void f( int a ) {
		a = 10;
	}
 
    public static void main(String[] args) {
        int a = 0;
        f(a);
        System.out.print("a=");
        System.out.print(a);
    }
}

[CheryBen]

Tu sors un vieux sujet du placard

Ce que tu demandes est impossible tel quel avec les types primitifs.
Il y a 2 solutions :
Ta fonction f renvoi un int et dans le main tu fais a = f(a)
Tu travailles avec un objet Integer plutôt qu'un int.

[r0d]

Tu sors un vieux sujet du placard

Vi je suis désolé Mais je pensais que ce serait mieux que d'en créer un nouveau parce que quand j'ai fait la recherche sur ce sujet j'ai eu 3000 résultats et ça fait déjà beaucoup non?
tu veux que je crée un nouveau?

Tu travailles avec un objet Integer plutôt qu'un int.

Ben je viens de tester ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
public class HelloWord {
	public static void g( Integer a ){
		a=10;
	}
 
    public static void main(String[] args) {
    	Integer a=0;
    	g(a);
        System.out.print( "number = " + a );
        System.out.println();
    }
}

et la sortie reste obstinément "number = 0";

J'ai bien l'impression que ce n'est pas possible en fait, tout simplement.
Je sais qu'en C# c'est possible avec un mot-clé, ref il me semble. En python ça ne semble pas non plus possible...

[adiGuba]

Tu travailles avec un objet Integer plutôt qu'un int.

Faux : Integer est une classe immutable et ses données ne pourront pas être changé...


Il faudrait donc utiliser une classe mutable contenant un int avec ses getter/setter (il n'y a rien de tel en standard).


Mais cela dépend surtout de ce que tu veux faire avec cela : on ne traduit pas un code C++ en Java ligne par ligne... les philosophies sont différentes !

a++

[r0d]

Mais cela dépend surtout de ce que tu veux faire avec cela : on ne traduit pas un code C++ en Java ligne par ligne... les philosophies sont différentes !

Oui je sais bien, c'est juste une question "philosophique" que je me pose. En fait, en ce moment j'ai des soucis (en c++) avec des problèmes de gestion de mémoire, j'aimerai comprendre comment les différents langages gèrent le passage de paramètre.

Merci pour vos réponse

[adiGuba]

Et bien en Java c'est tout simple : tout est passé par copie !

La passage par référence est très utile en C++ pour le passage d'objet, car on n'a que deux autres alternatives :

• Passer l'objet par copie (par défaut), ce qui entraine l'appel implicite du constructeur de copie et qui peut être couteux.
• Passer l'adresse de l'objet pour éviter la copie (passage par pointeur), mais cela entraine l'utilisation de pointeur pas forcément toujours pratique.

Le passage par référence permet de passer un objet sans en faire de copie...



En Java on ne retrouve pas ce problème, puisque si on a bien un passage par copie pour tous les éléments, on ne manipule pas vraiment d'objet mais seulement des références. Ainsi lorsqu'on passe un objet à une méthode on fait en réalité une copie de sa référence, ce qui s'apparente en fait à un passage par pointeur (en C++), sans les inconvénients...


Du coup le seul intérêt d'avoir un passage par référence en Java serait la possibilité de simuler plusieurs valeurs de retour, ce qui est généralement plutôt déconseillé (on privilégiera à la place un objet conteneur dont les valeurs seront modifié).


a++

[CheryBen]

Faux : Integer est une classe immutable et ses données ne pourront pas être changé...

oups j'avais oublié, je ne travaille jamais avec ces classes...

Et bien en Java c'est tout simple : tout est passé par copie !

Faire un passage par référence ou par copie de référence, n'est-ce pas identique? une référence est bien l'adresse dans la mémoire?

J'avoue que même en ayant compris la pratique depuis un moment, les questions philosophiques restent compliquées.

[r0d]

Faire un passage par référence ou par copie de référence, n'est-ce pas identique? une référence est bien l'adresse dans la mémoire?

Je ne sais pas si ça répondra à ta question, mais en c++, il y a une subtile différence entre pointeur et référence (je ne parle pas de la syntaxe, qui elle est totalement différente):
-> un pointeur c'est une variable qui contient l'adresse de l'objet (la zone mémoire dans laquelle est stocké l'objet). C'est un type.
-> une référence c'est l'adresse de l'objet.
Ca n'a pas l'air à première vue, mais ça change beaucoup de chose: étant donné qu'un pointeur est un type, on peut faire beaucoup de choses que l'on ne peut pas faire avec une référence, comme par exemple définir une valeur nulle, des opérations, etc...

[adiGuba]

Faire un passage par référence ou par copie de référence, n'est-ce pas identique? une référence c'est bien l'adresse dans la mémoire?

Une référence correspond bien grosso-modo à une adresse, mais le "passage par référence" et par "copie de référence" n'est pas tout à fait pareil :

Prenons le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
	public static void method(String str) {
		str = "world";
	}
 
	public static void main(String[] args) {
		String str = "hello";
		method(str);
		System.out.println(str);
	}

Avec Java nous avons comme résultat "hello" (str n'est pas modifié).
Pourquoi ?

Dans la méthode main() nous avons :

• Un objet "hello", quelque part en mémoire.
• Une référence str, stocké dans le stack de la méthode.

Lorsqu'on appelle la méthode, on copie la valeur de la référence (l'adresse si tu préfères) dans une nouvelle référence str stocké dans le stack de la méthode method(). On a deux références distinctes :

• str de main(), stocké dans le stack de la méthode main() (puisque c'est une variable locale)
• str de method(), stocké dans le stack de la méthode method() (puisque c'est un paramètre)

Ces deux références pointent vers le même objet en mémoire (ce qui fait que l'utilisation d'une éventuellement méthode setter serait visible via les deux référence).

Mais lorsqu'on fait une affectation comme dans le code de method(), on modifie la valeur de la référence (l'adresse du pointeur si tu veux).
Du coup la référence str de method() pointe vers un autre objet en mémoire, mais il n'y a aucun moyen de modifier la référence str de main() qui est dans un autre espace mémoire.




A l'inverse, si un passage par référence était possible, la variable str de method() ne serait pas stocké dans le stack de cette dernière : on utiliserait directement l'espace mémoire dans le stack de la méthode appelante (main() donc), et donc toutes modifications impacterait également la méthode parente : on a une seule référence et non pas deux !
On obtiendrait donc le résultat "world".


En fait tu es proche d'un passage par pointeur (sauf qu'il est caché) :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
void method(char* c) {
   *c = 'a'; // Tu modifies la valeur pointé par c, ce qui impactera le parent, c'est l'équivalent d'un setter en Java 
   c = "a"; // Tu modifies directement c, qui appartient uniquement à la méthode (pas d'impact sur l'appelant)
}

a++