Неявное приведение тернарного оператора к базовому классу

In other words, why does Base* obj = foo; work without a cast but using the ?: operator doesn't?

Тип условного выражения не зависит от того, чему оно присвоено. В вашем случае компилятор должен иметь возможность оценивать !bar ? foo : bar; независимо от того, чему он назначен.

В вашем случае это проблема, поскольку ни foo, преобразованный в тип bar, ни bar не может быть преобразован в тип foo.

Is it because it's not clear that I want to use the Base part?

Точно.

Цитата из стандартного черновика C++ N4296, раздел 5.16 Условный оператор, параграф 6.3:

• One or both of the second and third operands have pointer type; pointer conversions (4.10) and qualification conversions (4.4) are performed to bring them to their composite pointer type (Clause 5). The result is of the composite pointer type.

Раздел 5 Выражения, пункты 13.8 и 13.9:

The composite pointer type of two operands p1 and p2 having types T1 and T2, respectively, where at least one is a pointer or pointer to member type or std::nullptr_t, is:

• if T1 and T2 are similar types (4.4), the cv-combined type of T1 and T2;
• otherwise, a program that necessitates the determination of a composite pointer type is ill-formed.

Примечание: я скопировал здесь 5 / 13.8, чтобы показать вам, что это не работает. Фактически, это 5 / 13.9, «программа плохо сформирована».

И Раздел 4.10 Преобразования указателей, Параграф 3:

A prvalue of type “pointer to cv D”, where D is a class type, can be converted to a prvalue of type “pointer to cv B”, where B is a base class (Clause 10) of D. If B is an inaccessible (Clause 11) or ambiguous (10.2) base class of D, a program that necessitates this conversion is ill-formed. The result of the conversion is a pointer to the base class subobject of the derived class object. The null pointer value is converted to the null pointer value of the destination type.

Итак, не имеет значения (вообще), что и Foo, и Bar являются производными от одного и того же базового класса. Имеет значение только то, что указатель на Foo и указатель на Bar не могут быть преобразованы друг в друга (нет отношения наследования).

Разрешение преобразования в базовый тип указателя для условного оператора звучит неплохо, но на практике было бы проблематично.

В вашем примере

struct Base {};
struct Foo : Base {};
struct Bar : Base {};

Может показаться, что очевидным выбором будет cond ? foo : bar в качестве типа Base*.

Но эта логика не подходит для общего случая.

Например.:

struct TheRealBase {};
struct Base : TheRealBase {};
struct Foo : Base {};
struct Bar : Base {};

Должен ли cond ? foo : bar быть типа Base* или типа TheRealBase*?

Как насчет:

struct Base1 {};
struct Base2 {};
struct Foo : Base1, Base2 {};
struct Bar : Base1, Base2 {};

Какого типа теперь должен быть cond ? foo : bar?

Или как насчет сейчас:

struct Base {};

struct B1 : Base {};
struct B2 : Base {};

struct X {};

struct Foo : B1, X {};
struct Bar : B2, X {};


      Base
      /  \
     /    \   
    /      \
  B1        B2 
   |   X    |
   | /   \  |
   |/     \ |
  Foo      Bar

Ой !! Удачи в рассуждении типа cond ? foo : bar. Я знаю, некрасиво, уродливо, непрактично и достойно охоты, но в стандарте все равно должны быть правила для этого.

Вы уловили суть.

Также имейте в виду, что std::common_type определяется в терминах правил условных операторов.

Since an implicit cast to a Base* exists, what is preventing the compiler from doing so?

Согласно [expr.cond] / 7,

Lvalue-to-rvalue, array-to-pointer, and function-to-pointer standard conversions are performed on the second and third operands. After those conversions, one of the following shall hold:

• ...
• One or both of the second and third operands have pointer type; pointer conversions, function pointer conversions, and qualification conversions are performed to bring them to their composite pointer type. The result is of the composite pointer type.

где тип составного указателя определено в [expr.type] / 4:

The composite pointer type of two operands p1 and p2 having types T1 and T2, respectively, where at least one is a pointer or pointer-to-member type or std​::​nullptr_­t, is:

• if both p1 and p2 are null pointer constants, std​::​nullptr_­t;

• if either p1 or p2 is a null pointer constant, T2 or T1, respectively;

• if T1 or T2 is “pointer to cv1 void” and the other type is “pointer to cv2 T”, where T is an object type or void, “pointer to cv12 void”, where cv12 is the union of cv1 and cv2;

• if T1 or T2 is “pointer to noexcept function” and the other type is “pointer to function”, where the function types are otherwise the same, “pointer to function”;

• if T1 is “pointer to cv1 C1” and T2 is “pointer to cv2 C2”, where C1 is reference-related to C2 or C2 is reference-related to C1, the cv-combined type of T1 and T2 or the cv-combined type of T2 and T1, respectively;

• if T1 is “pointer to member of C1 of type cv1 U1” and T2 is “pointer to member of C2 of type cv2 U2” where C1 is reference-related to C2 or C2 is reference-related to C1, the cv-combined type of T2 and T1 or the cv-combined type of T1 and T2, respectively;

• if T1 and T2 are similar types, the cv-combined type of T1 and T2;

• otherwise, a program that necessitates the determination of a composite pointer type is ill-formed.

Теперь вы можете видеть, что указатель на «общую базу» не является типом составного указателя.

In other words, why does Base* obj = foo; work without a cast but using the ?: operator doesn't? Is it because it's not clear that I want to use the Base part?

Проблема в том, что правило должно определять тип условного выражения независимо, без соблюдения инициализации.

Чтобы быть конкретным, правило должно определять, что условные выражения в следующих двух операторах относятся к одному типу.

Base* obj = !bar ? foo : bar;
bar ? foo : bar;

Теперь, если у вас нет сомнений в том, что условное выражение во втором утверждении имеет неправильный формат ¹, каковы причины, по которым оно правильно сформировано в первом утверждении?

_{¹ Of course one can make a rule to make such expression well-formed. For example, let composite pointer types include the pointer to an unambiguous base type. However, this is something beyond this question, and should be discussed by ISO C++ committee.}