Qu'est-ce que le découpage en tranches d'objets ?

Question

Quelqu'un l'a mentionné dans l'IRC comme étant le problème du tranchage.

Answer 1

Le "découpage en tranches" consiste à affecter un objet d'une classe dérivée à une instance d'une classe de base, perdant ainsi une partie de l'information - une partie est "découpée en tranches".

Par exemple,

class A {
   int foo;
};

class B : public A {
   int bar;
};

Ainsi, un objet de type B a deux membres de données, foo y bar .

Alors si vous deviez écrire ceci :

B b;

A a = b;

Ensuite, les informations dans b à propos du membre bar est perdue dans a .

Answer 2

La plupart des réponses n'expliquent pas quel est le problème réel du découpage en tranches. Elles n'expliquent que les cas bénins de découpage en tranches, et non les cas dangereux. Supposons, comme les autres réponses, que vous avez affaire à deux classes A y B où B dérive (publiquement) de A .

Dans cette situation, le C++ vous permet de passer une instance de B à A (et aussi au constructeur de copie). Cela fonctionne parce qu'une instance de B peut être converti en un const A& ce qui est ce que les opérateurs d'affectation et les constructeurs de copie attendent de leurs arguments.

Le cas bénin

B b;
A a = b;

Rien de grave ne se produit ici - vous avez demandé une instance de A qui est une copie de B et c'est exactement ce que vous obtenez. Bien sûr, a ne contiendra pas certains des b mais comment le faire ? C'est un A après tout, pas un B donc ça n'a même pas entendu à propos de ces membres, et encore moins serait capable de les stocker.

L'affaire des traîtres

B b1;
B b2;
A& a_ref = b2;
a_ref = b1;
//b2 now contains a mixture of b1 and b2!

Vous pourriez penser que b2 sera une copie de b1 après. Mais, hélas, c'est no ! Si vous l'inspectez, vous découvrirez que b2 est une créature de Frankenstein, faite de quelques morceaux de b1 (les morceaux qui B hérite de A ), et quelques morceaux de b2 (les morceaux que seuls B contient). Aïe !

Que s'est-il passé ? Eh bien, par défaut, le C++ ne traite pas les opérateurs d'assignation comme étant virtual . Ainsi, la ligne a_ref = b1 appellera l'opérateur d'affectation de A et non celle de B . En effet, pour les fonctions non virtuelles, la fonction déclaré (formellement : statique ) (qui est A& ) détermine quelle fonction est appelée, par opposition à l'option réel (formellement : dynamique ) (qui serait B puisque a_ref fait référence à une instance de B ). Maintenant, A L'opérateur d'affectation de l'utilisateur ne connaît évidemment que les membres déclarés dans l'article A donc il ne copiera que ceux-là, laissant les membres ajoutés dans B inchangé.

Une solution

Le fait de n'assigner que des parties d'un objet n'a généralement pas beaucoup de sens, mais le C++ ne fournit malheureusement pas de moyen intégré pour l'interdire. Vous pouvez cependant en créer un. La première étape consiste à rendre l'opérateur d'affectation virtual . Cela garantira que c'est toujours le réel qui est appelé, et non l'opérateur d'affectation du type déclaré de type. La deuxième étape consiste à utiliser dynamic_cast pour vérifier que l'objet attribué a un type compatible. La troisième étape consiste à effectuer l'assignation réelle dans un membre (protégé !) assign() puisque B 's assign() vous voudrez probablement utiliser A 's assign() pour copier A des membres.

class A {
public:
  virtual A& operator= (const A& a) {
    assign(a);
    return *this;
  }

protected:
  void assign(const A& a) {
    // copy members of A from a to this
  }
};

class B : public A {
public:
  virtual B& operator= (const A& a) {
    if (const B* b = dynamic_cast<const B*>(&a))
      assign(*b);
    else
      throw bad_assignment();
    return *this;
  }

protected:
  void assign(const B& b) {
    A::assign(b); // Let A's assign() copy members of A from b to this
    // copy members of B from b to this
  }
};

Notez que, par pure commodité, B 's operator= remplace de manière covariante le type de retour, puisqu'il connaît qu'il retourne une instance de B .

Answer 3

Si vous avez une classe de base A et une classe dérivée B Vous pouvez alors procéder comme suit.

void wantAnA(A myA)
{
   // work with myA
}

B derived;
// work with the object "derived"
wantAnA(derived);

Maintenant, la méthode wantAnA a besoin d'une copie de derived . Cependant, l'objet derived ne peut pas être copié complètement, car la classe B pourrait inventer des variables membres additionnelles qui ne sont pas dans sa classe de base A .

Par conséquent, pour appeler wantAnA le compilateur va "découper" tous les membres supplémentaires de la classe dérivée. Le résultat peut être un objet que vous ne vouliez pas créer, parce que

• elle peut être incomplète,
• il se comporte comme un A -objet (tous les comportements particuliers de la classe B est perdue).

Answer 4

La troisième correspondance dans google pour "C++ slicing" me donne cet article de Wikipedia http://en.wikipedia.org/wiki/Object_slicing et ceci (chauffé, mais les premiers posts définissent le problème) : http://bytes.com/forum/thread163565.html

C'est donc quand on assigne un objet d'une sous-classe à la super-classe. La superclasse ne sait rien des informations supplémentaires de la sous-classe, et n'a pas la place de les stocker, donc les informations supplémentaires sont "coupées".

Si ces liens ne donnent pas suffisamment d'informations pour une "bonne réponse", veuillez modifier votre question pour nous indiquer ce que vous recherchez en plus.

Answer 5

Le problème du découpage en tranches est grave car il peut entraîner une corruption de la mémoire, et il est très difficile de garantir qu'un programme n'en souffre pas. Pour l'éliminer du langage, les classes qui supportent l'héritage doivent être accessibles uniquement par référence (et non par valeur). Le langage de programmation D possède cette propriété.

Considérons une classe A et une classe B dérivée de A. Une corruption de la mémoire peut se produire si la partie A possède un pointeur p et une instance B qui fait pointer p vers les données supplémentaires de B. Ensuite, lorsque les données supplémentaires sont coupées, p pointe vers des déchets. Ensuite, lorsque les données supplémentaires sont supprimées, p pointe vers un déchet.