What is object slicing

Question

Someone mentioned it in the IRC as the slicing problem

User · Answer

If You have a base class A and a derived class B  then You can do the following   void wantAnA A myA          work with myA    B derived     work with the object  derived  wantAnA derived     Now the method wantAnA needs a copy of derived  However  the object derived cannot be copied completely  as the class B could invent additional member variables which are not in its base class A   Therefore  to call wantAnA  the compiler will  slice off  all additional members of the derived class  The result might be an object you did not want to create  because   it may be incomplete  it behaves like an A-object  all special behaviour of the class B is lost

User · Answer

The slicing problem in C   arises from the value semantics of its objects  which remained mostly due to compatibility with C structs  You need to use explicit reference or pointer syntax to achieve  normal  object behavior found in most other languages that do objects  i e   objects are always passed around by reference   The short answers is that you slice the object by assigning a derived object to a base object by value  i e  the remaining object is only a part of the derived object  In order to preserve value semantics  slicing is a reasonable behavior and has its relatively rare uses  which doesn t exist in most other languages  Some people consider it a feature of C    while many considered it one of the quirks misfeatures of C

User · Answer

Slicing  is where you assign an object of a derived class to an instance of a base class  thereby losing part of the information - some of it is  sliced  away   For example    class A      int foo      class B   public A      int bar       So an object of type B has two data members  foo and bar   Then if you were to write this   B b   A a   b    Then the information in b about member bar is lost in a

User · Answer

When a Derived class Object is assigned to Base class Object  all the members of derived class object is copied to base class object except the members which are not present in the base class  These members are Sliced away by the compiler  This is called Object Slicing   Here is an Example     include lt bits stdc   h gt  using namespace std  class Base       public          int a          int b          int c          Base                         a 10              b 20              c 30               class Derived   public Base       public          int d          int e          Derived                         d 40              e 50               int main         Derived d      cout lt  lt d a lt  lt   n       cout lt  lt d b lt  lt   n       cout lt  lt d c lt  lt   n       cout lt  lt d d lt  lt   n       cout lt  lt d e lt  lt   n         Base b   d      cout lt  lt b a lt  lt   n       cout lt  lt b b lt  lt   n       cout lt  lt b c lt  lt   n       cout lt  lt b d lt  lt   n       cout lt  lt b e lt  lt   n       return 0      It will generate    Error   class Base  has no member named  d   Error   class Base  has no member named  e

User · Answer

In C    a derived class object can be assigned to a base class object  but the other way is not possible   class Base   int x  y      class Derived   public Base   int z  w      int main          Derived d      Base b   d     Object Slicing   z and w of d are sliced off     Object slicing happens when a derived class object is assigned to a base class object  additional attributes of a derived class object are sliced off to form the base class object

User · Answer

The slicing problem is serious because it can result in memory corruption  and it is very difficult to guarantee a program does not suffer from it  To design it out of the language  classes that support inheritance should be accessible by reference only  not by value   The D programming language has this property   Consider class A  and class B derived from A  Memory corruption can happen if the A part has a pointer p  and a B instance that points p to B s additional data  Then  when the additional data gets sliced off  p is pointing to garbage

User · Answer

when a derived class object is assigned to a base class object  additional attributes of a derived class object are sliced off  discard   form the base class object   class Base    int x       class Derived   public Base     int z         int main      Derived d  Base b   d     Object Slicing   z of d is sliced off

User · Answer

I just ran across the slicing problem and promptly landed here  So let me add my two cents to this   Let s have an example from  production code   or something that comes kind of close      Let s say we have something that dispatches actions  A control center UI for example  This UI needs to get a list of things that are currently able to be dispatched  So we define a class that contains the dispatch-information  Let s call it Action  So an Action has some member variables  For simplicity we just have 2  being a std  string name and a std  function lt void   gt  f  Then it has an void activate   which just executes the f member   So the UI gets a std  vector lt Action gt  supplied  Imagine some functions like   void push back Action toAdd       Now we have established how it looks from the UI s perspective  No problem so far  But some other guy who works on this project suddenly decides that there are specialized actions that need more information in the Action object  For what reason ever  That could also be solved with lambda captures   This example is not taken 1-1 from the code   So the guy derives from Action to add his own flavour  He passes an instance of his home-brewed class to the push back but then the program goes haywire   So what happened  As you might have guessed  the object has been sliced   The extra information from the instance has been lost  and f is now prone to undefined behaviour     I hope this example brings light about for those people who can t really imagine things when talking about As and Bs being derived in some manner

