Передача `this` до завершения базовых конструкторов: UB или просто опасно?

Ответ на этот вопрос содержится непосредственно в стандарте С++ 3.8/5:

До того, как время жизни объекта началось, но после того, как память, которую будет занимать объект, была выделена, или после того, как время жизни объекта закончилось и до того, как память, которую занимает объект, будет повторно использована или освобождена, любой указатель, который ссылается на память место, где объект будет или находился, может быть использовано, но только ограниченным образом. Для строящегося или разрушаемого объекта см. 12.7. В противном случае такой указатель ссылается на выделенное хранилище (3.7.4.2), и использование указателя, как если бы указатель был типа void*, четко определен. Такой указатель может быть разыменован, но результирующее значение lvalue может использоваться только ограниченными способами, как описано ниже. Программа имеет неопределенное поведение, если:

• объект будет или был типа класса с нетривиальным деструктором, а указатель используется как операнд выражения удаления,
• the pointer is used to access a non-static data member or call a non-static member function of the object, or
• the pointer is implicitly converted (4.10) to a pointer to a base class type, or
• указатель используется в качестве операнда static_cast (5.2.9) (за исключением случаев, когда преобразование выполняется в void* или в void* и впоследствии в char* или unsigned char*), или
• указатель используется как операнд dynamic_cast (5.2.7).

Кроме того, в 12.7/3:

Для явного или неявного преобразования указателя (glvalue), ссылающегося на объект класса X, в указатель (ссылку) на прямой или косвенный базовый класс B X, построение X и построение всех его прямых или косвенных оснований которые прямо или косвенно происходят от B, должны быть запущены, и уничтожение этих классов не должно быть завершено, в противном случае преобразование приводит к неопределенному поведению.

Это не УБ. Объект может быть еще не инициализирован должным образом (поэтому его использование сразу может оказаться невозможным), но сохранение указателя на потом вполне допустимо.

Мне пришлось бы передать *this, но в этом случае оператор deref ничего не сделал бы.

Конечно, это было бы разыменованием указателя. Помните, что инициализация — это не то же самое, что выделение — когда конструктор запускается, объект уже правильно выделен (иначе вы не смогли бы его инициализировать) — т. е. он существует, но находится в неопределенном состоянии, пока не завершится его конструктор.

Поведение не является неопределенным и не обязательно опасным.

Ни Foo, ни Bar не делают никаких проблем с полученными указателями.

Это ключ: вам просто нужно знать, что объект, на который указывает указатель, еще не полностью построен.

Что, если бы Foo::Foo(Bar*) было Foo::Foo(Bar&) с той же семантикой?

На самом деле между ними нет никакой разницы, если говорить об опасности или определенности.

Это хороший вопрос. Если мы прочитаем §3.8, время жизни объекта с нетривиальным конструктором начинается только после завершения конструктора (завершена инициализация). А несколькими абзацами позже стандарт разграничивает, что мы можем и что не можем делать с указателем до того, как началось время жизни объекта, но после того, как память, которую будет занимать объект, будет выделена (и указатель this в списке инициализации наверняка покажется вписаться в эту категорию, учитывая приведенное выше определение): в частности

Программа имеет неопределенное поведение, если:

[...]

• указатель неявно преобразуется в указатель на тип базового класса или

[...]

В вашем примере тип указателя в параметре базового класса имеет тип базового класса, поэтому указатель this производного класса должен быть неявно преобразован в него. Что является неопределенным поведением в соответствии с вышеизложенным. Но... чтобы вызвать конструктор базового класса, компилятор должен неявно преобразовать адрес в указатель типа на базовый класс. Так что должны быть какие-то исключения.

На практике я ни разу не знал, чтобы компилятор в этом случае дал сбой, за исключением случаев, когда задействовано виртуальное наследование; Я определенно сталкивался с ошибками со следующим шаблоном:

class L;
class VB {};
class R : virtual VB { public: R( L* ); }
class L { L( char const* p ); };
class D : private virtual L, private virtual R { D(); }
D::D( char const* p ) : L( p ), R( this ) {}

Почему у компилятора были проблемы здесь, я не знаю. Он смог правильно преобразовать указатель, чтобы передать его как указатель this конструктору L, но не сделал этого правильно при передаче его в R.

В этом случае обходной путь состоял в том, чтобы предоставить класс-оболочку для L с функцией-членом, которая возвращала указатель, например:

class LW : public L
{
public:
    LW( char const* p ) : L( p ) {}
    L* getAddress() { return this; }
};

D::D( char const* p ) : L( p ), R( this->getAddress(); ) {}

Результатом всего этого является то, что я не могу дать вам однозначный ответ, потому что не уверен, что имели в виду авторы стандарта. С другой стороны, я действительно видел случаи, когда это не срабатывало (и не так давно).