Виртуальные функции в конструкторах, почему языки отличаются?

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

C++ путем, я думаю, имеет больше смысла, но приводит к проблемам ожидания, когда кто-то рассматривает Ваш код. Если Вы знаете об этой ситуации, Вы не должны намеренно помещать свой код в эту ситуацию для пользы более поздней отладки.

Виртуальные функции в конструкторах, почему языки отличаются?

Поскольку нет никакого хорошего поведения. Я нахожу, что поведение C++ имеет больше смысла (так как c-скалистые-вершины базового класса называют первыми, это выдерживает обосновать, что они должны вызвать виртуальные функции базового класса - в конце концов, c-скалистая-вершина производного класса еще не работала, таким образом, это не могло настроить правильные предварительные условия для виртуальной функции производного класса).

Но иногда, где я хочу использовать виртуальные функции для инициализации состояния (таким образом, не имеет значения, что их называют с неинициализированным состоянием) поведение C#/Java более хорошо.

Я думаю, что C++ предлагает лучшую семантику с точки зрения наличия 'самого корректного' поведения... однако это - больше работы для компилятора, и код definitiely неинтуитивный кому-то читающему его позже.

С подходом.NET функция должна быть очень ограничена для не доверия любому состоянию производного объекта.

Delphi хорошо использует виртуальных конструкторов в платформе GUI VCL:

type
  TComponent = class
  public
    constructor Create(AOwner: TComponent); virtual; // virtual constructor
  end;

  TMyEdit = class(TComponent)
  public
    constructor Create(AOwner: TComponent); override; // override virtual constructor
  end;

  TMyButton = class(TComponent)
  public
    constructor Create(AOwner: TComponent); override; // override virtual constructor
  end;

  TComponentClass = class of TComponent;

function CreateAComponent(ComponentClass: TComponentClass; AOwner: TComponent): TComponent;
begin
  Result := ComponentClass.Create(AOwner);
end;

var
  MyEdit: TMyEdit;
  MyButton: TMyButton;
begin
  MyEdit := CreateAComponent(TMyEdit, Form) as TMyEdit;
  MyButton := CreateAComponent(TMyButton, Form) as TMyButton;
end;

Я нашел поведение C++ очень раздражающим. Вы не можете записать, что виртуальные функции к, например, возвращают желаемый размер объекта и имеют конструктора по умолчанию, инициализируют каждый объект. Например, было бы хорошо сделать:

BaseClass() { for (int i=0; i<virtualSize(); i++) initialize_stuff_for_index(i); }

С другой стороны преимущество поведения C++ состоит в том, что оно препятствует constuctors как вышеупомянутое от того, чтобы быть записанным.

Я не думаю проблема вызывающих методов, которые предполагают, что конструктор был закончен, хорошее оправдание за C++. Если бы это действительно было проблемой затем, то конструктору не разрешили бы назвать методы, так как та же проблема может относиться к методам за базовый класс.

Другая точка против C++ - то, что поведение намного менее эффективно. Хотя конструктор знает непосредственно, что это называет, vtab указатель должен быть изменен для каждого класса от основы до финала, потому что конструктор мог бы назвать другие методы, которые вызовут виртуальные функции. На основе моего опыта это тратит впустую намного больше времени, чем сохраняется путем совершения вызовов виртуальных функций в более эффективном конструкторе.

Намного более раздражающий то, что это также верно для деструкторов. Если Вы пишете виртуальную очистку () функция, и деструктор базового класса делает очистку (), это, конечно, не делает то, что Вы ожидаете.

Это и то, что деструкторы вызовов C++ на статических объектах на выходе имеют действительно pissed меня прочь в течение долгого времени.