User · Answer

Third match in google for  C   slicing  gives me this Wikipedia article http   en wikipedia org wiki Object slicing and this  heated  but the first few posts define the problem    http   bytes com forum thread163565 html  So it s when you assign an object of a subclass to the super class  The superclass knows nothing of the additional information in the subclass  and hasn t got room to store it  so the additional information gets  sliced off    If those links don t give enough info for a  good answer  please edit your question to let us know what more you re looking for

User · Answer

Slicing  is where you assign an object of a derived class to an instance of a base class  thereby losing part of the information - some of it is  sliced  away   For example    class A      int foo      class B   public A      int bar       So an object of type B has two data members  foo and bar   Then if you were to write this   B b   A a   b    Then the information in b about member bar is lost in a

User · Answer

In C    a derived class object can be assigned to a base class object  but the other way is not possible   class Base   int x  y      class Derived   public Base   int z  w      int main          Derived d      Base b   d     Object Slicing   z and w of d are sliced off     Object slicing happens when a derived class object is assigned to a base class object  additional attributes of a derived class object are sliced off to form the base class object

User · Answer

These are all good answers  I would just like to add an execution example when passing objects by value vs by reference    include  lt iostream gt   using namespace std      Base class class A   public      A          A const A amp  a            cout  lt  lt    A  copy constructor   lt  lt  endl            virtual void run   const   cout  lt  lt   I am an  A    lt  lt  endl           Derived class class B  public A   public      B   A          B const B amp  a  A a            cout  lt  lt    B  copy constructor   lt  lt  endl            virtual void run   const   cout  lt  lt   I am a  B    lt  lt  endl        void g const A  amp  a        a run       void h const A a        a run       int main         cout  lt  lt   Call by reference   lt  lt  endl      g B         cout  lt  lt  endl  lt  lt   Call by copy   lt  lt  endl      h B         The output is   Call by reference I am a  B   Call by copy  A  copy constructor I am an  A

User · Answer

The slicing problem is serious because it can result in memory corruption  and it is very difficult to guarantee a program does not suffer from it  To design it out of the language  classes that support inheritance should be accessible by reference only  not by value   The D programming language has this property   Consider class A  and class B derived from A  Memory corruption can happen if the A part has a pointer p  and a B instance that points p to B s additional data  Then  when the additional data gets sliced off  p is pointing to garbage

User · Answer

If You have a base class A and a derived class B  then You can do the following   void wantAnA A myA          work with myA    B derived     work with the object  derived  wantAnA derived     Now the method wantAnA needs a copy of derived  However  the object derived cannot be copied completely  as the class B could invent additional member variables which are not in its base class A   Therefore  to call wantAnA  the compiler will  slice off  all additional members of the derived class  The result might be an object you did not want to create  because   it may be incomplete  it behaves like an A-object  all special behaviour of the class B is lost

User · Answer

So     Why is losing the derived information bad      because the author of the derived class may have changed the representation such that slicing off the extra information changes the value being represented by the object   This can happen if the derived class if used to cache a representation that is more efficient for certain operations  but expensive to transform back to the base representation   Also thought someone should also mention what you should do to avoid slicing    Get a copy of C   Coding Standards  101 rules guidlines  and best practices   Dealing with slicing is  54   It suggests a somewhat sophisticated pattern to fully deal with the issue   have a protected copy constructor  a protected pure virtual DoClone  and a public Clone with an assert which will tell you if a  further  derived class failed to implement DoClone correctly    The Clone method makes a proper deep copy of the polymorphic object    You can also mark the copy constructor on the base explicit which allows for explicit slicing if it is desired

User · Answer

Third match in google for  C   slicing  gives me this Wikipedia article http   en wikipedia org wiki Object slicing and this  heated  but the first few posts define the problem    http   bytes com forum thread163565 html  So it s when you assign an object of a subclass to the super class  The superclass knows nothing of the additional information in the subclass  and hasn t got room to store it  so the additional information gets  sliced off    If those links don t give enough info for a  good answer  please edit your question to let us know what more you re looking for

User · Answer

Slicing  is where you assign an object of a derived class to an instance of a base class  thereby losing part of the information - some of it is  sliced  away   For example    class A      int foo      class B   public A      int bar       So an object of type B has two data members  foo and bar   Then if you were to write this   B b   A a   b    Then the information in b about member bar is lost in a

