Mon Javaquarium

Bonjour, j'ai hésité à faire un nouveau post, et comme je débute je pense que vous aurez beaucoup de choses à dire. Le code se trouve ici: https://github.com/Nekyia/Javaquarium.

Il n'y a pour l'instant que l'exercice 1.1. Je veux que chaque partie soit "parfaite" avant de passer à la suivante. Aussi je viens juste de commencer les class hier, donc c'est tout frais.

Voilà. Soyez impitoyable

Salut j'ai lu ton code en diagonal ,et apparemment tu ne fais pas la différence entre un objet ayant une sémantique de valeur et un objet ayant une sémantique d'entité ce qui est un peu normal si tu as commencé les classes il y a deux jours.
Je te conseille d'aller voir ça.
Bonne continuation

Merci Octodex. J'ai lu l'article, je comprends l'idée de base, mais si on pouvais m'indiquer concrètement quand je devrais faire la différence dans mon code, cela m'aiderais bien.

Je dis peut-être n'importe quoi, mais est-ce qu'une fonction b.clone(a) qui dit simplement que mon objet b n'est pas le même que le a, mais que c'est un clone et qu'il a donc les mêmes caractéristiques au moment du clonage, à un sens en sémantique d'identité ?

Si j'ai bien compris tu voudrais faire quelque chose comme :

1
2
3
4

  Fish *clone(Fish *f)
  {
     return new Fish(*f);
  }

Si c'est ce que tu voulais faire selon moi ce n'est pas compatible car tu vas utiliser le constructeur de copie de Fish et un objet ayant une sémantique d'entité ne peut pas être copié.

Sinon si tu ne veux pas t’embêter tu peux faire comme ceci https://github.com/alex-lairan/javaquarium/blob/master/entity/entity.hpp

C'est une lib en plus à ajouter, mais qui n'ajoute pas boost aujourd'hui dans ses projet (ironique je sais que tous le monde n'utilise pas cette lib)

Encore une question: que se passe-t-il (que se passera-t-il surtout) si je ne respecte pas cette sémantique d'entité ?

En soi, rien, ton compilateur ne va pas te crier dessus, ton programme va fonctionner mais c'est une norme de la programmation orientée objet.

Ce que je veux dire, c'est que la sémantique en soi à un sens, mais si ça n'apportait rien on ne s'en embêterait pas, donc qu'est-ce que ça apporte de faire la différence entre sémantique de valeur, d'entité,… ?

Cela permet d'améliorer la conception de ton programme et donner un sens aux classes ,par exemple il est logique de définir l'opérateur + pour une classe matrice (car sémantique de valeur ) en revanche additionner des poissons n'a pas de sens (sémantique d'entité ) et cela permet aussi d'éviter le slicing .

Après, faire des clones, oui mais s'ils sont semblables en tout point, ce sont deux entités différentes et distinguables donc il faut que tu trouves un moyen de les différencier (avec un ID par exemple).

Si tu supprimes le constructeur de copie et l'opérateur d'affectation je ne sais pas comment tu comptes faire le clonage.

Bah en faisant un constructeur qui prend en paramètres nom, sexe, age, espèce, etc. et qui crée un ID unique pour le poisson et ensuite faire une fonction membre qui crée un nouveau poisson en passant en argument au constructeur le nom du poisson, son sexe, etc.

Rapidement cela pourrait être ça :

1
2
3
4
5
6
7

class Poisson {
public :
   Poisson(std::string name,...);
   getName();
private :
   std::string m_name;
};

avec une fonction cloner :

1
2
3
4

void cloner(Poisson &autre) {
   Poisson clone{autre.getName(),...};
   //puis le mettre dans l'aquarium
}

Ah oui j'avais pas pensé à cette façon de faire
Par contre cela implique beaucoup de getter pas très OO tout ça Moi j'aurais pluôt vu le code comme ça :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

class Fish
{
   public :

   Fish(const string &n) : nom(n), id(generer_id())
   {

   }

   Fish *clone()
   {
     return new Fish(nom,...,generer_id());
   }

  private :
  int generer_id()
  {
    id=...;
  }

  private :
  string nom
  int id;
}

Merci pour le lien Typhlos. Ça parle de beaucoup de chose que je n'ai pas encore vu mais j'ai marqué la page pour y revenir de temps en temps. Si j'ai bien compris ça permet surtout d'organiser son code pour que lorsque le programme grossit il reste organisé correctement et les objets soient utilisés de manière logique.

Mais je suis encore victime de confusion, reformulons:

1) si un objet est défini par ses valeurs (par exemple une couleur avec les membres R G et B) alors si je copie une instance j'obtiens un double du même objet (deux fois la couleur rouge)

2) sinon (par exemple un homme avec une taille et un âge) si je le copie j'obtiens une autre entité qui a les mêmes valeurs (deux hommes)

=> 1 a une sémantique de valeur et 2 une sémantique d'identité ? je ne peux pas additionner deux hommes et l'égalité n'a pas de sens, ce sont deux entités distinctes. Je peux juste comparer leurs tailles ou leurs âges. (est-ce que ça un sens d'additionner deux couleurs ?)

1) Oui
2) Si tu copie tu n'as plus de sémantique d'identité car tu as perdu l'unicité de ta première entité :chaque entité est unique en les copiant elles ne le seront plus.C'est pour ça qu'il ne faut pas copier les objets ayant des sémantiques d'entités

est-ce que ça un sens d'additionner deux couleurs ?

Oui car une couleur peut être considérée comme une valeur.

Oui c'est vrai qu'on peut faire de la fonction cloner une fonction membre de la classe Poisson. C'est plus propre en effet

Par contre plutôt que new j'utiliserai plutôt std::make_unique<Fish> Fish(nom,…,generer_id()) et la fonction cloner serait plutôt du type std::unique_ptr<Fish>.

Oui c'est vrai les pointeurs intelligents c'est mieux mais j'avais la flemme.

Lu'!

Non. Ce n'est pas une norme. Ce sont des noms, posés sur des concepts pour différencier leur comportement. D'un côté on a posé les valeurs et de l'autre les entités. Et c'est dû au fait que C++ autorise la copie des objets que l'on a besoin de faire cette distinction dans l'implémentation puisqu'en Java ou en C# par exemple, les objets sont nécessairement des entités puisqu'il n'y a pas de copie d'objet, juste des références.