Q:

Passing derived class to a function of base class argument

I have this code:
#include <iostream>

class Base {
  public:
  virtual void sayHello() {
    std::cout << "Hello world, I am Base" << std::endl;
  }
};

class Derived: public Base {
  public:
  void sayHello() {
    std::cout << "Hello world, I am Derived" << std::endl;
  }
};

void testPointer(Base *obj) {
  obj->sayHello();
}

void testReference(Base &obj) {
  obj.sayHello();
}

void testObject(Base obj) {
  obj.sayHello();
}

int main() {
  {
    std::cout << "Testing with pointer argument: ";
    Derived *derived = new Derived;
    testPointer(derived);
  }
  {
    std::cout << "Testing with reference argument: ";
    Derived derived;
    testReference(derived);
  }
  {
    std::cout << "Testing with object argument: ";
    Derived derived;
    testObject(derived);
  }
}

The output is:
Testing with pointer argument: Hello world, I am Derived
Testing with reference argument: Hello world, I am Derived
Testing with object argument: Hello world, I am Base

My question is why both the pointer case void testPointer(Base *obj) and the reference case void testReference(Base &obj) return the result of derived instance of void sayHello() but not and the pass by copy case?  What should I do to make the copy case to return the result of the derived class function void sayHello()? 

A:

A function taking a reference or pointer refers to the original object passed in, while by-value arguments will create a copy of your object.   Since you are only copying the base part (since it takes a base object), you end up working with a copy of just the base part, and it acts like a base because it is a base. 
This "base-only" copying is called "slicing" because it only copies part of your object, "slicing off" the derived part.