User · Answer

I just ran across the slicing problem and promptly landed here  So let me add my two cents to this   Let s have an example from  production code   or something that comes kind of close      Let s say we have something that dispatches actions  A control center UI for example  This UI needs to get a list of things that are currently able to be dispatched  So we define a class that contains the dispatch-information  Let s call it Action  So an Action has some member variables  For simplicity we just have 2  being a std  string name and a std  function lt void   gt  f  Then it has an void activate   which just executes the f member   So the UI gets a std  vector lt Action gt  supplied  Imagine some functions like   void push back Action toAdd       Now we have established how it looks from the UI s perspective  No problem so far  But some other guy who works on this project suddenly decides that there are specialized actions that need more information in the Action object  For what reason ever  That could also be solved with lambda captures   This example is not taken 1-1 from the code   So the guy derives from Action to add his own flavour  He passes an instance of his home-brewed class to the push back but then the program goes haywire   So what happened  As you might have guessed  the object has been sliced   The extra information from the instance has been lost  and f is now prone to undefined behaviour     I hope this example brings light about for those people who can t really imagine things when talking about As and Bs being derived in some manner

User · Answer

So     Why is losing the derived information bad      because the author of the derived class may have changed the representation such that slicing off the extra information changes the value being represented by the object   This can happen if the derived class if used to cache a representation that is more efficient for certain operations  but expensive to transform back to the base representation   Also thought someone should also mention what you should do to avoid slicing    Get a copy of C   Coding Standards  101 rules guidlines  and best practices   Dealing with slicing is  54   It suggests a somewhat sophisticated pattern to fully deal with the issue   have a protected copy constructor  a protected pure virtual DoClone  and a public Clone with an assert which will tell you if a  further  derived class failed to implement DoClone correctly    The Clone method makes a proper deep copy of the polymorphic object    You can also mark the copy constructor on the base explicit which allows for explicit slicing if it is desired

User · Answer

So     Why is losing the derived information bad      because the author of the derived class may have changed the representation such that slicing off the extra information changes the value being represented by the object   This can happen if the derived class if used to cache a representation that is more efficient for certain operations  but expensive to transform back to the base representation   Also thought someone should also mention what you should do to avoid slicing    Get a copy of C   Coding Standards  101 rules guidlines  and best practices   Dealing with slicing is  54   It suggests a somewhat sophisticated pattern to fully deal with the issue   have a protected copy constructor  a protected pure virtual DoClone  and a public Clone with an assert which will tell you if a  further  derived class failed to implement DoClone correctly    The Clone method makes a proper deep copy of the polymorphic object    You can also mark the copy constructor on the base explicit which allows for explicit slicing if it is desired

User · Answer

Most answers here fail to explain what the actual problem with slicing is  They only explain the benign cases of slicing  not the treacherous ones  Assume  like the other answers  that you re dealing with two classes A and B  where B derives  publicly  from A   In this situation  C   lets you pass an instance of B to  A s assignment operator  and also to the copy constructor   This works because an instance of B can be converted to a const A amp   which is what assignment operators and copy-constructors expect their arguments to be   The benign case  B b  A a   b    Nothing bad happens there - you asked for an instance of A which is a copy of B  and that s exactly what you get  Sure  a won t contain some of b s members  but how should it  It s an A  after all  not a B  so it hasn t even heard about these members  let alone would be able to store them   The treacherous case  B b1  B b2  A amp  a ref   b2  a ref   b1    b2 now contains a mixture of b1 and b2    You might think that b2 will be a copy of b1 afterward  But  alas  it s not  If you inspect it  you ll discover that b2 is a Frankensteinian creature  made from some chunks of b1  the chunks that B inherits from A   and some chunks of b2  the chunks that only B contains   Ouch   What happened  Well  C   by default doesn t treat assignment operators as virtual  Thus  the line a ref   b1 will call the assignment operator of A  not that of B  This is because  for non-virtual functions  the declared  formally  static  type  which is A amp   determines which function is called  as opposed to the actual  formally  dynamic  type  which would be B  since a ref references an instance of B   Now  A s assignment operator obviously knows only about the members declared in A  so it will copy only those  leaving the members added in B unchanged   A solution  Assigning only to parts of an object usually makes little sense  yet C    unfortunately  provides no built-in way to forbid this  You can  however  roll your own  The first step is making the assignment operator virtual  This will guarantee that it s always the actual type s assignment operator which is called  not the declared type s  The second step is to use dynamic cast to verify that the assigned object has a compatible type  The third step is to do the actual assignment in a  protected   member assign    since B s assign   will probably want to use A s assign   to copy A s  members   class A   public    virtual A amp  operator   const A amp  a        assign a       return  this       protected    void assign const A amp  a           copy members of A from a to this         class B   public A   public    virtual B amp  operator   const A amp  a        if  const B  b   dynamic cast lt const B  gt   amp a         assign  b       else       throw bad assignment        return  this       protected    void assign const B amp  b        A  assign b      Let A s assign   copy members of A from b to this        copy members of B from b to this          Note that  for pure convenience  B s operator  covariantly overrides the return type  since it knows that it s returning an instance of B

