Here is an example:

 class Shape {public:	Shape() { };	virtual void draw() {};};class Circle : public Shape {private:	int m_iRadius;public:	Circle(int iRadius){ m_iRadius = iRadius; }	virtual void draw() { /*do drawing*/}	int GetRadius(){ return m_iRadius; }};void funcx(Shape shape) { /*do something*/}

Now, what if we try this:

 Circle circle(2);funcx(circle); //Pass a Circle as parameter, when function expects a Shape

Will this result in an error? No. Because Circle is derived from Shape, the compiler will generate a default assignment operator and will copy all the fields common to Circle and Shape. But the m_iRadius field will be lost and there is no way it can be used in funcx.

Another problem is the loss of type information. This may result in undesirable behavior by virtual functions. This phenomenon is called slicing. It is common in exception handling, when exceptions are caught using base class. It is used either to avoid multiple catch blocks or when the types of possible thrown exception is unknown.

 class CException {};class CMemoryException : public CException {};class CFileException: public CException{};try{ /*do something silly*/ }catch(CException exception) {/*handle exception*/}

To avoid slicing, change the operations so they use pointer or reference to the base class object rather then the base class object itself. In the given sample code, funcx can be changed so that it takes a pointer/reference to Shape as a parameter rather than Shape:

 void funcx(Shape *shape) { /*do something*/}

Inside the function body, this pointer can be safely type-casted to a Circle pointer to access Circle specific information:

 dynamic_cast(shape)->GetRadius();