Out of the many rules of C++, some annoyanced do come up. Here’s one that I think confuses some people.

In the following code, the two lines assigning to “b” look the same but they do different things:

FooDerived d1;
FooDerived d2;

FooBase& b = d1;
b = d2;

When assigning d2 , the object gets sliced! “But the type of “b” has not changed between calls!” you might cry. Yep, that’s the annoying part.

If we run this code:

struct FooBase {
  FooBase(int nx) : x(nx) {}
  int x;
};

struct FooDerived : public FooBase {
  FooDerived(int nx, int ny) : FooBase(nx), y(ny) {}
  int y;
};

void check_FooDerived(FooDerived *d) {
  std::cout << "x = " << d->x << " __ y = " << d->y << '\n';
}

int main() {
  FooDerived *pd;

  FooDerived d1(1001, 1001);
  FooDerived d2(2002, 2002);

  FooBase &b = d1;

  pd = static_cast<FooDerived *>(&b);
  check_FooDerived(pd);

  b = d2;

  pd = static_cast<FooDerived *>(&b);
  check_FooDerived(pd);

  return 0;
}

The output is:

x = 1001 __ y = 1001
x = 2002 __ y = 1001

The first time we assign to b, what in fact happens is the object is directly referenced to, since a reference is actually being constructed (not assigned to). You can’t even declare a reference in code without assigning to it immediately, as it will be a compiler error.

However the second time we assign to b, now it becomes a proper lvalue, and the assignment operator is called on the static type (which is FooBase). This only copies the “x” variable, and not the “y” (since it doesn’t exist in FooBase), thus it stays unchanged for the second check.

This might confuse people learning C++, since in both cases “we are assigning to a reference” !

Next thing to note is that a reference declared as a function parameter is considered being initilized when you pass a value to it. That’s why the following code will not slice the object:

void check_fd2(FooBase &b) {
  FooDerived *pd = static_cast<FooDerived *>(&b);
  check_FooDerived(pd);
}

int main() {
  //.... same code as before

  check_fd2(d2);

  //.... same code as before
}

Output:

x = 1001 __ y = 1001
x = 2002 __ y = 2002

This is because calling a function with a parameter by reference will behave in the same way as a declaration, so the reference will be constructed directly, thus it will reference to the same actual object “d2”.