User · Answer

I see all the answers mention when object slicing happens when data members are sliced  Here I give an example that the methods are not overridden  class A  public      virtual void Say            std  cout lt  lt  quot I am A quot  lt  lt std  endl            class B  public A  public      void Say   override          std  cout lt  lt  quot I am B quot  lt  lt std  endl            int main       B b     A a1     A a2 b      b Say       I am B    a1 Say       I am A    a2 Say       I am A   why       B  object b  is derived from A  object a1 and a2   b and a1  as we expect  call their member function  But from polymorphism viewpoint we don   t expect a2  which is assigned by b  to not be overridden  Basically  a2 only saves A-class part of b and that is object slicing in C    To solve this problem  a reference or pointer should be used  A amp  a2 b   a2 Say       I am B  or A  a2    amp b  a2- gt Say       I am B  For more details see my post

User · Answer

The slicing problem is serious because it can result in memory corruption  and it is very difficult to guarantee a program does not suffer from it  To design it out of the language  classes that support inheritance should be accessible by reference only  not by value   The D programming language has this property   Consider class A  and class B derived from A  Memory corruption can happen if the A part has a pointer p  and a B instance that points p to B s additional data  Then  when the additional data gets sliced off  p is pointing to garbage

User · Answer

When a Derived class Object is assigned to Base class Object  all the members of derived class object is copied to base class object except the members which are not present in the base class  These members are Sliced away by the compiler  This is called Object Slicing   Here is an Example     include lt bits stdc   h gt  using namespace std  class Base       public          int a          int b          int c          Base                         a 10              b 20              c 30               class Derived   public Base       public          int d          int e          Derived                         d 40              e 50               int main         Derived d      cout lt  lt d a lt  lt   n       cout lt  lt d b lt  lt   n       cout lt  lt d c lt  lt   n       cout lt  lt d d lt  lt   n       cout lt  lt d e lt  lt   n         Base b   d      cout lt  lt b a lt  lt   n       cout lt  lt b b lt  lt   n       cout lt  lt b c lt  lt   n       cout lt  lt b d lt  lt   n       cout lt  lt b e lt  lt   n       return 0      It will generate    Error   class Base  has no member named  d   Error   class Base  has no member named  e

User · Answer

The slicing problem in C   arises from the value semantics of its objects  which remained mostly due to compatibility with C structs  You need to use explicit reference or pointer syntax to achieve  normal  object behavior found in most other languages that do objects  i e   objects are always passed around by reference   The short answers is that you slice the object by assigning a derived object to a base object by value  i e  the remaining object is only a part of the derived object  In order to preserve value semantics  slicing is a reasonable behavior and has its relatively rare uses  which doesn t exist in most other languages  Some people consider it a feature of C    while many considered it one of the quirks misfeatures of C

User · Answer

Slicing  is where you assign an object of a derived class to an instance of a base class  thereby losing part of the information - some of it is  sliced  away   For example    class A      int foo      class B   public A      int bar       So an object of type B has two data members  foo and bar   Then if you were to write this   B b   A a   b    Then the information in b about member bar is lost in a

User · Answer

If You have a base class A and a derived class B  then You can do the following   void wantAnA A myA          work with myA    B derived     work with the object  derived  wantAnA derived     Now the method wantAnA needs a copy of derived  However  the object derived cannot be copied completely  as the class B could invent additional member variables which are not in its base class A   Therefore  to call wantAnA  the compiler will  slice off  all additional members of the derived class  The result might be an object you did not want to create  because   it may be incomplete  it behaves like an A-object  all special behaviour of the class B is lost

User · Answer

