Hésitation sémantique de valeur ou d'entité

Salut les agrumes ,j'étais entrain de lire un tutoriel sur les pointeurs intelligents et je tombe sur ce code où l'auteur dit qu'il s'agit d'une sémantique de valeur sauf que Rectangle et Circle héritent de Shape et que normalement si c'est bien une sémantique de valeur il ne devrait pas y avoir d'héritage.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

vector<Shape> v;
v.push_back(Rectangle(0, 0, 10, 20));
v.push_back(Circle(0, 0, 10));
for(vector<Shape>::iterator it = v.begin();
it != v.end();
++it)
{
it->draw();
}
vector<Shape> v2 = v;
for(vector<Shape>::iterator it = v2.begin();
it != v2.end();
++it)
{
it->move(2, 2);
}

Je remercie d'avance les personnes qui me permettront de clarifier cela.
Bonne journée à tous !

Salut,

A mon avis, la sémantique d'une forme va principalement dépendre de son utilisation. Si elle représente un "objet", une "chose", qui sera par exemple déplacé, affiché… alors ce sera une sémantique d'entité. Si c'est pour une utilisation plutôt mathématique (comparaison de formes, de leur air, etc…), alors elle peut avoir une sémantique de valeur.

Et effectivement, si c'est une sémantique de valeur, l'héritage serait alors inapproprié.

Or dans ce code, je dirais qu'il s'agit plutôt d'une sémantique d'entité (les formes sont affichées, déplacées). Et ce qui pose problème c'est la ligne vector<Shape> v2 = v;. Ce n'est pas vraiment une copie, mais plutôt un clonage.

Pour cette raison, on peut décider d'interdire l'opérateur = avec ce genre de classe, et proposer une fonction clone().

HS: Les range-based for, c'est plus joli.

1
2

for(const auto &shape : v)
    shape.draw();

ok ,merci pour vos réponses .Donc selon toi Ksass`Peuk ici c'est une sémantique d'entité ?

Il faudrait voir l'article en question, il y a peut être une confusion/imprécision ?

Il faut faire la distinction entre le concept mathématique (la valeur) et une "instance" particulière (le fait d'appeler tes classes "Circle" et "Rectangle" ne veut pas dire que cela représente un cercle et un rectangle).

Si tu veux par exemple comparer deux surfaces, tu pourrais écrire :

1
2
3

Circle c(0, 0, 10);          // x, y, r
Rectangle r1(0, 0, 10, 20);  // x, y, w, h
bool b = has_same_surface(c, r1);

Si tu crées une seconde variable r2 :

1
2
3

Rectangle r2(0, 0, 10, 20);  // x, y, w, h
bool b = has_same_surface(c, r2);
r1 == r2;

r1 et r2 représente bien la même chose, peu importe que cela correspondent à des objets différents en mémoire.

Maintenant, si on prend des shapes, que l'utilisateur peut cliquer et déplacer à la souris :

1
2
3
4
5

vector<Shape> shapes = {
    Rectangle(0, 0, 10, 20),
    Rectangle(0, 0, 10, 20)
};
shapes.draw();

Même si tes 2 rectangles sont au même endroit, ce sont bien 2 "choses" différentes pour l'utilisateur. L'une est au dessus de l'autre, si l'utilisateur clique en (5, 5), il ne va sélectionner que le rectangle qui est au dessus et il ne déplacera qu'un seul rectangle.

Dans le premier cas, peu importe l'instance en particulier que l'on prend en compte, le résultat est le même (c'est une valeur). Dans le second cas, chaque instance est identifiable et différente des autres (c'est une entité).

Probablement que le mieux est de renommer tes types, par exemple RectangleShape et CircleShape, pour bien montrer qu'il ne s'agit pas des concepts "rectangle" et "cercle", mais d'entités.

Je pense avoir compris ,dans ton premier exemple Rectangle et Circle représentent des surfaces et donc peuvent être considérées comme une sémantique de valeur.(si j'ai bien compris)
Voilà le lien de l'article gbdivers :Article. PS : désolé si j'ai mis un peu de temps à répondre ^^.

Le code que tu cites vient d'une partie introductive, il y a en effet un problème de sémantique que cette partie veut exposer :

Les problèmes sont multiples : On doit désormais s'occuper de désallouer correctement ce qui a été alloué (ce que je n'ai pas fait ici), de plus, on a sans forcément le vouloir une sémantique d'entité, alors qu'initialement on avait une sémantique de valeur. Ainsi, la deuxième partie du code modifie aussi le contenu de v, ce qui n'était pas le cas dans la version précédente.

Oui sauf que ma question était : Est ce vraiment une sémantique de valeur que l'on avait au début puisque dans son code de départ : il affichait des formes et utilisait l'héritage.(cf code de mon premier message).

Oui, c'est bien une sémantique de valeur qu'il considère¹, il aurait en effet pu le dire plus clairement par contre.

C'est le point de départ : on veut manipuler ensemble plusieurs objets différents à sémantique de valeur, comment faire ? Le premier problème, le slicing, est traité en passant par des pointeurs. Ensuite vient les problèmes de la citation de mon message précédent.

Si c'est une introduction aux pointeurs intelligents que tu veux, je ne suis pas convaincu que l'approche de Loic dans cette article soit la meilleur (il choisit de traiter un cas non couvert par les pointeurs du standard comme exemple).

Le tuto publié sur ce site à propos du RAII me semble avoir une meilleur approche du problème.

ok, je vais voir de ce pas ce tuto.
En tout cas merci de m'avoir éclairé sur ce point .