C++按值和按引用比较运算符的多态性

Question

我想比较从相同基类型派生但不是相同派生类的两个对象。因此，我将 == 运算符设为虚拟并在派生类中覆盖它。

当我将所有对象存储在基本类型的数组中时，不会调用派生实现，它直接进入基本实现。但是，当数组是指向基类的指针类型并且取消引用元素时，它确实可以工作。

有人可以解释一下为什么会出现这种行为吗？这让我很困惑;-)

enum eType {
  BASE_TYPE,
  DERIVED_TYPE
};

class A {
  eType mType;
public:
  A() : mType(BASE_TYPE) {}
  A(eType Type) : mType(Type) {}
  virtual bool operator == (A &Other) {
    return mType == Other.mType;
  }
};

class B : public A {
  int bVal;
public:
  B(int Val) : A(DERIVED_TYPE), bVal(Val) {}
  virtual bool operator == (A &Other) {
    if(!(A::operator ==(Other))) {
      return false;
    }
    B* myB = (B*)&Other;
    return bVal == myB->bVal;
  }
};

int main(int argc, char *argv[])
{
  A a1, a2;
  B b1(0);
  B b2(1);

  bool result = false;

  // Calls implementation in A
  result = (a1 == a2);
  // Calls implementation in B
  result = (b1 == b2);

  A aArray[2];
  aArray[0] = b1;
  aArray[1] = b2;

  // Calls implementation in A!
  result = (aArray[0] == aArray[1]);

  A *aRefArray[2];
  aRefArray[0] = &b1;
  aRefArray[1] = &b2;

  // Calls implementation in B
  result = ((*aRefArray[0]) == (*aRefArray[1]));

  return 0;
}

Answer 1

  A aArray[2];
  aArray[0] = b1;
  aArray[1] = b2;

当您这样做时，对象切片需要放置并且对象的派生部分刚刚被剥离。现在存储在数组中的对象现在仅表现为基类的对象。当然，操作符函数的基类版本会被调用。

---

  A *aRefArray[2];
  aRefArray[0] = &b1;
  aRefArray[1] = &b2;

适当地，保留派生类对象的类型，因为存储在数组中的只是指向实际对象的指针，而不是对象本身。
由于保留了对象的类型，因此在这种情况下将调用运算符函数的派生类版本。