1  THE DEFINITION OF SLICING PROBLEM  If D is a derived class of the base class B  then you can assign an object of type Derived to a variable  or parameter  of type Base    EXAMPLE  class Pet    public      string name     class Dog   public Pet   public      string breed      int main            Dog dog      Pet pet       dog name    Tommy       dog breed    Kangal Dog       pet   dog      cout  lt  lt  pet breed    ERROR   Although the above assignment is allowed  the value that is assigned to the variable pet loses its breed field  This is called the slicing problem   2  HOW TO FIX THE SLICING PROBLEM  To defeat the problem  we use pointers to dynamic variables   EXAMPLE  Pet  ptrP  Dog  ptrD  ptrD   new Dog           ptrD- gt name    Tommy   ptrD- gt breed    Kangal Dog   ptrP   ptrD  cout  lt  lt    Dog   ptrP - gt breed     In this case  none of the data members or member functions of the dynamic variable being pointed to by ptrD  descendant class object  will be lost  In addition   if you need to use functions  the function must be a virtual function

User · Answer

OK  I ll give it a try after reading many posts explaining object slicing but not how it becomes problematic    The vicious scenario that can result in memory corruption is the following    Class provides  accidentally  possibly compiler-generated  assignment on a polymorphic base class  Client copies and slices an instance of a derived class  Client calls a virtual member function that accesses the sliced-off state

User · Answer

Third match in google for  C   slicing  gives me this Wikipedia article http   en wikipedia org wiki Object slicing and this  heated  but the first few posts define the problem    http   bytes com forum thread163565 html  So it s when you assign an object of a subclass to the super class  The superclass knows nothing of the additional information in the subclass  and hasn t got room to store it  so the additional information gets  sliced off    If those links don t give enough info for a  good answer  please edit your question to let us know what more you re looking for

User · Answer

1  THE DEFINITION OF SLICING PROBLEM  If D is a derived class of the base class B  then you can assign an object of type Derived to a variable  or parameter  of type Base    EXAMPLE  class Pet    public      string name     class Dog   public Pet   public      string breed      int main            Dog dog      Pet pet       dog name    Tommy       dog breed    Kangal Dog       pet   dog      cout  lt  lt  pet breed    ERROR   Although the above assignment is allowed  the value that is assigned to the variable pet loses its breed field  This is called the slicing problem   2  HOW TO FIX THE SLICING PROBLEM  To defeat the problem  we use pointers to dynamic variables   EXAMPLE  Pet  ptrP  Dog  ptrD  ptrD   new Dog           ptrD- gt name    Tommy   ptrD- gt breed    Kangal Dog   ptrP   ptrD  cout  lt  lt    Dog   ptrP - gt breed     In this case  none of the data members or member functions of the dynamic variable being pointed to by ptrD  descendant class object  will be lost  In addition   if you need to use functions  the function must be a virtual function

User · Answer

class A         int x         class B         B      x 1   c  a            int x       char c         int main            A a       B b       a   b         b c     a  is  sliced  off     return 0

User · Answer

So     Why is losing the derived information bad      because the author of the derived class may have changed the representation such that slicing off the extra information changes the value being represented by the object   This can happen if the derived class if used to cache a representation that is more efficient for certain operations  but expensive to transform back to the base representation   Also thought someone should also mention what you should do to avoid slicing    Get a copy of C   Coding Standards  101 rules guidlines  and best practices   Dealing with slicing is  54   It suggests a somewhat sophisticated pattern to fully deal with the issue   have a protected copy constructor  a protected pure virtual DoClone  and a public Clone with an assert which will tell you if a  further  derived class failed to implement DoClone correctly    The Clone method makes a proper deep copy of the polymorphic object    You can also mark the copy constructor on the base explicit which allows for explicit slicing if it is desired

User · Answer

when a derived class object is assigned to a base class object  additional attributes of a derived class object are sliced off  discard   form the base class object   class Base    int x       class Derived   public Base     int z         int main      Derived d  Base b   d     Object Slicing   z of d is sliced off

User · Answer

