Сокращение сложности кода для GWT

Оператор присваивания не требуется, чтобы быть сделанным виртуальным.

обсуждение ниже - приблизительно operator=, но оно также относится к любому оператору, перегружающемуся, который берет в рассматриваемом типе, и любая функция, которая берет в рассматриваемом типе.

ниже обсуждения показывает, что виртуальное ключевое слово не знает о наследовании параметра в отношении нахождения подписи функции соответствия. В заключительном примере это показывает, как правильно обработать присвоение при контакте с наследованными типами.

Виртуальные функции не знают о наследовании параметра:

подпись функции А должна быть тем же для виртуального, чтобы сыграть роль. Таким образом даже при том, что в следующем примере, оператор = сделан виртуальным, вызов никогда не будет действовать как виртуальная функция в D, потому что параметры и возвращаемое значение оператора = отличаются.

функция B::operator=(const B& right) и D::operator=(const D& right) на 100% полностью отличается и рассматривается как 2 отличных функции.

class B
{
public:
  virtual B& operator=(const B& right)
  {
    x = right.x;
    return *this;
  }

  int x;

};

class D : public B
{
public:
  virtual D& operator=(const D& right)
  {
    x = right.x;
    y = right.y;
    return *this;
  }
  int y;
};

Значения по умолчанию и перегрузка 2 операторы:

Вы можете, хотя определяют виртуальную функцию, чтобы позволить Вам устанавливать значения по умолчанию для D, когда он присвоен переменной типа B. Это - то, даже если Ваша переменная B является действительно D, сохраненным в ссылку B. Вы не доберетесь эти D::operator=(const D& right) функция.

В ниже случая, присвоения от 2 объектов D, хранивших в 2 ссылках B... эти D::operator=(const B& right), переопределение используется.

//Use same B as above

class D : public B
{
public:
  virtual D& operator=(const D& right)
  {
    x = right.x;
    y = right.y;
    return *this;
  }


  virtual B& operator=(const B& right)
  {
    x = right.x;
    y = 13;//Default value
    return *this;
  }

  int y;
};


int main(int argc, char **argv) 
{
  D d1;
  B &b1 = d1;
  d1.x = 99;
  d1.y = 100;
  printf("d1.x d1.y %i %i\n", d1.x, d1.y);

  D d2;
  B &b2 = d2;
  b2 = b1;
  printf("d2.x d2.y %i %i\n", d2.x, d2.y);
  return 0;
}

Печать:

d1.x d1.y 99 100
d2.x d2.y 99 13

, Который показывает, что D::operator=(const D& right) никогда не используется.

Без виртуального ключевого слова на [1 110] у Вас были бы те же результаты как выше, но значение y не будет инициализировано. Т.е. это использовало бы B::operator=(const B& right)

Один последний шаг для связывания всего этого, RTTI:

можно использовать RTTI для надлежащей обработки виртуальных функций, которые берут в типе. Вот последняя часть загадки, которая выяснит, как правильно обработать присвоение при контакте с возможно наследованными типами.

virtual B& operator=(const B& right)
{
  const D *pD = dynamic_cast<const D*>(&right);
  if(pD)
  {
    x = pD->x;
    y = pD->y;
  }
  else
  {
    x = right.x;
    y = 13;//default value
  }

  return *this;
}