Segmentación de objetos en C++

Cuando un objeto de clase derivada se asigna a un objeto de clase base en C++, los atributos adicionales del objeto de clase derivada se cortan (no se consideran) para generar el objeto de clase base; y todo este proceso se denomina segmentación de objetos . En palabras simples, cuando los componentes adicionales de una clase derivada se dividen o no se utilizan y la prioridad se da al objeto de la clase base, esto se denomina división de objetos. 

En C++, un objeto de clase derivada se puede asignar a un objeto de clase base, pero no es posible hacerlo de otra manera. Para abordar este problema de corte, podemos usar un puntero dinámico.

Además, el corte de objetos ocurre cuando un objeto de clase derivado se asigna a un objeto de clase base y los atributos adicionales de un objeto de clase derivado se cortan para formar el objeto de clase base.

// C++ program to demonstrate what is object slicing
class Base {
    int x, y;
};
 
class Derived : public Base {
    int z, w;
};
 
int main()
{
    Derived d;
 
    // Object Slicing,
    // z and w of d are sliced off
    Base b = d;
}

Rebanado de objetos

// C++ program to demonstrate the mechanism or working of
// of the object slicing technique
#include <iostream>
using namespace std;
 
// Base class
class Base {
protected:
    int i;
 
public:
    Base(int a) { i = a; }
    virtual void
    display() // virtual function which is declared in base
              // class and re-declared in derived class
    {
        cout << "I am Base class object, i = " << i << endl;
    }
};
 
// Derived class
class Derived : public Base {
    int j;
 
public:
    Derived(int a, int b)
        : Base(a)
    {
 
        // assigning the value to the data members of
        // derived class
        j = b;
    }
    virtual void display()
    {
        cout << "I am Derived class object, i = " << i
             << ", j = " << j << endl;
    }
};
 
// Global method, Base class
// object is passed by value
void somefunc(Base obj) { obj.display(); }
 
int main()
{
    Base b(33);
    Derived d(45, 54);
    somefunc(b);
 
    // Object Slicing, the member j of d is
    // sliced off
    somefunc(d);
    return 0;
}

Producción: 

I am Base class object, i = 33
I am Base class object, i = 45

Podemos evitar el comportamiento inesperado anterior con el uso de punteros o referencias. La segmentación de objetos no se produce cuando se pasan punteros o referencias a objetos como argumentos de función, ya que un puntero o referencia de cualquier tipo ocupa la misma cantidad de memoria. Por ejemplo, si cambiamos el método global myfunc() en el programa anterior por el siguiente, el corte de objetos no ocurre. 

// REFERENCE TO ABOVE
 
// rest of code is similar to above
void somefunc (Base &obj)
{
    obj.display();
}          
// rest of code is similar to above

Producción: 

I am Base class object, i = 33
I am Derived class object, i = 45, j = 54

Obtenemos el mismo resultado si usamos punteros.

Una de las aplicaciones de segmentación de objetos se ve cuando un objeto de clase derivada se pasa a una función que toma un objeto de clase base como argumento. Esto se ha demostrado a continuación.

Ejemplo:

// rest of code is similar to above
void somefunc (Base *objp)
{
    objp->display();
}
 
int main()
{
    Base *bp = new Base(33) ;
    Derived *dp = new Derived(45, 54);
    somefunc(bp);
    somefunc(dp);  // No Object Slicing
    return 0;
}

Producción: 

I am Base class object, i = 33
I am Derived class object, i = 45, j = 54

La división de objetos se puede evitar haciendo que la función de la clase base sea puramente virtual, lo que impide la creación de objetos. No es posible crear el objeto de una clase que contiene un método virtual puro.
Este artículo es una contribución de Pravasi Meet . Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.