These are all good answers  I would just like to add an execution example when passing objects by value vs by reference    include  lt iostream gt   using namespace std      Base class class A   public      A          A const A amp  a            cout  lt  lt    A  copy constructor   lt  lt  endl            virtual void run   const   cout  lt  lt   I am an  A    lt  lt  endl           Derived class class B  public A   public      B   A          B const B amp  a  A a            cout  lt  lt    B  copy constructor   lt  lt  endl            virtual void run   const   cout  lt  lt   I am a  B    lt  lt  endl        void g const A  amp  a        a run       void h const A a        a run       int main         cout  lt  lt   Call by reference   lt  lt  endl      g B         cout  lt  lt  endl  lt  lt   Call by copy   lt  lt  endl      h B         The output is   Call by reference I am a  B   Call by copy  A  copy constructor I am an  A

User · Answer

Slicing means that the data added by a subclass are discarded when an object of the subclass is passed or returned by value or from a function expecting a base class object       Explanation  Consider the following class declaration              class baseclass                                                   baseclass  amp  operator   const baseclass amp                     baseclass const baseclass amp                          void function                                baseclass obj1 m                  obj1 m                As baseclass copy functions don t know anything about the derived only the base part of the derived is copied  This is commonly referred to as slicing

User · Answer

Third match in google for  C   slicing  gives me this Wikipedia article http   en wikipedia org wiki Object slicing and this  heated  but the first few posts define the problem    http   bytes com forum thread163565 html  So it s when you assign an object of a subclass to the super class  The superclass knows nothing of the additional information in the subclass  and hasn t got room to store it  so the additional information gets  sliced off    If those links don t give enough info for a  good answer  please edit your question to let us know what more you re looking for

User · Answer

It seems to me  that slicing isn t so much a problem other than when your own classes and program are poorly architected designed   If I pass a subclass object in as a parameter to a method  which takes a parameter of type superclass  I should certainly be aware of that and know the internally  the called method will be working with the superclass  aka baseclass  object only   It seems to me only the unreasonable expectation that providing a subclass where a baseclass is requested  would somehow result in subclass specific results  would cause slicing to be a problem   Its either poor design in the use of the method or a poor subclass implementation   I m guessing its usually the result of sacrificing good OOP design in favor of expediency or performance gains

User · Answer

It seems to me  that slicing isn t so much a problem other than when your own classes and program are poorly architected designed   If I pass a subclass object in as a parameter to a method  which takes a parameter of type superclass  I should certainly be aware of that and know the internally  the called method will be working with the superclass  aka baseclass  object only   It seems to me only the unreasonable expectation that providing a subclass where a baseclass is requested  would somehow result in subclass specific results  would cause slicing to be a problem   Its either poor design in the use of the method or a poor subclass implementation   I m guessing its usually the result of sacrificing good OOP design in favor of expediency or performance gains

User · Answer

OK  I ll give it a try after reading many posts explaining object slicing but not how it becomes problematic    The vicious scenario that can result in memory corruption is the following    Class provides  accidentally  possibly compiler-generated  assignment on a polymorphic base class  Client copies and slices an instance of a derived class  Client calls a virtual member function that accesses the sliced-off state

User · Answer

class A         int x         class B         B      x 1   c  a            int x       char c         int main            A a       B b       a   b         b c     a  is  sliced  off     return 0

User · Answer

The slicing problem is serious because it can result in memory corruption  and it is very difficult to guarantee a program does not suffer from it  To design it out of the language  classes that support inheritance should be accessible by reference only  not by value   The D programming language has this property   Consider class A  and class B derived from A  Memory corruption can happen if the A part has a pointer p  and a B instance that points p to B s additional data  Then  when the additional data gets sliced off  p is pointing to garbage

User · Answer

The slicing problem in C   arises from the value semantics of its objects  which remained mostly due to compatibility with C structs  You need to use explicit reference or pointer syntax to achieve  normal  object behavior found in most other languages that do objects  i e   objects are always passed around by reference   The short answers is that you slice the object by assigning a derived object to a base object by value  i e  the remaining object is only a part of the derived object  In order to preserve value semantics  slicing is a reasonable behavior and has its relatively rare uses  which doesn t exist in most other languages  Some people consider it a feature of C    while many considered it one of the quirks misfeatures of C

User · Answer

