object slicing

object slicing (tsz. object slicings)

1. (informatika) A szeletelés (object slicing) egy jellegzetes C++ probléma, amely az öröklődés és az érték szerinti hozzárendelés (copy by value) kombinációjából adódik. Olyankor fordul elő, amikor egy származtatott osztály objektumát egy alaposztály típusú változónak érték szerint adjuk át – ilyenkor az objektum “felső része” (a base class) megmarad, de a “felszeletelt” alsó része (a derived class tagjai, viselkedése) elveszik.

Képzeld el, hogy van egy torta (származtatott osztály), aminek az alapja egy piskóta (alaposztály). Amikor szeletelés történik, csak a piskótát tartjuk meg – a csoki-, gyümölcs-, vagy tejszínhabréteg elveszik.

class Base {
public:
    int a;
    void print() const {
        std::cout << "Base\n";
    }
};

class Derived : public Base {
public:
    int b;
    void print() const {
        std::cout << "Derived\n";
    }
};

void foo(Base b) {
    b.print(); // Melyik print?
}

int main() {
    Derived d;
    foo(d); // Object slicing történik itt
}

• A Derived d példányt érték szerint átadjuk a foo függvénybe, ami Base típusú paramétert fogad.
• Ekkor csak a Base része másolódik át.
• A Derived saját részei (b, Derived::print) elvesznek – a Base::print() fog lefutni.

1. Érték szerinti hozzárendelés:

   Base b = Derived();  // slicing
   

2. Érték szerinti paraméterátadás:

   void f(Base b);      // slicing, ha Derived-et adunk át
   

3. Érték szerinti visszatérési érték:

   Base g() {
       Derived d;
       return d;        // slicing
   }
   

• Elvesznek a származtatott tagváltozók
• Virtuális függvények nem futnak helyesen, ha nem pointer vagy referencia a hívás
• Nehezen észrevehető viselkedési hibákhoz vezethet
• A típusinformáció veszik el: a típus Base, nem Derived

class Shape {
public:
    virtual void draw() const {
        std::cout << "Drawing shape\n";
    }
};

class Circle : public Shape {
public:
    void draw() const override {
        std::cout << "Drawing circle\n";
    }
};

void render(Shape s) {  // slicing
    s.draw();           // "Drawing shape", nem "circle"
}

Ha render(Circle()); hívást végzünk, az eredmény nem a várt “Drawing circle”, hanem csak a Shape-féle viselkedés.

void render(const Shape& s) {
    s.draw(); // Megmarad a dinamikus viselkedés
}

void render(std::shared_ptr<Shape> s) {
    s->draw();
}

Base(const Base&) = delete;
Base& operator=(const Base&) = delete;

Tartsd be az alapszabályt: öröklésnél mindig hivatkozással (vagy pointerrel) dolgozz.

C++ objektumok memóriaelrendezése:

Derived d
+------------+------------+
| Base part  | Derived b  |
+------------+------------+

Ha csak a Base másolódik:

Base b = d;  // Slicing után
+------------+
| Base part  |
+------------+

A Derived b tag, és a Derived::vtable elveszik (ha nem referencia!).

Polimorfizmus működéséhez referenciára vagy pointerre van szükség. Ha másolás történik (slicing), a virtuális asztal (vtable) információ elveszik – ez az oka, hogy Derived::draw() helyett Base::draw() fut le.

std::vector<Base> shapes;
shapes.push_back(Circle()); // slicing

Ezért használj:

std::vector<std::unique_ptr<Shape>> shapes;
shapes.push_back(std::make_unique<Circle>());

“Polimorfizmust csak pointeren vagy referencián keresztül lehet használni C++-ban.”

Ezért sose adj érték szerint származtatott példányt alap osztályú paraméternek.

Az object slicing nem fordítási hiba, de logikai hibákhoz vezethet, különösen ha örökléses hierarchiában dolgozol, és nem figyelsz oda, hogyan másolódnak az objektumok. A C++ nagy rugalmasságot ad, de ennek ára van – a fejlesztőnek kell biztosítania, hogy a típusinformáció megmaradjon.

• object slicing - Szótár.net (en-hu)
• object slicing - Sztaki (en-hu)
• object slicing - Merriam–Webster
• object slicing - Cambridge
• object slicing - WordNet
• object slicing - Яндекс (en-ru)
• object slicing - Google (en-hu)
• object slicing - Wikidata
• object slicing - Wikipédia (angol)