Discussion :

[swirtel]

Bonjour,

Bien qu'ayant lû de la doc sur les Générics et ayant constaté des manques par rapport aux templates C++, je me demande si il était tout de même possible d'avoir un équivalent aux traits C++ ?

quelqu'un aurait-il une idée ?

Merci

[adiGuba]

Salut,

Bien qu'ayant lû de la doc sur les Générics et ayant constaté des manques par rapport aux templates C++,

L'approche est surtout très différentes : ce n'est pas du tout les mêmes mécanismes...

je me demande si il était tout de même possible d'avoir un équivalent aux traits C++ ?

A quoi servent les "traits" exactement ? J'ai jeté un coup d'oeil à la FAQ C++ mais j'avoue ne pas avoir très bien compris

a++

[Tommy31]

Salut,


L'approche est surtout très différentes : ce n'est pas du tout les mêmes mécanismes...


A quoi servent les "traits" exactement ? J'ai jeté un coup d'oeil à la FAQ C++ mais j'avoue ne pas avoir très bien compris

a++

Les traits servent principalement à définir une caractérisation sur un type et ce de façon statique. Ceci est rendu possible par la surcharge de template pour les différents type qu'ils adressent. C'est en gros de la définition de fonction au méta-niveau

Imagine par exemple, que tu veuilles définir la caractéristique de taille mémoire utilisée pour des types. Tu vas définir un template qui retourne 2 pour un appel size_traits<short>::size, et 4 pour un appel size_traits<int>.

là ca parraît obscur comme façon de faire, mais c'est rendu nécessaire si tu travaille dans le méta niveau. Si tu as un template qui accepte un type T dont tu veux connaitre la propriété de taille, tu peux appliquer le traits size_traits<T> dessus, donc introspecter sur un type anonyme.

En java, ca n'existe tout simplement pas. Il faut passer par des class<T>...

[CyberChouan]

Je n'ai pas tout compris à tes traits... mais l'introspection d'une classe existe en java (par contre, je ne suis pas certain que celle-ci fonctionne sur une classe anonyme): si tu veux en savoir d'avantage sur l'introspection en java, regarde le package "java.lang.reflect"

[gronono]

Bonjour,

Si j'ai bien compris l'exemple fourni, il me semble que c'est le fonctionnement des interfaces :

Code :

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

1
2
3
4
 
public interface SizeTraits {
  public int size();
}

Code :

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

1
2
3
4
5
6
 
public class ShortSizeTraits implement SizeTraits {
  public int size() {
      return 2;
  }
}

Code :

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

1
2
3
4
5
6
 
public class IntSizeTraits implement SizeTraits {
  public int size() {
      return 4;
  }
}

Et l'utilisation :

Code :

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

1
2
3
4
 
public void test(SizeTraits st) {
   System.out.println(st.size());
}

A+

[swirtel]

ton code sera utile au run-time, mais dans mon cas, cela ne m'intéresse pas, car il me faut un élément utile au compile-time.

Les generics Java n'ont pas la même approche qu'en C++, et ça m'ennuie, car j'aurais bien voulu appliquer les "traits" c++ en Java.

[gifffftane]

J'ai du mal à t'aider parce que je ne comprends pas ces traits.

Pourrais-tu donner un autre exemple, parce que de toutes façons la notion de taille mémoire n'existe pratiquement pas en java (même si, bien sûr, il y en a une).

Les méta-informations - dans une acceptation intuitive - sont souvent données par des annotations, mais, à part un petit nombre standard, elles ne sont pas traitées par le compilateur ; pour elles il faut se faire son propre compilateur d'annotations.

[Tommy31]

Les traits sont ce que l'introspection et les annotations permettent de faire en java, mais pas au même niveau. Les traits permettent de définir un méta opérateur, s'appliquant sur un type et retournant un résultat. On peut ainsi définir un trait 'facette' qui retourne une description, ou une icone sur un objet métier devant posséder un signifiant, ou un trait 'strategie' qui retourne un algorithme particulier selon le type transmis.

Mais attention, cela est STATIQUE. En c++ c'est à la compilation que s'interprètent les traits, en java c'est à l'exécution. C'est pas seulement par intérêt que cela survient à la compilation en C++, c'est absolument nécessaire quand on joue avec les templates, car on manipule des types anonymes (voir ce qu'en fait la bibliothèque boost).

[gifffftane]

Ces traits sont-ils définis dans le cadre d'une classe ou d'autre chose ?

En Java, à la compilation, on n'a pas grand chose d'autre que des classes, des interfaces, et des types génériques.

Je tente une approche pour voir : si je fais une classe Facette, avec une méthode getDescription(), est-ce que cela pourrait ressembler à un trait ?

[Tommy31]

Non pas du tout, car tu exprime un propriété d'instance, alors qu'en C++ c'est une propriété de type (de classe). On peut pas l'exprimer facilement en java à cause du type-erasure.

Cela dit, plus j'y réfléchis, et moins je vois d'intérêt aux traits en java, car les templates n'y sont pas exprimable...

[elmor]

Pour moi les staits ne sont pas utiles en Java car en Java le type génerique ne peut s'exprimer que sur des object et non sur des types simple (int, double ...).

Par exemple:

Code :

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

java.util.List<int>  aList = ....//ne compile pas

Donc en fait on n'a pas le problème que mélanger des types du genre char et char*.

Il est toujours possible d'utiliser les wilcards pour être sur que l'object herite d'une certaine interface.

Exemple:

Code :

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

class toto<T extend MYCLASS>