Most answers here fail to explain what the actual problem with slicing is  They only explain the benign cases of slicing  not the treacherous ones  Assume  like the other answers  that you re dealing with two classes A and B  where B derives  publicly  from A   In this situation  C   lets you pass an instance of B to  A s assignment operator  and also to the copy constructor   This works because an instance of B can be converted to a const A amp   which is what assignment operators and copy-constructors expect their arguments to be   The benign case  B b  A a   b    Nothing bad happens there - you asked for an instance of A which is a copy of B  and that s exactly what you get  Sure  a won t contain some of b s members  but how should it  It s an A  after all  not a B  so it hasn t even heard about these members  let alone would be able to store them   The treacherous case  B b1  B b2  A amp  a ref   b2  a ref   b1    b2 now contains a mixture of b1 and b2    You might think that b2 will be a copy of b1 afterward  But  alas  it s not  If you inspect it  you ll discover that b2 is a Frankensteinian creature  made from some chunks of b1  the chunks that B inherits from A   and some chunks of b2  the chunks that only B contains   Ouch   What happened  Well  C   by default doesn t treat assignment operators as virtual  Thus  the line a ref   b1 will call the assignment operator of A  not that of B  This is because  for non-virtual functions  the declared  formally  static  type  which is A amp   determines which function is called  as opposed to the actual  formally  dynamic  type  which would be B  since a ref references an instance of B   Now  A s assignment operator obviously knows only about the members declared in A  so it will copy only those  leaving the members added in B unchanged   A solution  Assigning only to parts of an object usually makes little sense  yet C    unfortunately  provides no built-in way to forbid this  You can  however  roll your own  The first step is making the assignment operator virtual  This will guarantee that it s always the actual type s assignment operator which is called  not the declared type s  The second step is to use dynamic cast to verify that the assigned object has a compatible type  The third step is to do the actual assignment in a  protected   member assign    since B s assign   will probably want to use A s assign   to copy A s  members   class A   public    virtual A amp  operator   const A amp  a        assign a       return  this       protected    void assign const A amp  a           copy members of A from a to this         class B   public A   public    virtual B amp  operator   const A amp  a        if  const B  b   dynamic cast lt const B  gt   amp a         assign  b       else       throw bad assignment        return  this       protected    void assign const B amp  b        A  assign b      Let A s assign   copy members of A from b to this        copy members of B from b to this          Note that  for pure convenience  B s operator  covariantly overrides the return type  since it knows that it s returning an instance of B

User · Answer

The slicing problem in C   arises from the value semantics of its objects  which remained mostly due to compatibility with C structs  You need to use explicit reference or pointer syntax to achieve  normal  object behavior found in most other languages that do objects  i e   objects are always passed around by reference   The short answers is that you slice the object by assigning a derived object to a base object by value  i e  the remaining object is only a part of the derived object  In order to preserve value semantics  slicing is a reasonable behavior and has its relatively rare uses  which doesn t exist in most other languages  Some people consider it a feature of C    while many considered it one of the quirks misfeatures of C

User · Answer

Slicing means that the data added by a subclass are discarded when an object of the subclass is passed or returned by value or from a function expecting a base class object       Explanation  Consider the following class declaration              class baseclass                                                   baseclass  amp  operator   const baseclass amp                     baseclass const baseclass amp                          void function                                baseclass obj1 m                  obj1 m                As baseclass copy functions don t know anything about the derived only the base part of the derived is copied  This is commonly referred to as slicing

User · Answer

I see all the answers mention when object slicing happens when data members are sliced  Here I give an example that the methods are not overridden  class A  public      virtual void Say            std  cout lt  lt  quot I am A quot  lt  lt std  endl            class B  public A  public      void Say   override          std  cout lt  lt  quot I am B quot  lt  lt std  endl            int main       B b     A a1     A a2 b      b Say       I am B    a1 Say       I am A    a2 Say       I am A   why       B  object b  is derived from A  object a1 and a2   b and a1  as we expect  call their member function  But from polymorphism viewpoint we don   t expect a2  which is assigned by b  to not be overridden  Basically  a2 only saves A-class part of b and that is object slicing in C    To solve this problem  a reference or pointer should be used  A amp  a2 b   a2 Say       I am B  or A  a2    amp b  a2- gt Say       I am B  For more details see my post

User · Answer

If You have a base class A and a derived class B  then You can do the following   void wantAnA A myA          work with myA    B derived     work with the object  derived  wantAnA derived     Now the method wantAnA needs a copy of derived  However  the object derived cannot be copied completely  as the class B could invent additional member variables which are not in its base class A   Therefore  to call wantAnA  the compiler will  slice off  all additional members of the derived class  The result might be an object you did not want to create  because   it may be incomplete  it behaves like an A-object  all special behaviour of the class B is lost

[c++] What is object slicing?

Examples related to c++

Examples related to inheritance

Examples related to c++-faq

Examples related to object-slicing